home *** CD-ROM | disk | FTP | other *** search
/ OpenStep (Enterprise) / OpenStepENTCD.toast / OEDEV / GNUSRC.Z / glob.c < prev    next >
C/C++ Source or Header  |  1996-01-11  |  17KB  |  701 lines
  1. /* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
  2.  
  3. This library is free software; you can redistribute it and/or
  4. modify it under the terms of the GNU Library General Public License as
  5. published by the Free Software Foundation; either version 2 of the
  6. License, or (at your option) any later version.
  7.  
  8. This library is distributed in the hope that it will be useful,
  9. but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11. Library General Public License for more details.
  12.  
  13. You should have received a copy of the GNU Library General Public
  14. License along with this library; see the file COPYING.LIB.  If
  15. not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  16. Cambridge, MA 02139, USA.  */
  17.  
  18. /* AIX requires this to be the first thing in the file.  */
  19. #if defined (_AIX) && !defined (__GNUC__)
  20.  #pragma alloca
  21. #endif
  22.  
  23. #ifdef    HAVE_CONFIG_H
  24. #include <config.h>
  25. #endif
  26.  
  27. #include <errno.h>
  28. #include <sys/types.h>
  29. #include <sys/stat.h>
  30.  
  31.  
  32. /* Comment out all this code if we are using the GNU C Library, and are not
  33.    actually compiling the library itself.  This code is part of the GNU C
  34.    Library, but also included in many other GNU distributions.  Compiling
  35.    and linking in this code is a waste when using the GNU C library
  36.    (especially if it is a shared library).  Rather than having every GNU
  37.    program understand `configure --with-gnu-libc' and omit the object files,
  38.    it is simpler to just do this in the source for each such file.  */
  39.  
  40. #if defined (_LIBC) || !defined (__GNU_LIBRARY__)
  41.  
  42.  
  43. #ifdef    STDC_HEADERS
  44. #include <stddef.h>
  45. #endif
  46.  
  47. #ifdef    HAVE_UNISTD_H
  48. #include <unistd.h>
  49. #ifndef POSIX
  50. #ifdef    _POSIX_VERSION
  51. #define    POSIX
  52. #endif
  53. #endif
  54. #endif
  55.  
  56. #if !defined(__GNU_LIBRARY__) && !defined(STDC_HEADERS)
  57. extern int errno;
  58. #endif
  59.  
  60. #ifndef    NULL
  61. #define    NULL    0
  62. #endif
  63.  
  64.  
  65. #if    defined (POSIX) || defined (HAVE_DIRENT_H) || defined (__GNU_LIBRARY__)
  66. #include <dirent.h>
  67. #ifndef    __GNU_LIBRARY__
  68. #define D_NAMLEN(d) strlen((d)->d_name)
  69. #else    /* GNU C library.  */
  70. #define D_NAMLEN(d) ((d)->d_namlen)
  71. #endif    /* Not GNU C library.  */
  72. #else    /* Not POSIX or HAVE_DIRENT_H.  */
  73. #define direct dirent
  74. #define D_NAMLEN(d) ((d)->d_namlen)
  75. #ifdef    HAVE_SYS_NDIR_H
  76. #include <sys/ndir.h>
  77. #endif    /* HAVE_SYS_NDIR_H */
  78. #ifdef    HAVE_SYS_DIR_H
  79. #include <sys/dir.h>
  80. #endif    /* HAVE_SYS_DIR_H */
  81. #ifdef HAVE_NDIR_H
  82. #include <ndir.h>
  83. #endif    /* HAVE_NDIR_H */
  84. #endif    /* POSIX or HAVE_DIRENT_H or __GNU_LIBRARY__.  */
  85.  
  86. #if (defined (POSIX) || defined (WIN32)) && !defined (__GNU_LIBRARY__)
  87. /* Posix does not require that the d_ino field be present, and some
  88.    systems do not provide it. */
  89. #define REAL_DIR_ENTRY(dp) 1
  90. #else
  91. #define REAL_DIR_ENTRY(dp) (dp->d_ino != 0)
  92. #endif /* POSIX */
  93.  
  94. #if    (defined (STDC_HEADERS) || defined (__GNU_LIBRARY__))
  95. #include <stdlib.h>
  96. #include <string.h>
  97. #define    ANSI_STRING
  98. #else    /* No standard headers.  */
  99.  
  100. #ifdef HAVE_STRING_H
  101. #include <string.h>
  102. #define    ANSI_STRING
  103. #else
  104. #include <strings.h>
  105. #endif
  106. #ifdef    HAVE_MEMORY_H
  107. #include <memory.h>
  108. #endif
  109.  
  110. #ifdef WIN32
  111. extern void *malloc (), *realloc ();
  112. #else
  113. extern char *malloc (), *realloc ();
  114. #endif
  115. extern void free ();
  116.  
  117. extern void qsort ();
  118. extern void abort (), exit ();
  119.  
  120. #endif    /* Standard headers.  */
  121.  
  122. #ifndef    ANSI_STRING
  123.  
  124. #ifndef    bzero
  125. extern void bzero ();
  126. #endif
  127. #ifndef    bcopy
  128. extern void bcopy ();
  129. #endif
  130.  
  131. #define    memcpy(d, s, n)    bcopy ((s), (d), (n))
  132. #define    strrchr    rindex
  133. /* memset is only used for zero here, but let's be paranoid.  */
  134. #define    memset(s, better_be_zero, n) \
  135.   ((void) ((better_be_zero) == 0 ? (bzero((s), (n)), 0) : (abort(), 0)))
  136. #endif    /* Not ANSI_STRING.  */
  137.  
  138. #ifndef    HAVE_STRCOLL
  139. #define    strcoll    strcmp
  140. #endif
  141.  
  142.  
  143. #ifndef    __GNU_LIBRARY__
  144. #ifdef    __GNUC__
  145. __inline
  146. #endif
  147. static char *
  148. my_realloc (p, n)
  149.      char *p;
  150.      unsigned int n;
  151. {
  152.   /* These casts are the for sake of the broken Ultrix compiler,
  153.      which warns of illegal pointer combinations otherwise.  */
  154.   if (p == NULL)
  155.     return (char *) malloc (n);
  156.   return (char *) realloc (p, n);
  157. }
  158. #define    realloc    my_realloc
  159. #endif
  160.  
  161.  
  162. #if    !defined(__alloca) && !defined(__GNU_LIBRARY__)
  163.  
  164. #ifdef    __GNUC__
  165. #undef    alloca
  166. #define    alloca(n)    __builtin_alloca (n)
  167. #else    /* Not GCC.  */
  168. #if    defined (sparc) || defined (HAVE_ALLOCA_H)
  169. #include <alloca.h>
  170. #else    /* Not sparc or HAVE_ALLOCA_H.  */
  171. #ifndef    _AIX
  172. extern char *alloca ();
  173. #endif    /* Not _AIX.  */
  174. #endif    /* sparc or HAVE_ALLOCA_H.  */
  175. #endif    /* GCC.  */
  176.  
  177. #define    __alloca    alloca
  178.  
  179. #endif
  180.  
  181. #ifndef __GNU_LIBRARY__
  182. #define __lstat lstat
  183. #ifndef HAVE_LSTAT
  184. #define lstat stat
  185. #endif
  186. #ifdef STAT_MACROS_BROKEN
  187. #undef S_ISDIR
  188. #endif
  189. #ifndef S_ISDIR
  190. #define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
  191. #endif
  192. #endif
  193.  
  194. #ifndef    STDC_HEADERS
  195. #undef    size_t
  196. #define    size_t    unsigned int
  197. #endif
  198.  
  199. /* Some system header files erroneously define these.
  200.    We want our own definitions from <fnmatch.h> to take precedence.  */
  201. #undef    FNM_PATHNAME
  202. #undef    FNM_NOESCAPE
  203. #undef    FNM_PERIOD
  204. #include <fnmatch.h>
  205.  
  206. /* Some system header files erroneously define these.
  207.    We want our own definitions from <glob.h> to take precedence.  */
  208. #undef    GLOB_ERR
  209. #undef    GLOB_MARK
  210. #undef    GLOB_NOSORT
  211. #undef    GLOB_DOOFFS
  212. #undef    GLOB_NOCHECK
  213. #undef    GLOB_APPEND
  214. #undef    GLOB_NOESCAPE
  215. #undef    GLOB_PERIOD
  216. #include <glob.h>
  217.  
  218. __ptr_t (*__glob_opendir_hook) __P ((const char *directory));
  219. const char *(*__glob_readdir_hook) __P ((__ptr_t stream));
  220. void (*__glob_closedir_hook) __P ((__ptr_t stream));
  221.  
  222. static int glob_pattern_p __P ((const char *pattern, int quote));
  223. static int glob_in_dir __P ((const char *pattern, const char *directory,
  224.                  int flags,
  225.                  int (*errfunc) __P ((const char *, int)),
  226.                  glob_t *pglob));
  227. static int prefix_array __P ((const char *prefix, char **array, size_t n));
  228. static int collated_compare __P ((const __ptr_t, const __ptr_t));
  229.  
  230. /* Do glob searching for PATTERN, placing results in PGLOB.
  231.    The bits defined above may be set in FLAGS.
  232.    If a directory cannot be opened or read and ERRFUNC is not nil,
  233.    it is called with the pathname that caused the error, and the
  234.    `errno' value from the failing call; if it returns non-zero
  235.    `glob' returns GLOB_ABEND; if it returns zero, the error is ignored.
  236.    If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
  237.    Otherwise, `glob' returns zero.  */
  238. int
  239. glob (pattern, flags, errfunc, pglob)
  240.      const char *pattern;
  241.      int flags;
  242.      int (*errfunc) __P ((const char *, int));
  243.      glob_t *pglob;
  244. {
  245.   const char *filename;
  246.   char *dirname;
  247.   size_t dirlen;
  248.   int status;
  249.   int oldcount;
  250.   
  251.   if (pattern == NULL || pglob == NULL || (flags & ~__GLOB_FLAGS) != 0)
  252.     {
  253.       errno = EINVAL;
  254.       return -1;
  255.     }
  256.  
  257.   /* Find the filename.  */
  258.   filename = strrchr (pattern, '/');
  259.   if (filename == NULL)
  260.     {
  261.       filename = pattern;
  262.       dirname = (char *) ".";
  263.       dirlen = 0;
  264.     }
  265.   else if (filename == pattern)
  266.     {
  267.       /* "/pattern".  */
  268.       dirname = (char *) "/";
  269.       dirlen = 1;
  270.       ++filename;
  271.     }
  272.   else
  273.     {
  274.       dirlen = filename - pattern;
  275.       dirname = (char *) __alloca (dirlen + 1);
  276.       memcpy (dirname, pattern, dirlen);
  277.       dirname[dirlen] = '\0';
  278.       ++filename;
  279.     }
  280.  
  281.   if (filename[0] == '\0' && dirlen > 1)
  282.     /* "pattern/".  Expand "pattern", appending slashes.  */
  283.     {
  284.       int val = glob (dirname, flags | GLOB_MARK, errfunc, pglob);
  285.       if (val == 0)
  286.     pglob->gl_flags = (pglob->gl_flags & ~GLOB_MARK) | (flags & GLOB_MARK);
  287.       return val;
  288.     }
  289.  
  290.   if (!(flags & GLOB_APPEND))
  291.     {
  292.       pglob->gl_pathc = 0;
  293.       pglob->gl_pathv = NULL;
  294.     }
  295.  
  296.   oldcount = pglob->gl_pathc;
  297.  
  298.   if (glob_pattern_p (dirname, !(flags & GLOB_NOESCAPE)))
  299.     {
  300.       /* The directory name contains metacharacters, so we
  301.      have to glob for the directory, and then glob for
  302.      the pattern in each directory found.  */
  303.       glob_t dirs;
  304.       register int i;
  305.  
  306.       status = glob (dirname,
  307.              ((flags & (GLOB_ERR | GLOB_NOCHECK | GLOB_NOESCAPE)) |
  308.               GLOB_NOSORT),
  309.              errfunc, &dirs);
  310.       if (status != 0)
  311.     return status;
  312.  
  313.       /* We have successfully globbed the preceding directory name.
  314.      For each name we found, call glob_in_dir on it and FILENAME,
  315.      appending the results to PGLOB.  */
  316.       for (i = 0; i < dirs.gl_pathc; ++i)
  317.     {
  318.       int oldcount;
  319.  
  320. #ifdef    SHELL
  321.       {
  322.         /* Make globbing interruptible in the bash shell. */
  323.         extern int interrupt_state;
  324.  
  325.         if (interrupt_state)
  326.           {
  327.         globfree (&dirs);
  328.         globfree (&files);
  329.         return GLOB_ABEND;
  330.           }
  331.       }
  332. #endif /* SHELL.  */
  333.  
  334.       oldcount = pglob->gl_pathc;
  335.       status = glob_in_dir (filename, dirs.gl_pathv[i],
  336.                 (flags | GLOB_APPEND) & ~GLOB_NOCHECK,
  337.                 errfunc, pglob);
  338.       if (status == GLOB_NOMATCH)
  339.         /* No matches in this directory.  Try the next.  */
  340.         continue;
  341.  
  342.       if (status != 0)
  343.         {
  344.           globfree (&dirs);
  345.           globfree (pglob);
  346.           return status;
  347.         }
  348.  
  349.       /* Stick the directory on the front of each name.  */
  350.       if (prefix_array (dirs.gl_pathv[i],
  351.                 &pglob->gl_pathv[oldcount],
  352.                 pglob->gl_pathc - oldcount))
  353.         {
  354.           globfree (&dirs);
  355.           globfree (pglob);
  356.           return GLOB_NOSPACE;
  357.         }
  358.     }
  359.  
  360.       flags |= GLOB_MAGCHAR;
  361.  
  362.       if (pglob->gl_pathc == oldcount)
  363.     /* No matches.  */
  364.     if (flags & GLOB_NOCHECK)
  365.       {
  366.         size_t len = strlen (pattern) + 1;
  367.         char *patcopy = (char *) malloc (len);
  368.         if (patcopy == NULL)
  369.           return GLOB_NOSPACE;
  370.         memcpy (patcopy, pattern, len);
  371.  
  372.         pglob->gl_pathv
  373.           = (char **) realloc (pglob->gl_pathv,
  374.                    (pglob->gl_pathc +
  375.                     ((flags & GLOB_DOOFFS) ?
  376.                      pglob->gl_offs : 0) +
  377.                     1 + 1) *
  378.                    sizeof (char *));
  379.         if (pglob->gl_pathv == NULL)
  380.           {
  381.         free (patcopy);
  382.         return GLOB_NOSPACE;
  383.           }
  384.  
  385.         if (flags & GLOB_DOOFFS)
  386.           while (pglob->gl_pathc < pglob->gl_offs)
  387.         pglob->gl_pathv[pglob->gl_pathc++] = NULL;
  388.  
  389.         pglob->gl_pathv[pglob->gl_pathc++] = patcopy;
  390.         pglob->gl_pathv[pglob->gl_pathc] = NULL;
  391.         pglob->gl_flags = flags;
  392.       }
  393.     else
  394.       return GLOB_NOMATCH;
  395.     }
  396.   else
  397.     {
  398.       status = glob_in_dir (filename, dirname, flags, errfunc, pglob);
  399.       if (status != 0)
  400.     return status;
  401.  
  402.       if (dirlen > 0)
  403.     {
  404.       /* Stick the directory on the front of each name.  */
  405.       if (prefix_array (dirname,
  406.                 &pglob->gl_pathv[oldcount],
  407.                 pglob->gl_pathc - oldcount))
  408.         {
  409.           globfree (pglob);
  410.           return GLOB_NOSPACE;
  411.         }
  412.     }
  413.     }
  414.  
  415.   if (flags & GLOB_MARK)
  416.     {
  417.       /* Append slashes to directory names.  glob_in_dir has already
  418.      allocated the extra character for us.  */
  419.       int i;
  420.       struct stat st;
  421.       for (i = oldcount; i < pglob->gl_pathc; ++i)
  422.     if (__lstat (pglob->gl_pathv[i], &st) == 0 &&
  423.         S_ISDIR (st.st_mode))
  424.       strcat (pglob->gl_pathv[i], "/");
  425.     }
  426.  
  427.   if (!(flags & GLOB_NOSORT))
  428.     /* Sort the vector.  */
  429.     qsort ((__ptr_t) &pglob->gl_pathv[oldcount],
  430.        pglob->gl_pathc - oldcount,
  431.        sizeof (char *), collated_compare);
  432.  
  433.   return 0;
  434. }
  435.  
  436.  
  437. /* Free storage allocated in PGLOB by a previous `glob' call.  */
  438. void
  439. globfree (pglob)
  440.      register glob_t *pglob;
  441. {
  442.   if (pglob->gl_pathv != NULL)
  443.     {
  444.       register int i;
  445.       for (i = 0; i < pglob->gl_pathc; ++i)
  446.     if (pglob->gl_pathv[i] != NULL)
  447.       free ((__ptr_t) pglob->gl_pathv[i]);
  448.       free ((__ptr_t) pglob->gl_pathv);
  449.     }
  450. }
  451.  
  452.  
  453. /* Do a collated comparison of A and B.  */
  454. static int
  455. collated_compare (a, b)
  456.      const __ptr_t a;
  457.      const __ptr_t b;
  458. {
  459.   const char *const s1 = *(const char *const * const) a;
  460.   const char *const s2 = *(const char *const * const) b;
  461.  
  462.   if (s1 == s2)
  463.     return 0;
  464.   if (s1 == NULL)
  465.     return 1;
  466.   if (s2 == NULL)
  467.     return -1;
  468.   return strcoll (s1, s2);
  469. }
  470.  
  471.  
  472. /* Prepend DIRNAME to each of N members of ARRAY, replacing ARRAY's
  473.    elements in place.  Return nonzero if out of memory, zero if successful.
  474.    A slash is inserted between DIRNAME and each elt of ARRAY,
  475.    unless DIRNAME is just "/".  Each old element of ARRAY is freed.  */
  476. static int
  477. prefix_array (dirname, array, n)
  478.      const char *dirname;
  479.      char **array;
  480.      size_t n;
  481. {
  482.   register size_t i;
  483.   size_t dirlen = strlen (dirname);
  484.  
  485.   if (dirlen == 1 && dirname[0] == '/')
  486.     /* DIRNAME is just "/", so normal prepending would get us "//foo".
  487.        We want "/foo" instead, so don't prepend any chars from DIRNAME.  */
  488.     dirlen = 0;
  489.  
  490.   for (i = 0; i < n; ++i)
  491.     {
  492.       size_t eltlen = strlen (array[i]) + 1;
  493.       /* note that eltlen needs to be one larger if MARK is set,
  494.          but we have no way of knowing this.  Allocate space for
  495.      the trailing slash in all cases just to be safe. */
  496.       char *new = (char *) malloc (dirlen + 1 + eltlen + 1);
  497.       if (new == NULL)
  498.     {
  499.       while (i > 0)
  500.         free ((__ptr_t) array[--i]);
  501.       return 1;
  502.     }
  503.  
  504.       memcpy (new, dirname, dirlen);
  505.       new[dirlen] = '/';
  506.       memcpy (&new[dirlen + 1], array[i], eltlen);
  507.       free ((__ptr_t) array[i]);
  508.       array[i] = new;
  509.     }
  510.  
  511.   return 0;
  512. }
  513.  
  514.  
  515. /* Return nonzero if PATTERN contains any metacharacters.
  516.    Metacharacters can be quoted with backslashes if QUOTE is nonzero.  */
  517. static int
  518. glob_pattern_p (pattern, quote)
  519.      const char *pattern;
  520.      int quote;
  521. {
  522.   register const char *p;
  523.   int open = 0;
  524.  
  525.   for (p = pattern; *p != '\0'; ++p)
  526.     switch (*p)
  527.       {
  528.       case '?':
  529.       case '*':
  530.     return 1;
  531.  
  532.       case '\\':
  533.     if (quote)
  534.       ++p;
  535.     break;
  536.  
  537.       case '[':
  538.     open = 1;
  539.     break;
  540.  
  541.       case ']':
  542.     if (open)
  543.       return 1;
  544.     break;
  545.       }
  546.  
  547.   return 0;
  548. }
  549.  
  550.  
  551. /* Like `glob', but PATTERN is a final pathname component,
  552.    and matches are searched for in DIRECTORY.
  553.    The GLOB_NOSORT bit in FLAGS is ignored.  No sorting is ever done.
  554.    The GLOB_APPEND flag is assumed to be set (always appends).  */
  555. static int
  556. glob_in_dir (pattern, directory, flags, errfunc, pglob)
  557.      const char *pattern;
  558.      const char *directory;
  559.      int flags;
  560.      int (*errfunc) __P ((const char *, int));
  561.      glob_t *pglob;
  562. {
  563.   __ptr_t stream;
  564.  
  565.   struct globlink
  566.     {
  567.       struct globlink *next;
  568.       char *name;
  569.     };
  570.   struct globlink *names = NULL;
  571.   size_t nfound = 0;
  572.  
  573.   if (!glob_pattern_p (pattern, !(flags & GLOB_NOESCAPE)))
  574.     {
  575.       stream = NULL;
  576.       flags |= GLOB_NOCHECK;
  577.     }
  578.   else
  579.     {
  580.       flags |= GLOB_MAGCHAR;
  581.  
  582.       stream = (__glob_opendir_hook ? (*__glob_opendir_hook) (directory)
  583.         : (__ptr_t) opendir (directory));
  584.       if (stream == NULL)
  585.     {
  586.       if ((errfunc != NULL && (*errfunc) (directory, errno)) ||
  587.           (flags & GLOB_ERR))
  588.         return GLOB_ABEND;
  589.     }
  590.       else
  591.     while (1)
  592.       {
  593.         const char *name;
  594.         size_t len;
  595.  
  596.         if (__glob_readdir_hook)
  597.           {
  598.         name = (*__glob_readdir_hook) (stream);
  599.         if (name == NULL)
  600.           break;
  601.         len = 0;
  602.           }
  603.         else
  604.           {
  605.         struct dirent *d = readdir ((DIR *) stream);
  606.         if (d == NULL)
  607.           break;
  608.         if (! REAL_DIR_ENTRY (d))
  609.           continue;
  610.         name = d->d_name;
  611. #ifdef    HAVE_D_NAMLEN
  612.         len = d->d_namlen;
  613. #else
  614.         len = 0;
  615. #endif
  616.           }
  617.         
  618.         if (fnmatch (pattern, name,
  619.              (!(flags & GLOB_PERIOD) ? FNM_PERIOD : 0) |
  620.              ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0)) == 0)
  621.           {
  622.         struct globlink *new
  623.           = (struct globlink *) __alloca (sizeof (struct globlink));
  624.         if (len == 0)
  625.           len = strlen (name);
  626.         new->name
  627.           = (char *) malloc (len + ((flags & GLOB_MARK) ? 1 : 0) + 1);
  628.         if (new->name == NULL)
  629.           goto memory_error;
  630.         memcpy ((__ptr_t) new->name, name, len);
  631.         new->name[len] = '\0';
  632.         new->next = names;
  633.         names = new;
  634.         ++nfound;
  635.           }
  636.       }
  637.     }
  638.  
  639.   if (nfound == 0 && (flags & GLOB_NOCHECK))
  640.     {
  641.       size_t len = strlen (pattern);
  642.       nfound = 1;
  643.       names = (struct globlink *) __alloca (sizeof (struct globlink));
  644.       names->next = NULL;
  645.       names->name = (char *) malloc (len + ((flags & GLOB_MARK) ? 1 : 0) + 1);
  646.       if (names->name == NULL)
  647.     goto memory_error;
  648.       memcpy (names->name, pattern, len);
  649.       names->name[len] = '\0';
  650.     }
  651.  
  652.   pglob->gl_pathv
  653.     = (char **) realloc (pglob->gl_pathv,
  654.              (pglob->gl_pathc +
  655.               ((flags & GLOB_DOOFFS) ? pglob->gl_offs : 0) +
  656.               nfound + 1) *
  657.              sizeof (char *));
  658.   if (pglob->gl_pathv == NULL)
  659.     goto memory_error;
  660.  
  661.   if (flags & GLOB_DOOFFS)
  662.     while (pglob->gl_pathc < pglob->gl_offs)
  663.       pglob->gl_pathv[pglob->gl_pathc++] = NULL;
  664.  
  665.   for (; names != NULL; names = names->next)
  666.     pglob->gl_pathv[pglob->gl_pathc++] = names->name;
  667.   pglob->gl_pathv[pglob->gl_pathc] = NULL;
  668.  
  669.   pglob->gl_flags = flags;
  670.  
  671.   if (stream != NULL)
  672.     {
  673.       int save = errno;
  674.       if (__glob_closedir_hook)
  675.     (*__glob_closedir_hook) (stream);
  676.       else
  677.     (void) closedir ((DIR *) stream);
  678.       errno = save;
  679.     }
  680.   return nfound == 0 ? GLOB_NOMATCH : 0;
  681.  
  682.  memory_error:
  683.   {
  684.     int save = errno;
  685.     if (__glob_closedir_hook)
  686.       (*__glob_closedir_hook) (stream);
  687.     else
  688.       (void) closedir ((DIR *) stream);
  689.     errno = save;
  690.   }
  691.   while (names != NULL)
  692.     {
  693.       if (names->name != NULL)
  694.     free ((__ptr_t) names->name);
  695.       names = names->next;
  696.     }
  697.   return GLOB_NOSPACE;
  698. }
  699.  
  700. #endif    /* _LIBC or not __GNU_LIBRARY__.  */
  701.