Tue Apr 2 21:27:01 1996 Andreas Schwab <schwab@issan.informatik.uni-dortmund.de>
[kopensolaris-gnu/glibc.git] / posix / glob.c
1 /* Copyright (C) 1991, 92, 93, 94, 95, 96 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 /* Enable GNU extensions in glob.h.  */
28 #ifndef _GNU_SOURCE
29 #define _GNU_SOURCE     1
30 #endif
31
32 #include <errno.h>
33 #include <sys/types.h>
34 #include <sys/stat.h>
35
36
37 /* Comment out all this code if we are using the GNU C Library, and are not
38    actually compiling the library itself.  This code is part of the GNU C
39    Library, but also included in many other GNU distributions.  Compiling
40    and linking in this code is a waste when using the GNU C library
41    (especially if it is a shared library).  Rather than having every GNU
42    program understand `configure --with-gnu-libc' and omit the object files,
43    it is simpler to just do this in the source for each such file.  */
44
45 #define GLOB_INTERFACE_VERSION 1
46 #if !defined (_LIBC) && defined (__GNU_LIBRARY__) && __GNU_LIBRARY__ > 1
47 #include <gnu-versions.h>
48 #if _GNU_GLOB_INTERFACE_VERSION == GLOB_INTERFACE_VERSION
49 #define ELIDE_CODE
50 #endif
51 #endif
52
53 #ifndef ELIDE_CODE
54
55 #ifdef  STDC_HEADERS
56 #include <stddef.h>
57 #endif
58
59 #ifdef  HAVE_UNISTD_H
60 #include <unistd.h>
61 #ifndef POSIX
62 #ifdef  _POSIX_VERSION
63 #define POSIX
64 #endif
65 #endif
66 #endif
67
68 #include <pwd.h>
69
70 #if !defined(__GNU_LIBRARY__) && !defined(STDC_HEADERS)
71 extern int errno;
72 #endif
73
74 #ifndef NULL
75 #define NULL    0
76 #endif
77
78
79 #if defined (HAVE_DIRENT_H) || defined (__GNU_LIBRARY__)
80 # include <dirent.h>
81 # define NAMLEN(dirent) strlen((dirent)->d_name)
82 #else
83 # define dirent direct
84 # define NAMLEN(dirent) (dirent)->d_namlen
85 # ifdef HAVE_SYS_NDIR_H
86 #  include <sys/ndir.h>
87 # endif
88 # ifdef HAVE_SYS_DIR_H
89 #  include <sys/dir.h>
90 # endif
91 # ifdef HAVE_NDIR_H
92 #  include <ndir.h>
93 # endif
94 #endif
95
96
97 /* In GNU systems, <dirent.h> defines this macro for us.  */
98 #ifdef _D_NAMLEN
99 #undef NAMLEN
100 #define NAMLEN(d) _D_NAMLEN(d)
101 #endif
102
103
104 #if defined (POSIX) && !defined (__GNU_LIBRARY__)
105 /* Posix does not require that the d_ino field be present, and some
106    systems do not provide it. */
107 #define REAL_DIR_ENTRY(dp) 1
108 #else
109 #define REAL_DIR_ENTRY(dp) (dp->d_ino != 0)
110 #endif /* POSIX */
111
112 #if     (defined (STDC_HEADERS) || defined (__GNU_LIBRARY__))
113 #include <stdlib.h>
114 #include <string.h>
115 #define ANSI_STRING
116 #else   /* No standard headers.  */
117
118 extern char *getenv ();
119
120 #ifdef HAVE_STRING_H
121 #include <string.h>
122 #define ANSI_STRING
123 #else
124 #include <strings.h>
125 #endif
126 #ifdef  HAVE_MEMORY_H
127 #include <memory.h>
128 #endif
129
130 extern char *malloc (), *realloc ();
131 extern void free ();
132
133 extern void qsort ();
134 extern void abort (), exit ();
135
136 #endif  /* Standard headers.  */
137
138 #ifndef ANSI_STRING
139
140 #ifndef bzero
141 extern void bzero ();
142 #endif
143 #ifndef bcopy
144 extern void bcopy ();
145 #endif
146
147 #define memcpy(d, s, n) bcopy ((s), (d), (n))
148 #define strrchr rindex
149 /* memset is only used for zero here, but let's be paranoid.  */
150 #define memset(s, better_be_zero, n) \
151   ((void) ((better_be_zero) == 0 ? (bzero((s), (n)), 0) : (abort(), 0)))
152 #endif  /* Not ANSI_STRING.  */
153
154 #ifndef HAVE_STRCOLL
155 #define strcoll strcmp
156 #endif
157
158
159 #ifndef __GNU_LIBRARY__
160 #ifdef  __GNUC__
161 __inline
162 #endif
163 static char *
164 my_realloc (p, n)
165      char *p;
166      unsigned int n;
167 {
168   /* These casts are the for sake of the broken Ultrix compiler,
169      which warns of illegal pointer combinations otherwise.  */
170   if (p == NULL)
171     return (char *) malloc (n);
172   return (char *) realloc (p, n);
173 }
174 #define realloc my_realloc
175 #endif
176
177
178 #if     !defined(__alloca) && !defined(__GNU_LIBRARY__)
179
180 #ifdef  __GNUC__
181 #undef  alloca
182 #define alloca(n)       __builtin_alloca (n)
183 #else   /* Not GCC.  */
184 #if     defined (sparc) || defined (HAVE_ALLOCA_H)
185 #include <alloca.h>
186 #else   /* Not sparc or HAVE_ALLOCA_H.  */
187 #ifndef _AIX
188 extern char *alloca ();
189 #endif  /* Not _AIX.  */
190 #endif  /* sparc or HAVE_ALLOCA_H.  */
191 #endif  /* GCC.  */
192
193 #define __alloca        alloca
194
195 #endif
196
197 #ifndef __GNU_LIBRARY__
198 #define __stat stat
199 #ifdef STAT_MACROS_BROKEN
200 #undef S_ISDIR
201 #endif
202 #ifndef S_ISDIR
203 #define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
204 #endif
205 #endif
206
207 #ifndef STDC_HEADERS
208 #undef  size_t
209 #define size_t  unsigned int
210 #endif
211
212 /* Some system header files erroneously define these.
213    We want our own definitions from <fnmatch.h> to take precedence.  */
214 #undef  FNM_PATHNAME
215 #undef  FNM_NOESCAPE
216 #undef  FNM_PERIOD
217 #include <fnmatch.h>
218
219 /* Some system header files erroneously define these.
220    We want our own definitions from <glob.h> to take precedence.  */
221 #undef  GLOB_ERR
222 #undef  GLOB_MARK
223 #undef  GLOB_NOSORT
224 #undef  GLOB_DOOFFS
225 #undef  GLOB_NOCHECK
226 #undef  GLOB_APPEND
227 #undef  GLOB_NOESCAPE
228 #undef  GLOB_PERIOD
229 #include <glob.h>
230 \f
231 static int glob_pattern_p __P ((const char *pattern, int quote));
232 static int glob_in_dir __P ((const char *pattern, const char *directory,
233                              int flags,
234                              int (*errfunc) __P ((const char *, int)),
235                              glob_t *pglob));
236 static int prefix_array __P ((const char *prefix, char **array, size_t n));
237 static int collated_compare __P ((const __ptr_t, const __ptr_t));
238
239 /* Do glob searching for PATTERN, placing results in PGLOB.
240    The bits defined above may be set in FLAGS.
241    If a directory cannot be opened or read and ERRFUNC is not nil,
242    it is called with the pathname that caused the error, and the
243    `errno' value from the failing call; if it returns non-zero
244    `glob' returns GLOB_ABEND; if it returns zero, the error is ignored.
245    If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
246    Otherwise, `glob' returns zero.  */
247 int
248 glob (pattern, flags, errfunc, pglob)
249      const char *pattern;
250      int flags;
251      int (*errfunc) __P ((const char *, int));
252      glob_t *pglob;
253 {
254   const char *filename;
255   char *dirname;
256   size_t dirlen;
257   int status;
258   int oldcount;
259
260   if (pattern == NULL || pglob == NULL || (flags & ~__GLOB_FLAGS) != 0)
261     {
262       errno = EINVAL;
263       return -1;
264     }
265
266   if (flags & GLOB_BRACE)
267     {
268       const char *begin = strchr (pattern, '{');
269       if (begin != NULL)
270         {
271           int firstc;
272           size_t restlen;
273           const char *p, *end, *next;
274           unsigned int depth = 0;
275
276           /* Find the end of the brace expression, by counting braces.
277              While we're at it, notice the first comma at top brace level.  */
278           end = begin + 1;
279           next = NULL;
280           while (1)
281             {
282               switch (*end++)
283                 {
284                 case ',':
285                   if (depth == 0 && next == NULL)
286                     next = end;
287                   continue;
288                 case '{':
289                   ++depth;
290                   continue;
291                 case '}':
292                   if (depth-- == 0)
293                     break;
294                   continue;
295                 case '\0':
296                   return glob (pattern, flags &~ GLOB_BRACE, errfunc, pglob);
297                 }
298               break;
299             }
300           restlen = strlen (end) + 1;
301           if (next == NULL)
302             next = end;
303
304           /* We have a brace expression.  BEGIN points to the opening {,
305              NEXT points past the terminator of the first element, and END
306              points past the final }.  We will accumulate result names from
307              recursive runs for each brace alternative in the buffer using
308              GLOB_APPEND.  */
309
310           if (!(flags & GLOB_APPEND))
311             {
312               /* This call is to set a new vector, so clear out the
313                  vector so we can append to it.  */
314               pglob->gl_pathc = 0;
315               pglob->gl_pathv = NULL;
316             }
317           firstc = pglob->gl_pathc;
318
319           /* In this loop P points to the beginning of the current element
320              and NEXT points past its terminator.  */
321           p = begin + 1;
322           while (1)
323             {
324               /* Construct a whole name that is one of the brace
325                  alternatives in a temporary buffer.  */
326               int result;
327               size_t bufsz = (begin - pattern) + (next - 1 - p) + restlen;
328 #ifdef __GNUC__
329               char onealt[bufsz];
330 #else
331               char *onealt = malloc (bufsz);
332               if (onealt == NULL)
333                 {
334                   if (!(flags & GLOB_APPEND))
335                     globfree (&pglob);
336                   return GLOB_NOSPACE;
337                 }
338 #endif
339               memcpy (onealt, pattern, begin - pattern);
340               memcpy (&onealt[begin - pattern], p, next - 1 - p);
341               memcpy (&onealt[(begin - pattern) + (next - 1 - p)],
342                       end, restlen);
343               result = glob (onealt,
344                              ((flags & ~(GLOB_NOCHECK|GLOB_NOMAGIC)) |
345                               GLOB_APPEND), errfunc, pglob);
346 #ifndef __GNUC__
347               free (onealt);
348 #endif
349
350               /* If we got an error, return it.  */
351               if (result && result != GLOB_NOMATCH)
352                 {
353                   if (!(flags & GLOB_APPEND))
354                     globfree (pglob);
355                   return result;
356                 }
357
358               /* Advance past this alternative and process the next.  */
359               p = next;
360               depth = 0;
361             scan:
362               switch (*p++)
363                 {
364                 case ',':
365                   if (depth == 0)
366                     {
367                       /* Found the next alternative.  Loop to glob it.  */
368                       next = p;
369                       continue;
370                     }
371                   goto scan;
372                 case '{':
373                   ++depth;
374                   goto scan;
375                 case '}':
376                   if (depth-- == 0)
377                     /* End of the brace expression.  Break out of the loop.  */
378                     break;
379                   goto scan;
380                 }
381             }
382
383           if (pglob->gl_pathc == firstc &&
384               !(flags & (GLOB_NOCHECK|GLOB_NOMAGIC)))
385             return GLOB_NOMATCH;
386         }
387     }
388
389   /* Find the filename.  */
390   filename = strrchr (pattern, '/');
391   if (filename == NULL)
392     {
393       filename = pattern;
394       dirname = (char *) ".";
395       dirlen = 0;
396     }
397   else if (filename == pattern)
398     {
399       /* "/pattern".  */
400       dirname = (char *) "/";
401       dirlen = 1;
402       ++filename;
403     }
404   else
405     {
406       dirlen = filename - pattern;
407       dirname = (char *) __alloca (dirlen + 1);
408       memcpy (dirname, pattern, dirlen);
409       dirname[dirlen] = '\0';
410       ++filename;
411     }
412
413   if (filename[0] == '\0' && dirlen > 1)
414     /* "pattern/".  Expand "pattern", appending slashes.  */
415     {
416       int val = glob (dirname, flags | GLOB_MARK, errfunc, pglob);
417       if (val == 0)
418         pglob->gl_flags = (pglob->gl_flags & ~GLOB_MARK) | (flags & GLOB_MARK);
419       return val;
420     }
421
422   if (!(flags & GLOB_APPEND))
423     {
424       pglob->gl_pathc = 0;
425       pglob->gl_pathv = NULL;
426     }
427
428   oldcount = pglob->gl_pathc;
429
430   if ((flags & GLOB_TILDE) && dirname[0] == '~')
431     {
432       if (dirname[1] == '\0')
433         {
434           /* Look up home directory.  */
435           dirname = getenv ("HOME");
436           if (dirname == NULL || dirname[0] == '\0')
437             {
438               extern char *getlogin __P ((void));
439               char *name = getlogin ();
440               if (name != NULL)
441                 {
442                   struct passwd *p = getpwnam (name);
443                   if (p != NULL)
444                     dirname = p->pw_dir;
445                 }
446             }
447           if (dirname == NULL || dirname[0] == '\0')
448             dirname = (char *) "~"; /* No luck.  */
449         }
450       else
451         {
452           /* Look up specific user's home directory.  */
453           struct passwd *p = getpwnam (dirname + 1);
454           if (p != NULL)
455             dirname = p->pw_dir;
456         }
457     }
458
459   if (glob_pattern_p (dirname, !(flags & GLOB_NOESCAPE)))
460     {
461       /* The directory name contains metacharacters, so we
462          have to glob for the directory, and then glob for
463          the pattern in each directory found.  */
464       glob_t dirs;
465       register int i;
466
467       status = glob (dirname,
468                      ((flags & (GLOB_ERR | GLOB_NOCHECK | GLOB_NOESCAPE)) |
469                       GLOB_NOSORT),
470                      errfunc, &dirs);
471       if (status != 0)
472         return status;
473
474       /* We have successfully globbed the preceding directory name.
475          For each name we found, call glob_in_dir on it and FILENAME,
476          appending the results to PGLOB.  */
477       for (i = 0; i < dirs.gl_pathc; ++i)
478         {
479           int oldcount;
480
481 #ifdef  SHELL
482           {
483             /* Make globbing interruptible in the bash shell. */
484             extern int interrupt_state;
485
486             if (interrupt_state)
487               {
488                 globfree (&dirs);
489                 globfree (&files);
490                 return GLOB_ABEND;
491               }
492           }
493 #endif /* SHELL.  */
494
495           oldcount = pglob->gl_pathc;
496           status = glob_in_dir (filename, dirs.gl_pathv[i],
497                                 (flags | GLOB_APPEND) & ~GLOB_NOCHECK,
498                                 errfunc, pglob);
499           if (status == GLOB_NOMATCH)
500             /* No matches in this directory.  Try the next.  */
501             continue;
502
503           if (status != 0)
504             {
505               globfree (&dirs);
506               globfree (pglob);
507               return status;
508             }
509
510           /* Stick the directory on the front of each name.  */
511           if (prefix_array (dirs.gl_pathv[i],
512                             &pglob->gl_pathv[oldcount],
513                             pglob->gl_pathc - oldcount))
514             {
515               globfree (&dirs);
516               globfree (pglob);
517               return GLOB_NOSPACE;
518             }
519         }
520
521       flags |= GLOB_MAGCHAR;
522
523       if (pglob->gl_pathc == oldcount)
524         /* No matches.  */
525         if (flags & GLOB_NOCHECK)
526           {
527             size_t len = strlen (pattern) + 1;
528             char *patcopy = (char *) malloc (len);
529             if (patcopy == NULL)
530               return GLOB_NOSPACE;
531             memcpy (patcopy, pattern, len);
532
533             pglob->gl_pathv
534               = (char **) realloc (pglob->gl_pathv,
535                                    (pglob->gl_pathc +
536                                     ((flags & GLOB_DOOFFS) ?
537                                      pglob->gl_offs : 0) +
538                                     1 + 1) *
539                                    sizeof (char *));
540             if (pglob->gl_pathv == NULL)
541               {
542                 free (patcopy);
543                 return GLOB_NOSPACE;
544               }
545
546             if (flags & GLOB_DOOFFS)
547               while (pglob->gl_pathc < pglob->gl_offs)
548                 pglob->gl_pathv[pglob->gl_pathc++] = NULL;
549
550             pglob->gl_pathv[pglob->gl_pathc++] = patcopy;
551             pglob->gl_pathv[pglob->gl_pathc] = NULL;
552             pglob->gl_flags = flags;
553           }
554         else
555           return GLOB_NOMATCH;
556     }
557   else
558     {
559       status = glob_in_dir (filename, dirname, flags, errfunc, pglob);
560       if (status != 0)
561         return status;
562
563       if (dirlen > 0)
564         {
565           /* Stick the directory on the front of each name.  */
566           if (prefix_array (dirname,
567                             &pglob->gl_pathv[oldcount],
568                             pglob->gl_pathc - oldcount))
569             {
570               globfree (pglob);
571               return GLOB_NOSPACE;
572             }
573         }
574     }
575
576   if (flags & GLOB_MARK)
577     {
578       /* Append slashes to directory names.  */
579       int i;
580       struct stat st;
581       for (i = oldcount; i < pglob->gl_pathc; ++i)
582         if (((flags & GLOB_ALTDIRFUNC) ?
583              (*pglob->gl_stat) (pglob->gl_pathv[i], &st) :
584              __stat (pglob->gl_pathv[i], &st)) == 0 &&
585             S_ISDIR (st.st_mode))
586           {
587             size_t len = strlen (pglob->gl_pathv[i]) + 2;
588             char *new = realloc (pglob->gl_pathv[i], len);
589             if (new == NULL)
590               {
591                 globfree (pglob);
592                 return GLOB_NOSPACE;
593               }
594             strcpy (&new[len - 2], "/");
595             pglob->gl_pathv[i] = new;
596           }
597     }
598
599   if (!(flags & GLOB_NOSORT))
600     /* Sort the vector.  */
601     qsort ((__ptr_t) &pglob->gl_pathv[oldcount],
602            pglob->gl_pathc - oldcount,
603            sizeof (char *), collated_compare);
604
605   return 0;
606 }
607
608
609 /* Free storage allocated in PGLOB by a previous `glob' call.  */
610 void
611 globfree (pglob)
612      register glob_t *pglob;
613 {
614   if (pglob->gl_pathv != NULL)
615     {
616       register int i;
617       for (i = 0; i < pglob->gl_pathc; ++i)
618         if (pglob->gl_pathv[i] != NULL)
619           free ((__ptr_t) pglob->gl_pathv[i]);
620       free ((__ptr_t) pglob->gl_pathv);
621     }
622 }
623
624
625 /* Do a collated comparison of A and B.  */
626 static int
627 collated_compare (a, b)
628      const __ptr_t a;
629      const __ptr_t b;
630 {
631   const char *const s1 = *(const char *const * const) a;
632   const char *const s2 = *(const char *const * const) b;
633
634   if (s1 == s2)
635     return 0;
636   if (s1 == NULL)
637     return 1;
638   if (s2 == NULL)
639     return -1;
640   return strcoll (s1, s2);
641 }
642
643
644 /* Prepend DIRNAME to each of N members of ARRAY, replacing ARRAY's
645    elements in place.  Return nonzero if out of memory, zero if successful.
646    A slash is inserted between DIRNAME and each elt of ARRAY,
647    unless DIRNAME is just "/".  Each old element of ARRAY is freed.  */
648 static int
649 prefix_array (dirname, array, n)
650      const char *dirname;
651      char **array;
652      size_t n;
653 {
654   register size_t i;
655   size_t dirlen = strlen (dirname);
656
657   if (dirlen == 1 && dirname[0] == '/')
658     /* DIRNAME is just "/", so normal prepending would get us "//foo".
659        We want "/foo" instead, so don't prepend any chars from DIRNAME.  */
660     dirlen = 0;
661
662   for (i = 0; i < n; ++i)
663     {
664       size_t eltlen = strlen (array[i]) + 1;
665       char *new = (char *) malloc (dirlen + 1 + eltlen);
666       if (new == NULL)
667         {
668           while (i > 0)
669             free ((__ptr_t) array[--i]);
670           return 1;
671         }
672
673       memcpy (new, dirname, dirlen);
674       new[dirlen] = '/';
675       memcpy (&new[dirlen + 1], array[i], eltlen);
676       free ((__ptr_t) array[i]);
677       array[i] = new;
678     }
679
680   return 0;
681 }
682
683
684 /* Return nonzero if PATTERN contains any metacharacters.
685    Metacharacters can be quoted with backslashes if QUOTE is nonzero.  */
686 static int
687 glob_pattern_p (pattern, quote)
688      const char *pattern;
689      int quote;
690 {
691   register const char *p;
692   int open = 0;
693
694   for (p = pattern; *p != '\0'; ++p)
695     switch (*p)
696       {
697       case '?':
698       case '*':
699         return 1;
700
701       case '\\':
702         if (quote && p[1] != '\0')
703           ++p;
704         break;
705
706       case '[':
707         open = 1;
708         break;
709
710       case ']':
711         if (open)
712           return 1;
713         break;
714       }
715
716   return 0;
717 }
718
719
720 /* Like `glob', but PATTERN is a final pathname component,
721    and matches are searched for in DIRECTORY.
722    The GLOB_NOSORT bit in FLAGS is ignored.  No sorting is ever done.
723    The GLOB_APPEND flag is assumed to be set (always appends).  */
724 static int
725 glob_in_dir (pattern, directory, flags, errfunc, pglob)
726      const char *pattern;
727      const char *directory;
728      int flags;
729      int (*errfunc) __P ((const char *, int));
730      glob_t *pglob;
731 {
732   __ptr_t stream;
733
734   struct globlink
735     {
736       struct globlink *next;
737       char *name;
738     };
739   struct globlink *names = NULL;
740   size_t nfound = 0;
741
742   if (!glob_pattern_p (pattern, !(flags & GLOB_NOESCAPE)))
743     {
744       stream = NULL;
745       flags |= GLOB_NOCHECK;
746     }
747   else
748     {
749       flags |= GLOB_MAGCHAR;
750
751       stream = ((flags & GLOB_ALTDIRFUNC) ?
752                 (*pglob->gl_opendir) (directory) :
753                 (__ptr_t) opendir (directory));
754       if (stream == NULL)
755         {
756           if ((errfunc != NULL && (*errfunc) (directory, errno)) ||
757               (flags & GLOB_ERR))
758             return GLOB_ABEND;
759         }
760       else
761         while (1)
762           {
763             const char *name;
764             size_t len;
765             struct dirent *d = ((flags & GLOB_ALTDIRFUNC) ?
766                                 (*pglob->gl_readdir) (stream) :
767                                 readdir ((DIR *) stream));
768             if (d == NULL)
769               break;
770             if (! REAL_DIR_ENTRY (d))
771               continue;
772
773             name = d->d_name;
774
775             if (fnmatch (pattern, name,
776                          (!(flags & GLOB_PERIOD) ? FNM_PERIOD : 0) |
777                          ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0)) == 0)
778               {
779                 struct globlink *new
780                   = (struct globlink *) __alloca (sizeof (struct globlink));
781                 len = NAMLEN (d);
782                 new->name
783                   = (char *) malloc (len + 1);
784                 if (new->name == NULL)
785                   goto memory_error;
786                 memcpy ((__ptr_t) new->name, name, len);
787                 new->name[len] = '\0';
788                 new->next = names;
789                 names = new;
790                 ++nfound;
791               }
792           }
793     }
794
795   if (nfound == 0 && (flags & GLOB_NOMAGIC) &&
796       ! glob_pattern_p (pattern, !(flags & GLOB_NOESCAPE)))
797     flags |= GLOB_NOCHECK;
798
799   if (nfound == 0 && (flags & GLOB_NOCHECK))
800     {
801       size_t len = strlen (pattern);
802       nfound = 1;
803       names = (struct globlink *) __alloca (sizeof (struct globlink));
804       names->next = NULL;
805       names->name = (char *) malloc (len + 1);
806       if (names->name == NULL)
807         goto memory_error;
808       memcpy (names->name, pattern, len);
809       names->name[len] = '\0';
810     }
811
812   pglob->gl_pathv
813     = (char **) realloc (pglob->gl_pathv,
814                          (pglob->gl_pathc +
815                           ((flags & GLOB_DOOFFS) ? pglob->gl_offs : 0) +
816                           nfound + 1) *
817                          sizeof (char *));
818   if (pglob->gl_pathv == NULL)
819     goto memory_error;
820
821   if (flags & GLOB_DOOFFS)
822     while (pglob->gl_pathc < pglob->gl_offs)
823       pglob->gl_pathv[pglob->gl_pathc++] = NULL;
824
825   for (; names != NULL; names = names->next)
826     pglob->gl_pathv[pglob->gl_pathc++] = names->name;
827   pglob->gl_pathv[pglob->gl_pathc] = NULL;
828
829   pglob->gl_flags = flags;
830
831   if (stream != NULL)
832     {
833       int save = errno;
834       if (flags & GLOB_ALTDIRFUNC)
835         (*pglob->gl_closedir) (stream);
836       else
837         closedir ((DIR *) stream);
838       errno = save;
839     }
840   return nfound == 0 ? GLOB_NOMATCH : 0;
841
842  memory_error:
843   {
844     int save = errno;
845     if (flags & GLOB_ALTDIRFUNC)
846       (*pglob->gl_closedir) (stream);
847     else
848       closedir ((DIR *) stream);
849     errno = save;
850   }
851   while (names != NULL)
852     {
853       if (names->name != NULL)
854         free ((__ptr_t) names->name);
855       names = names->next;
856     }
857   return GLOB_NOSPACE;
858 }
859
860 #endif  /* Not ELIDE_CODE.  */
861