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