lib/glob.c

   1 /* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999 Free
   2 Software Foundation, Inc.
   3
   4 This library is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU Library General Public License as
   6 published by the Free Software Foundation; either version 2 of the
   7 License, or (at your option) any later version.
   8
   9 This library is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 Library General Public License for more details.
  13
  14 You should have received a copy of the GNU Library General Public License
  15 along with this library; see the file COPYING.LIB.  If not, write to the Free
  16 Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
  17 USA.  */
  18
  19 /* AIX requires this to be the first thing in the file.  */
  20 #if defined _AIX && !defined __GNUC__
  21  #pragma alloca
  22 #endif
  23
  24 #ifdef  HAVE_CONFIG_H
  25 # include <config.h>
  26 #endif
  27
  28 /* Enable GNU extensions in glob.h.  */
  29 #ifndef _GNU_SOURCE
  30 # define _GNU_SOURCE    1
  31 #endif
  32
  33 #include <errno.h>
  34 #include <sys/types.h>
  35 #include <sys/stat.h>
  36
  37 /* Outcomment the following line for production quality code.  */
  38 /* #define NDEBUG 1 */
  39 #include <assert.h>
  40
  41 #include <stdio.h>              /* Needed on stupid SunOS for assert.  */
  42
  43
  44 /* Comment out all this code if we are using the GNU C Library, and are not
  45    actually compiling the library itself.  This code is part of the GNU C
  46    Library, but also included in many other GNU distributions.  Compiling
  47    and linking in this code is a waste when using the GNU C library
  48    (especially if it is a shared library).  Rather than having every GNU
  49    program understand `configure --with-gnu-libc' and omit the object files,
  50    it is simpler to just do this in the source for each such file.  */
  51
  52 #define GLOB_INTERFACE_VERSION 1
  53 #if !defined _LIBC && defined __GNU_LIBRARY__ && __GNU_LIBRARY__ > 1
  54 # include <gnu-versions.h>
  55 # if _GNU_GLOB_INTERFACE_VERSION == GLOB_INTERFACE_VERSION
  56 #  define ELIDE_CODE
  57 # endif
  58 #endif
  59
  60 #ifndef ELIDE_CODE
  61
  62 #if defined STDC_HEADERS || defined __GNU_LIBRARY__
  63 # include <stddef.h>
  64 #endif
  65
  66 #if defined HAVE_UNISTD_H || defined _LIBC
  67 # include <unistd.h>
  68 # ifndef POSIX
  69 #  ifdef _POSIX_VERSION
  70 #   define POSIX
  71 #  endif
  72 # endif
  73 #endif
  74
  75 #if !defined _AMIGA && !defined VMS && !defined WINDOWS32
  76 # include <pwd.h>
  77 #endif
  78
  79 #if !defined __GNU_LIBRARY__ && !defined STDC_HEADERS
  80 extern int errno;
  81 #endif
  82 #ifndef __set_errno
  83 # define __set_errno(val) errno = (val)
  84 #endif
  85
  86 #ifndef NULL
  87 # define NULL   0
  88 #endif
  89
  90
  91 #if defined HAVE_DIRENT_H || defined __GNU_LIBRARY__
  92 # include <dirent.h>
  93 # define NAMLEN(dirent) strlen((dirent)->d_name)
  94 #else
  95 # define dirent direct
  96 # define NAMLEN(dirent) (dirent)->d_namlen
  97 # ifdef HAVE_SYS_NDIR_H
  98 #  include <sys/ndir.h>
  99 # endif
 100 # ifdef HAVE_SYS_DIR_H
 101 #  include <sys/dir.h>
 102 # endif
 103 # ifdef HAVE_NDIR_H
 104 #  include <ndir.h>
 105 # endif
 106 # ifdef HAVE_VMSDIR_H
 107 #  include "vmsdir.h"
 108 # endif /* HAVE_VMSDIR_H */
 109 #endif
 110
 111
 112 /* In GNU systems, <dirent.h> defines this macro for us.  */
 113 #ifdef _D_NAMLEN
 114 # undef NAMLEN
 115 # define NAMLEN(d) _D_NAMLEN(d)
 116 #endif
 117
 118 /* When used in the GNU libc the symbol _DIRENT_HAVE_D_TYPE is available
 119    if the `d_type' member for `struct dirent' is available.  */
 120 #if defined(_DIRENT_HAVE_D_TYPE) || defined(HAVE_STRUCT_DIRENT_D_TYPE)
 121 # define HAVE_D_TYPE    1
 122 #endif
 123
 124
 125 #if (defined POSIX || defined WINDOWS32) && !defined __GNU_LIBRARY__
 126 /* Posix does not require that the d_ino field be present, and some
 127    systems do not provide it. */
 128 # define REAL_DIR_ENTRY(dp) 1
 129 #else
 130 # define REAL_DIR_ENTRY(dp) (dp->d_ino != 0)
 131 #endif /* POSIX */
 132
 133 #if defined STDC_HEADERS || defined __GNU_LIBRARY__
 134 # include <stdlib.h>
 135 # include <string.h>
 136 # define        ANSI_STRING
 137 #else   /* No standard headers.  */
 138
 139 extern char *getenv ();
 140
 141 # ifdef HAVE_STRING_H
 142 #  include <string.h>
 143 #  define ANSI_STRING
 144 # else
 145 #  include <strings.h>
 146 # endif
 147 # ifdef HAVE_MEMORY_H
 148 #  include <memory.h>
 149 # endif
 150
 151 extern char *malloc (), *realloc ();
 152 extern void free ();
 153
 154 extern void qsort ();
 155 extern void abort (), exit ();
 156
 157 #endif  /* Standard headers.  */
 158
 159 #ifndef ANSI_STRING
 160
 161 # ifndef bzero
 162 extern void bzero ();
 163 # endif
 164 # ifndef bcopy
 165 extern void bcopy ();
 166 # endif
 167
 168 # define memcpy(d, s, n)        bcopy ((s), (d), (n))
 169 # define strrchr        rindex
 170 /* memset is only used for zero here, but let's be paranoid.  */
 171 # define memset(s, better_be_zero, n) \
 172   ((void) ((better_be_zero) == 0 ? (bzero((s), (n)), 0) : (abort(), 0)))
 173 #endif  /* Not ANSI_STRING.  */
 174
 175 #if !defined HAVE_STRCOLL && !defined _LIBC
 176 # define strcoll        strcmp
 177 #endif
 178
 179 #if !defined HAVE_MEMPCPY && __GLIBC__ - 0 == 2 && __GLIBC_MINOR__ >= 1
 180 # define HAVE_MEMPCPY   1
 181 # undef  mempcpy
 182 # define mempcpy(Dest, Src, Len) __mempcpy (Dest, Src, Len)
 183 #endif
 184
 185 #if !defined __GNU_LIBRARY__ && !defined __DJGPP__
 186 # ifdef __GNUC__
 187 __inline
 188 # endif
 189 # ifndef __SASC
 190 #  ifdef WINDOWS32
 191 static void *
 192 my_realloc (void *p, unsigned int n)
 193 #  else
 194 static char *
 195 my_realloc (p, n)
 196      char *p;
 197      unsigned int n;
 198 #  endif
 199 {
 200   /* These casts are the for sake of the broken Ultrix compiler,
 201      which warns of illegal pointer combinations otherwise.  */
 202   if (p == NULL)
 203     return (char *) malloc (n);
 204   return (char *) realloc (p, n);
 205 }
 206 # define        realloc my_realloc
 207 # endif /* __SASC */
 208 #endif /* __GNU_LIBRARY__ || __DJGPP__ */
 209
 210
 211 #if !defined __alloca && !defined __GNU_LIBRARY__
 212
 213 # ifdef __GNUC__
 214 #  undef alloca
 215 #  define alloca(n)     __builtin_alloca (n)
 216 # else  /* Not GCC.  */
 217 #  ifdef HAVE_ALLOCA_H
 218 #   include <alloca.h>
 219 #  else /* Not HAVE_ALLOCA_H.  */
 220 #   ifndef _AIX
 221 #    ifdef WINDOWS32
 222 #     include <malloc.h>
 223 #    else
 224 extern char *alloca ();
 225 #    endif /* WINDOWS32 */
 226 #   endif /* Not _AIX.  */
 227 #  endif /* sparc or HAVE_ALLOCA_H.  */
 228 # endif /* GCC.  */
 229 #endif
 230
 231 #ifndef __GNU_LIBRARY__
 232 # define __stat stat
 233 # ifdef STAT_MACROS_BROKEN
 234 #  undef S_ISDIR
 235 # endif
 236 # ifndef S_ISDIR
 237 #  define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
 238 # endif
 239 #endif
 240
 241 #ifdef _LIBC
 242 # undef strdup
 243 # define strdup(str) __strdup (str)
 244 # define sysconf(id) __sysconf (id)
 245 # define closedir(dir) __closedir (dir)
 246 # define opendir(name) __opendir (name)
 247 # define readdir(str) __readdir (str)
 248 # define getpwnam_r(name, bufp, buf, len, res) \
 249    __getpwnam_r (name, bufp, buf, len, res)
 250 # ifndef __stat
 251 #  define __stat(fname, buf) __xstat (_STAT_VER, fname, buf)
 252 # endif
 253 #endif
 254
 255 #if !(defined STDC_HEADERS || defined __GNU_LIBRARY__)
 256 # undef size_t
 257 # define size_t unsigned int
 258 #endif
 259
 260 /* Some system header files erroneously define these.
 261    We want our own definitions from <fnmatch.h> to take precedence.  */
 262 #ifndef __GNU_LIBRARY__
 263 # undef FNM_PATHNAME
 264 # undef FNM_NOESCAPE
 265 # undef FNM_PERIOD
 266 #endif
 267 #include <fnmatch.h>
 268
 269 /* Some system header files erroneously define these.
 270    We want our own definitions from <glob.h> to take precedence.  */
 271 #ifndef __GNU_LIBRARY__
 272 # undef GLOB_ERR
 273 # undef GLOB_MARK
 274 # undef GLOB_NOSORT
 275 # undef GLOB_DOOFFS
 276 # undef GLOB_NOCHECK
 277 # undef GLOB_APPEND
 278 # undef GLOB_NOESCAPE
 279 # undef GLOB_PERIOD
 280 #endif
 281 #include <glob.h>
 282
 283 #if !defined __alloca
 284 # define __alloca alloca
 285 #endif
 286
 287 #if !defined __stat
 288 # define __stat stat
 289 #endif
 290
 291 #ifdef HAVE_GETLOGIN_R
 292 extern int getlogin_r __P ((char *, size_t));
 293 #else
 294 extern char *getlogin __P ((void));
 295 #endif
 296 \f
 297 static
 298 #if __GNUC__ - 0 >= 2
 299 inline
 300 #endif
 301 const char *next_brace_sub __P ((const char *begin));
 302 static int glob_in_dir __P ((const char *pattern, const char *directory,
 303                              int flags,
 304                              int (*errfunc) (const char *, int),
 305                              glob_t *pglob));
 306 static int prefix_array __P ((const char *prefix, char **array, size_t n));
 307 static int collated_compare __P ((const __ptr_t, const __ptr_t));
 308
 309 #if !defined _LIBC || !defined NO_GLOB_PATTERN_P
 310 int __glob_pattern_p __P ((const char *pattern, int quote));
 311 #endif
 312
 313 /* Find the end of the sub-pattern in a brace expression.  We define
 314    this as an inline function if the compiler permits.  */
 315 static
 316 #if __GNUC__ - 0 >= 2
 317 inline
 318 #endif
 319 const char *
 320 next_brace_sub (begin)
 321      const char *begin;
 322 {
 323   unsigned int depth = 0;
 324   const char *cp = begin;
 325
 326   while (1)
 327     {
 328       if (depth == 0)
 329         {
 330           if (*cp != ',' && *cp != '}' && *cp != '\0')
 331             {
 332               if (*cp == '{')
 333                 ++depth;
 334               ++cp;
 335               continue;
 336             }
 337         }
 338       else
 339         {
 340           while (*cp != '\0' && (*cp != '}' || depth > 0))
 341             {
 342               if (*cp == '}')
 343                 --depth;
 344               ++cp;
 345             }
 346           if (*cp == '\0')
 347             /* An incorrectly terminated brace expression.  */
 348             return NULL;
 349
 350           continue;
 351         }
 352       break;
 353     }
 354
 355   return cp;
 356 }
 357
 358 /* Do glob searching for PATTERN, placing results in PGLOB.
 359    The bits defined above may be set in FLAGS.
 360    If a directory cannot be opened or read and ERRFUNC is not nil,
 361    it is called with the pathname that caused the error, and the
 362    `errno' value from the failing call; if it returns non-zero
 363    `glob' returns GLOB_ABORTED; if it returns zero, the error is ignored.
 364    If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
 365    Otherwise, `glob' returns zero.  */
 366 int
 367 glob (pattern, flags, errfunc, pglob)
 368      const char *pattern;
 369      int flags;
 370      int (*errfunc) __P ((const char *, int));
 371      glob_t *pglob;
 372 {
 373   const char *filename;
 374   const char *dirname;
 375   size_t dirlen;
 376   int status;
 377   size_t oldcount;
 378
 379   if (pattern == NULL || pglob == NULL || (flags & ~__GLOB_FLAGS) != 0)
 380     {
 381       __set_errno (EINVAL);
 382       return -1;
 383     }
 384
 385   /* POSIX requires all slashes to be matched.  This means that with
 386      a trailing slash we must match only directories.  */
 387   if (pattern[0] && pattern[strlen (pattern) - 1] == '/')
 388     flags |= GLOB_ONLYDIR;
 389
 390   if (flags & GLOB_BRACE)
 391     {
 392       const char *begin = strchr (pattern, '{');
 393       if (begin != NULL)
 394         {
 395           /* Allocate working buffer large enough for our work.  Note that
 396             we have at least an opening and closing brace.  */
 397           size_t firstc;
 398           char *alt_start;
 399           const char *p;
 400           const char *next;
 401           const char *rest;
 402           size_t rest_len;
 403 #ifdef __GNUC__
 404           char onealt[strlen (pattern) - 1];
 405 #else
 406           char *onealt = (char *) malloc (strlen (pattern) - 1);
 407           if (onealt == NULL)
 408             {
 409               if (!(flags & GLOB_APPEND))
 410                 globfree (pglob);
 411               return GLOB_NOSPACE;
 412             }
 413 #endif
 414
 415           /* We know the prefix for all sub-patterns.  */
 416 #ifdef HAVE_MEMPCPY
 417           alt_start = mempcpy (onealt, pattern, begin - pattern);
 418 #else
 419           memcpy (onealt, pattern, begin - pattern);
 420           alt_start = &onealt[begin - pattern];
 421 #endif
 422
 423           /* Find the first sub-pattern and at the same time find the
 424              rest after the closing brace.  */
 425           next = next_brace_sub (begin + 1);
 426           if (next == NULL)
 427             {
 428               /* It is an illegal expression.  */
 429 #ifndef __GNUC__
 430               free (onealt);
 431 #endif
 432               return glob (pattern, flags & ~GLOB_BRACE, errfunc, pglob);
 433             }
 434
 435           /* Now find the end of the whole brace expression.  */
 436           rest = next;
 437           while (*rest != '}')
 438             {
 439               rest = next_brace_sub (rest + 1);
 440               if (rest == NULL)
 441                 {
 442                   /* It is an illegal expression.  */
 443 #ifndef __GNUC__
 444                   free (onealt);
 445 #endif
 446                   return glob (pattern, flags & ~GLOB_BRACE, errfunc, pglob);
 447                 }
 448             }
 449           /* Please note that we now can be sure the brace expression
 450              is well-formed.  */
 451           rest_len = strlen (++rest) + 1;
 452
 453           /* We have a brace expression.  BEGIN points to the opening {,
 454              NEXT points past the terminator of the first element, and END
 455              points past the final }.  We will accumulate result names from
 456              recursive runs for each brace alternative in the buffer using
 457              GLOB_APPEND.  */
 458
 459           if (!(flags & GLOB_APPEND))
 460             {
 461               /* This call is to set a new vector, so clear out the
 462                  vector so we can append to it.  */
 463               pglob->gl_pathc = 0;
 464               pglob->gl_pathv = NULL;
 465             }
 466           firstc = pglob->gl_pathc;
 467
 468           p = begin + 1;
 469           while (1)
 470             {
 471               int result;
 472
 473               /* Construct the new glob expression.  */
 474 #ifdef HAVE_MEMPCPY
 475               mempcpy (mempcpy (alt_start, p, next - p), rest, rest_len);
 476 #else
 477               memcpy (alt_start, p, next - p);
 478               memcpy (&alt_start[next - p], rest, rest_len);
 479 #endif
 480
 481               result = glob (onealt,
 482                              ((flags & ~(GLOB_NOCHECK|GLOB_NOMAGIC))
 483                               | GLOB_APPEND), errfunc, pglob);
 484
 485               /* If we got an error, return it.  */
 486               if (result && result != GLOB_NOMATCH)
 487                 {
 488 #ifndef __GNUC__
 489                   free (onealt);
 490 #endif
 491                   if (!(flags & GLOB_APPEND))
 492                     globfree (pglob);
 493                   return result;
 494                 }
 495
 496               if (*next == '}')
 497                 /* We saw the last entry.  */
 498                 break;
 499
 500               p = next + 1;
 501               next = next_brace_sub (p);
 502               assert (next != NULL);
 503             }
 504
 505 #ifndef __GNUC__
 506           free (onealt);
 507 #endif
 508
 509           if (pglob->gl_pathc != firstc)
 510             /* We found some entries.  */
 511             return 0;
 512           else if (!(flags & (GLOB_NOCHECK|GLOB_NOMAGIC)))
 513             return GLOB_NOMATCH;
 514         }
 515     }
 516
 517   /* Find the filename.  */
 518   filename = strrchr (pattern, '/');
 519 #if defined __MSDOS__ || defined WINDOWS32
 520   /* The case of "d:pattern".  Since `:' is not allowed in
 521      file names, we can safely assume that wherever it
 522      happens in pattern, it signals the filename part.  This
 523      is so we could some day support patterns like "[a-z]:foo".  */
 524   if (filename == NULL)
 525     filename = strchr (pattern, ':');
 526 #endif /* __MSDOS__ || WINDOWS32 */
 527   if (filename == NULL)
 528     {
 529       /* This can mean two things: a simple name or "~name".  The later
 530          case is nothing but a notation for a directory.  */
 531       if ((flags & (GLOB_TILDE|GLOB_TILDE_CHECK)) && pattern[0] == '~')
 532         {
 533           dirname = pattern;
 534           dirlen = strlen (pattern);
 535
 536           /* Set FILENAME to NULL as a special flag.  This is ugly but
 537              other solutions would require much more code.  We test for
 538              this special case below.  */
 539           filename = NULL;
 540         }
 541       else
 542         {
 543           filename = pattern;
 544 #ifdef _AMIGA
 545           dirname = "";
 546 #else
 547           dirname = ".";
 548 #endif
 549           dirlen = 0;
 550         }
 551     }
 552   else if (filename == pattern)
 553     {
 554       /* "/pattern".  */
 555       dirname = "/";
 556       dirlen = 1;
 557       ++filename;
 558     }
 559   else
 560     {
 561       char *newp;
 562       dirlen = filename - pattern;
 563 #if defined __MSDOS__ || defined WINDOWS32
 564       if (*filename == ':'
 565           || (filename > pattern + 1 && filename[-1] == ':'))
 566         {
 567           char *drive_spec;
 568
 569           ++dirlen;
 570           drive_spec = (char *) __alloca (dirlen + 1);
 571 #ifdef HAVE_MEMPCPY
 572           *((char *) mempcpy (drive_spec, pattern, dirlen)) = '\0';
 573 #else
 574           memcpy (drive_spec, pattern, dirlen);
 575           drive_spec[dirlen] = '\0';
 576 #endif
 577           /* For now, disallow wildcards in the drive spec, to
 578              prevent infinite recursion in glob.  */
 579           if (__glob_pattern_p (drive_spec, !(flags & GLOB_NOESCAPE)))
 580             return GLOB_NOMATCH;
 581           /* If this is "d:pattern", we need to copy `:' to DIRNAME
 582              as well.  If it's "d:/pattern", don't remove the slash
 583              from "d:/", since "d:" and "d:/" are not the same.*/
 584         }
 585 #endif
 586       newp = (char *) __alloca (dirlen + 1);
 587 #ifdef HAVE_MEMPCPY
 588       *((char *) mempcpy (newp, pattern, dirlen)) = '\0';
 589 #else
 590       memcpy (newp, pattern, dirlen);
 591       newp[dirlen] = '\0';
 592 #endif
 593       dirname = newp;
 594       ++filename;
 595
 596       if (filename[0] == '\0'
 597 #if defined __MSDOS__ || defined WINDOWS32
 598           && dirname[dirlen - 1] != ':'
 599           && (dirlen < 3 || dirname[dirlen - 2] != ':'
 600               || dirname[dirlen - 1] != '/')
 601 #endif
 602           && dirlen > 1)
 603         /* "pattern/".  Expand "pattern", appending slashes.  */
 604         {
 605           int val = glob (dirname, flags | GLOB_MARK, errfunc, pglob);
 606           if (val == 0)
 607             pglob->gl_flags = ((pglob->gl_flags & ~GLOB_MARK)
 608                                | (flags & GLOB_MARK));
 609           return val;
 610         }
 611     }
 612
 613   if (!(flags & GLOB_APPEND))
 614     {
 615       pglob->gl_pathc = 0;
 616       pglob->gl_pathv = NULL;
 617     }
 618
 619   oldcount = pglob->gl_pathc;
 620
 621 #ifndef VMS
 622   if ((flags & (GLOB_TILDE|GLOB_TILDE_CHECK)) && dirname[0] == '~')
 623     {
 624       if (dirname[1] == '\0' || dirname[1] == '/')
 625         {
 626           /* Look up home directory.  */
 627 #ifdef VMS
 628 /* This isn't obvious, RTLs of DECC and VAXC know about "HOME" */
 629           const char *home_dir = getenv ("SYS$LOGIN");
 630 #else
 631           const char *home_dir = getenv ("HOME");
 632 #endif
 633 # ifdef _AMIGA
 634           if (home_dir == NULL || home_dir[0] == '\0')
 635             home_dir = "SYS:";
 636 # else
 637 #  ifdef WINDOWS32
 638           if (home_dir == NULL || home_dir[0] == '\0')
 639             home_dir = "c:/users/default"; /* poor default */
 640 #  else
 641 #   ifdef VMS
 642 /* Again, this isn't obvious, if "HOME" isn't known "SYS$LOGIN" should be set */
 643           if (home_dir == NULL || home_dir[0] == '\0')
 644             home_dir = "SYS$DISK:[]";
 645 #   else
 646           if (home_dir == NULL || home_dir[0] == '\0')
 647             {
 648               int success;
 649               char *name;
 650 #   if defined HAVE_GETLOGIN_R || defined _LIBC
 651               size_t buflen = sysconf (_SC_LOGIN_NAME_MAX) + 1;
 652
 653               if (buflen == 0)
 654                 /* `sysconf' does not support _SC_LOGIN_NAME_MAX.  Try
 655                    a moderate value.  */
 656                 buflen = 20;
 657               name = (char *) __alloca (buflen);
 658
 659               success = getlogin_r (name, buflen) >= 0;
 660 #   else
 661               success = (name = getlogin ()) != NULL;
 662 #   endif
 663               if (success)
 664                 {
 665                   struct passwd *p;
 666 #   if defined HAVE_GETPWNAM_R || defined _LIBC
 667                   size_t pwbuflen = sysconf (_SC_GETPW_R_SIZE_MAX);
 668                   char *pwtmpbuf;
 669                   struct passwd pwbuf;
 670                   int save = errno;
 671
 672                   if (pwbuflen == -1)
 673                     /* `sysconf' does not support _SC_GETPW_R_SIZE_MAX.
 674                        Try a moderate value.  */
 675                     pwbuflen = 1024;
 676                   pwtmpbuf = (char *) __alloca (pwbuflen);
 677
 678                   while (getpwnam_r (name, &pwbuf, pwtmpbuf, pwbuflen, &p)
 679                          != 0)
 680                     {
 681                       if (errno != ERANGE)
 682                         {
 683                           p = NULL;
 684                           break;
 685                         }
 686                       pwbuflen *= 2;
 687                       pwtmpbuf = (char *) __alloca (pwbuflen);
 688                       __set_errno (save);
 689                     }
 690 #   else
 691                   p = getpwnam (name);
 692 #   endif
 693                   if (p != NULL)
 694                     home_dir = p->pw_dir;
 695                 }
 696             }
 697           if (home_dir == NULL || home_dir[0] == '\0')
 698             {
 699               if (flags & GLOB_TILDE_CHECK)
 700                 return GLOB_NOMATCH;
 701               else
 702                 home_dir = "~"; /* No luck.  */
 703             }
 704 #   endif /* VMS */
 705 #  endif /* WINDOWS32 */
 706 # endif
 707           /* Now construct the full directory.  */
 708           if (dirname[1] == '\0')
 709             dirname = home_dir;
 710           else
 711             {
 712               char *newp;
 713               size_t home_len = strlen (home_dir);
 714               newp = (char *) __alloca (home_len + dirlen);
 715 # ifdef HAVE_MEMPCPY
 716               mempcpy (mempcpy (newp, home_dir, home_len),
 717                        &dirname[1], dirlen);
 718 # else
 719               memcpy (newp, home_dir, home_len);
 720               memcpy (&newp[home_len], &dirname[1], dirlen);
 721 # endif
 722               dirname = newp;
 723             }
 724         }
 725 # if !defined _AMIGA && !defined WINDOWS32 && !defined VMS
 726       else
 727         {
 728           char *end_name = strchr (dirname, '/');
 729           const char *user_name;
 730           const char *home_dir;
 731
 732           if (end_name == NULL)
 733             user_name = dirname + 1;
 734           else
 735             {
 736               char *newp;
 737               newp = (char *) __alloca (end_name - dirname);
 738 # ifdef HAVE_MEMPCPY
 739               *((char *) mempcpy (newp, dirname + 1, end_name - dirname))
 740                 = '\0';
 741 # else
 742               memcpy (newp, dirname + 1, end_name - dirname);
 743               newp[end_name - dirname - 1] = '\0';
 744 # endif
 745               user_name = newp;
 746             }
 747
 748           /* Look up specific user's home directory.  */
 749           {
 750             struct passwd *p;
 751 #  if defined HAVE_GETPWNAM_R || defined _LIBC
 752             size_t buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
 753             char *pwtmpbuf;
 754             struct passwd pwbuf;
 755             int save = errno;
 756
 757             if (buflen == -1)
 758               /* `sysconf' does not support _SC_GETPW_R_SIZE_MAX.  Try a
 759                  moderate value.  */
 760               buflen = 1024;
 761             pwtmpbuf = (char *) __alloca (buflen);
 762
 763             while (getpwnam_r (user_name, &pwbuf, pwtmpbuf, buflen, &p) != 0)
 764               {
 765                 if (errno != ERANGE)
 766                   {
 767                     p = NULL;
 768                     break;
 769                   }
 770                 buflen *= 2;
 771                 pwtmpbuf = __alloca (buflen);
 772                 __set_errno (save);
 773               }
 774 #  else
 775             p = getpwnam (user_name);
 776 #  endif
 777             if (p != NULL)
 778               home_dir = p->pw_dir;
 779             else
 780               home_dir = NULL;
 781           }
 782           /* If we found a home directory use this.  */
 783           if (home_dir != NULL)
 784             {
 785               char *newp;
 786               size_t home_len = strlen (home_dir);
 787               size_t rest_len = end_name == NULL ? 0 : strlen (end_name);
 788               newp = (char *) __alloca (home_len + rest_len + 1);
 789 #  ifdef HAVE_MEMPCPY
 790               *((char *) mempcpy (mempcpy (newp, home_dir, home_len),
 791                                   end_name, rest_len)) = '\0';
 792 #  else
 793               memcpy (newp, home_dir, home_len);
 794               memcpy (&newp[home_len], end_name, rest_len);
 795               newp[home_len + rest_len] = '\0';
 796 #  endif
 797               dirname = newp;
 798             }
 799           else
 800             if (flags & GLOB_TILDE_CHECK)
 801               /* We have to regard it as an error if we cannot find the
 802                  home directory.  */
 803               return GLOB_NOMATCH;
 804         }
 805 # endif /* Not Amiga && not WINDOWS32 && not VMS.  */
 806     }
 807 #endif  /* Not VMS.  */
 808
 809   /* Now test whether we looked for "~" or "~NAME".  In this case we
 810      can give the answer now.  */
 811   if (filename == NULL)
 812     {
 813       struct stat st;
 814
 815       /* Return the directory if we don't check for error or if it exists.  */
 816       if ((flags & GLOB_NOCHECK)
 817           || (((flags & GLOB_ALTDIRFUNC)
 818                ? (*pglob->gl_stat) (dirname, &st)
 819                : __stat (dirname, &st)) == 0
 820               && S_ISDIR (st.st_mode)))
 821         {
 822           pglob->gl_pathv
 823             = (char **) realloc (pglob->gl_pathv,
 824                                  (pglob->gl_pathc +
 825                                   ((flags & GLOB_DOOFFS) ?
 826                                    pglob->gl_offs : 0) +
 827                                   1 + 1) *
 828                                  sizeof (char *));
 829           if (pglob->gl_pathv == NULL)
 830             return GLOB_NOSPACE;
 831
 832           if (flags & GLOB_DOOFFS)
 833             while (pglob->gl_pathc < pglob->gl_offs)
 834               pglob->gl_pathv[pglob->gl_pathc++] = NULL;
 835
 836 #if defined HAVE_STRDUP || defined _LIBC
 837           pglob->gl_pathv[pglob->gl_pathc] = strdup (dirname);
 838 #else
 839           {
 840             size_t len = strlen (dirname) + 1;
 841             char *dircopy = malloc (len);
 842             if (dircopy != NULL)
 843               pglob->gl_pathv[pglob->gl_pathc] = memcpy (dircopy, dirname,
 844                                                          len);
 845           }
 846 #endif
 847           if (pglob->gl_pathv[pglob->gl_pathc] == NULL)
 848             {
 849               free (pglob->gl_pathv);
 850               return GLOB_NOSPACE;
 851             }
 852           pglob->gl_pathv[++pglob->gl_pathc] = NULL;
 853           pglob->gl_flags = flags;
 854
 855           return 0;
 856         }
 857
 858       /* Not found.  */
 859       return GLOB_NOMATCH;
 860     }
 861
 862   if (__glob_pattern_p (dirname, !(flags & GLOB_NOESCAPE)))
 863     {
 864       /* The directory name contains metacharacters, so we
 865          have to glob for the directory, and then glob for
 866          the pattern in each directory found.  */
 867       glob_t dirs;
 868       register size_t i;
 869
 870       status = glob (dirname,
 871                      ((flags & (GLOB_ERR | GLOB_NOCHECK | GLOB_NOESCAPE))
 872                       | GLOB_NOSORT | GLOB_ONLYDIR),
 873                      errfunc, &dirs);
 874       if (status != 0)
 875         return status;
 876
 877       /* We have successfully globbed the preceding directory name.
 878          For each name we found, call glob_in_dir on it and FILENAME,
 879          appending the results to PGLOB.  */
 880       for (i = 0; i < dirs.gl_pathc; ++i)
 881         {
 882           int old_pathc;
 883
 884 #ifdef  SHELL
 885           {
 886             /* Make globbing interruptible in the bash shell. */
 887             extern int interrupt_state;
 888
 889             if (interrupt_state)
 890               {
 891                 globfree (&dirs);
 892                 globfree (&files);
 893                 return GLOB_ABORTED;
 894               }
 895           }
 896 #endif /* SHELL.  */
 897
 898           old_pathc = pglob->gl_pathc;
 899           status = glob_in_dir (filename, dirs.gl_pathv[i],
 900                                 ((flags | GLOB_APPEND)
 901                                  & ~(GLOB_NOCHECK | GLOB_ERR)),
 902                                 errfunc, pglob);
 903           if (status == GLOB_NOMATCH)
 904             /* No matches in this directory.  Try the next.  */
 905             continue;
 906
 907           if (status != 0)
 908             {
 909               globfree (&dirs);
 910               globfree (pglob);
 911               return status;
 912             }
 913
 914           /* Stick the directory on the front of each name.  */
 915           if (prefix_array (dirs.gl_pathv[i],
 916                             &pglob->gl_pathv[old_pathc],
 917                             pglob->gl_pathc - old_pathc))
 918             {
 919               globfree (&dirs);
 920               globfree (pglob);
 921               return GLOB_NOSPACE;
 922             }
 923         }
 924
 925       flags |= GLOB_MAGCHAR;
 926
 927       /* We have ignored the GLOB_NOCHECK flag in the `glob_in_dir' calls.
 928          But if we have not found any matching entry and thie GLOB_NOCHECK
 929          flag was set we must return the list consisting of the disrectory
 930          names followed by the filename.  */
 931       if (pglob->gl_pathc == oldcount)
 932         {
 933           /* No matches.  */
 934           if (flags & GLOB_NOCHECK)
 935             {
 936               size_t filename_len = strlen (filename) + 1;
 937               char **new_pathv;
 938               struct stat st;
 939
 940               /* This is an pessimistic guess about the size.  */
 941               pglob->gl_pathv
 942                 = (char **) realloc (pglob->gl_pathv,
 943                                      (pglob->gl_pathc +
 944                                       ((flags & GLOB_DOOFFS) ?
 945                                        pglob->gl_offs : 0) +
 946                                       dirs.gl_pathc + 1) *
 947                                      sizeof (char *));
 948               if (pglob->gl_pathv == NULL)
 949                 {
 950                   globfree (&dirs);
 951                   return GLOB_NOSPACE;
 952                 }
 953
 954               if (flags & GLOB_DOOFFS)
 955                 while (pglob->gl_pathc < pglob->gl_offs)
 956                   pglob->gl_pathv[pglob->gl_pathc++] = NULL;
 957
 958               for (i = 0; i < dirs.gl_pathc; ++i)
 959                 {
 960                   const char *dir = dirs.gl_pathv[i];
 961                   size_t dir_len = strlen (dir);
 962
 963                   /* First check whether this really is a directory.  */
 964                   if (((flags & GLOB_ALTDIRFUNC)
 965                        ? (*pglob->gl_stat) (dir, &st) : __stat (dir, &st)) != 0
 966                       || !S_ISDIR (st.st_mode))
 967                     /* No directory, ignore this entry.  */
 968                     continue;
 969
 970                   pglob->gl_pathv[pglob->gl_pathc] = malloc (dir_len + 1
 971                                                              + filename_len);
 972                   if (pglob->gl_pathv[pglob->gl_pathc] == NULL)
 973                     {
 974                       globfree (&dirs);
 975                       globfree (pglob);
 976                       return GLOB_NOSPACE;
 977                     }
 978
 979 #ifdef HAVE_MEMPCPY
 980                   mempcpy (mempcpy (mempcpy (pglob->gl_pathv[pglob->gl_pathc],
 981                                              dir, dir_len),
 982                                     "/", 1),
 983                            filename, filename_len);
 984 #else
 985                   memcpy (pglob->gl_pathv[pglob->gl_pathc], dir, dir_len);
 986                   pglob->gl_pathv[pglob->gl_pathc][dir_len] = '/';
 987                   memcpy (&pglob->gl_pathv[pglob->gl_pathc][dir_len + 1],
 988                           filename, filename_len);
 989 #endif
 990                   ++pglob->gl_pathc;
 991                 }
 992
 993               pglob->gl_pathv[pglob->gl_pathc] = NULL;
 994               pglob->gl_flags = flags;
 995
 996               /* Now we know how large the gl_pathv vector must be.  */
 997               new_pathv = (char **) realloc (pglob->gl_pathv,
 998                                              ((pglob->gl_pathc + 1)
 999                                               * sizeof (char *)));
1000               if (new_pathv != NULL)
1001                 pglob->gl_pathv = new_pathv;
1002             }
1003           else
1004             return GLOB_NOMATCH;
1005         }
1006
1007       globfree (&dirs);
1008     }
1009   else
1010     {
1011       status = glob_in_dir (filename, dirname, flags, errfunc, pglob);
1012       if (status != 0)
1013         return status;
1014
1015       if (dirlen > 0)
1016         {
1017           /* Stick the directory on the front of each name.  */
1018           size_t ignore = oldcount;
1019
1020           if ((flags & GLOB_DOOFFS) && ignore < pglob->gl_offs)
1021             ignore = pglob->gl_offs;
1022
1023           if (prefix_array (dirname,
1024                             &pglob->gl_pathv[ignore],
1025                             pglob->gl_pathc - ignore))
1026             {
1027               globfree (pglob);
1028               return GLOB_NOSPACE;
1029             }
1030         }
1031     }
1032
1033   if (flags & GLOB_MARK)
1034     {
1035       /* Append slashes to directory names.  */
1036       size_t i;
1037       struct stat st;
1038       for (i = oldcount; i < pglob->gl_pathc; ++i)
1039         if (((flags & GLOB_ALTDIRFUNC)
1040              ? (*pglob->gl_stat) (pglob->gl_pathv[i], &st)
1041              : __stat (pglob->gl_pathv[i], &st)) == 0
1042             && S_ISDIR (st.st_mode))
1043           {
1044             size_t len = strlen (pglob->gl_pathv[i]) + 2;
1045             char *new = realloc (pglob->gl_pathv[i], len);
1046             if (new == NULL)
1047               {
1048                 globfree (pglob);
1049                 return GLOB_NOSPACE;
1050               }
1051             strcpy (&new[len - 2], "/");
1052             pglob->gl_pathv[i] = new;
1053           }
1054     }
1055
1056   if (!(flags & GLOB_NOSORT))
1057     {
1058       /* Sort the vector.  */
1059       int non_sort = oldcount;
1060
1061       if ((flags & GLOB_DOOFFS) && pglob->gl_offs > oldcount)
1062         non_sort = pglob->gl_offs;
1063
1064       qsort ((__ptr_t) &pglob->gl_pathv[non_sort],
1065              pglob->gl_pathc - non_sort,
1066              sizeof (char *), collated_compare);
1067     }
1068
1069   return 0;
1070 }
1071
1072
1073 /* Free storage allocated in PGLOB by a previous `glob' call.  */
1074 void
1075 globfree (pglob)
1076      register glob_t *pglob;
1077 {
1078   if (pglob->gl_pathv != NULL)
1079     {
1080       register size_t i;
1081       for (i = 0; i < pglob->gl_pathc; ++i)
1082         if (pglob->gl_pathv[i] != NULL)
1083           free ((__ptr_t) pglob->gl_pathv[i]);
1084       free ((__ptr_t) pglob->gl_pathv);
1085     }
1086 }
1087
1088
1089 /* Do a collated comparison of A and B.  */
1090 static int
1091 collated_compare (a, b)
1092      const __ptr_t a;
1093      const __ptr_t b;
1094 {
1095   const char *const s1 = *(const char *const * const) a;
1096   const char *const s2 = *(const char *const * const) b;
1097
1098   if (s1 == s2)
1099     return 0;
1100   if (s1 == NULL)
1101     return 1;
1102   if (s2 == NULL)
1103     return -1;
1104   return strcoll (s1, s2);
1105 }
1106
1107
1108 /* Prepend DIRNAME to each of N members of ARRAY, replacing ARRAY's
1109    elements in place.  Return nonzero if out of memory, zero if successful.
1110    A slash is inserted between DIRNAME and each elt of ARRAY,
1111    unless DIRNAME is just "/".  Each old element of ARRAY is freed.  */
1112 static int
1113 prefix_array (dirname, array, n)
1114      const char *dirname;
1115      char **array;
1116      size_t n;
1117 {
1118   register size_t i;
1119   size_t dirlen = strlen (dirname);
1120 #if defined __MSDOS__ || defined WINDOWS32
1121   int sep_char = '/';
1122 # define DIRSEP_CHAR sep_char
1123 #else
1124 # define DIRSEP_CHAR '/'
1125 #endif
1126
1127   if (dirlen == 1 && dirname[0] == '/')
1128     /* DIRNAME is just "/", so normal prepending would get us "//foo".
1129        We want "/foo" instead, so don't prepend any chars from DIRNAME.  */
1130     dirlen = 0;
1131 #if defined __MSDOS__ || defined WINDOWS32
1132   else if (dirlen > 1)
1133     {
1134       if (dirname[dirlen - 1] == '/' && dirname[dirlen - 2] == ':')
1135         /* DIRNAME is "d:/".  Don't prepend the slash from DIRNAME.  */
1136         --dirlen;
1137       else if (dirname[dirlen - 1] == ':')
1138         {
1139           /* DIRNAME is "d:".  Use `:' instead of `/'.  */
1140           --dirlen;
1141           sep_char = ':';
1142         }
1143     }
1144 #endif
1145
1146   for (i = 0; i < n; ++i)
1147     {
1148       size_t eltlen = strlen (array[i]) + 1;
1149       char *new = (char *) malloc (dirlen + 1 + eltlen);
1150       if (new == NULL)
1151         {
1152           while (i > 0)
1153             free ((__ptr_t) array[--i]);
1154           return 1;
1155         }
1156
1157 #ifdef HAVE_MEMPCPY
1158       {
1159         char *endp = (char *) mempcpy (new, dirname, dirlen);
1160         *endp++ = DIRSEP_CHAR;
1161         mempcpy (endp, array[i], eltlen);
1162       }
1163 #else
1164       memcpy (new, dirname, dirlen);
1165       new[dirlen] = DIRSEP_CHAR;
1166       memcpy (&new[dirlen + 1], array[i], eltlen);
1167 #endif
1168       free ((__ptr_t) array[i]);
1169       array[i] = new;
1170     }
1171
1172   return 0;
1173 }
1174
1175
1176 /* We must not compile this function twice.  */
1177 #if !defined _LIBC || !defined NO_GLOB_PATTERN_P
1178 /* Return nonzero if PATTERN contains any metacharacters.
1179    Metacharacters can be quoted with backslashes if QUOTE is nonzero.  */
1180 int
1181 __glob_pattern_p (pattern, quote)
1182      const char *pattern;
1183      int quote;
1184 {
1185   register const char *p;
1186   int open = 0;
1187
1188   for (p = pattern; *p != '\0'; ++p)
1189     switch (*p)
1190       {
1191       case '?':
1192       case '*':
1193         return 1;
1194
1195       case '\\':
1196         if (quote && p[1] != '\0')
1197           ++p;
1198         break;
1199
1200       case '[':
1201         open = 1;
1202         break;
1203
1204       case ']':
1205         if (open)
1206           return 1;
1207         break;
1208       }
1209
1210   return 0;
1211 }
1212 # ifdef _LIBC
1213 weak_alias (__glob_pattern_p, glob_pattern_p)
1214 # endif
1215 #endif
1216
1217
1218 /* Like `glob', but PATTERN is a final pathname component,
1219    and matches are searched for in DIRECTORY.
1220    The GLOB_NOSORT bit in FLAGS is ignored.  No sorting is ever done.
1221    The GLOB_APPEND flag is assumed to be set (always appends).  */
1222 static int
1223 glob_in_dir (pattern, directory, flags, errfunc, pglob)
1224      const char *pattern;
1225      const char *directory;
1226      int flags;
1227      int (*errfunc) __P ((const char *, int));
1228      glob_t *pglob;
1229 {
1230   __ptr_t stream = NULL;
1231
1232   struct globlink
1233     {
1234       struct globlink *next;
1235       char *name;
1236     };
1237   struct globlink *names = NULL;
1238   size_t nfound;
1239   int meta;
1240   int save;
1241
1242 #ifdef VMS
1243   if (*directory == 0)
1244     directory = "[]";
1245 #endif
1246   meta = __glob_pattern_p (pattern, !(flags & GLOB_NOESCAPE));
1247   if (meta == 0)
1248     {
1249       if (flags & (GLOB_NOCHECK|GLOB_NOMAGIC))
1250         /* We need not do any tests.  The PATTERN contains no meta
1251            characters and we must not return an error therefore the
1252            result will always contain exactly one name.  */
1253         flags |= GLOB_NOCHECK;
1254       else
1255         {
1256           /* Since we use the normal file functions we can also use stat()
1257              to verify the file is there.  */
1258           struct stat st;
1259           size_t patlen = strlen (pattern);
1260           size_t dirlen = strlen (directory);
1261           char *fullname = (char *) __alloca (dirlen + 1 + patlen + 1);
1262
1263 # ifdef HAVE_MEMPCPY
1264           mempcpy (mempcpy (mempcpy (fullname, directory, dirlen),
1265                             "/", 1),
1266                    pattern, patlen + 1);
1267 # else
1268           memcpy (fullname, directory, dirlen);
1269           fullname[dirlen] = '/';
1270           memcpy (&fullname[dirlen + 1], pattern, patlen + 1);
1271 # endif
1272           if (((flags & GLOB_ALTDIRFUNC)
1273                ? (*pglob->gl_stat) (fullname, &st)
1274                : __stat (fullname, &st)) == 0)
1275             /* We found this file to be existing.  Now tell the rest
1276                of the function to copy this name into the result.  */
1277             flags |= GLOB_NOCHECK;
1278         }
1279
1280       nfound = 0;
1281     }
1282   else
1283     {
1284       if (pattern[0] == '\0')
1285         {
1286           /* This is a special case for matching directories like in
1287              "*a/".  */
1288           names = (struct globlink *) __alloca (sizeof (struct globlink));
1289           names->name = (char *) malloc (1);
1290           if (names->name == NULL)
1291             goto memory_error;
1292           names->name[0] = '\0';
1293           names->next = NULL;
1294           nfound = 1;
1295           meta = 0;
1296         }
1297       else
1298         {
1299           stream = ((flags & GLOB_ALTDIRFUNC)
1300                     ? (*pglob->gl_opendir) (directory)
1301                     : (__ptr_t) opendir (directory));
1302           if (stream == NULL)
1303             {
1304               if (errno != ENOTDIR
1305                   && ((errfunc != NULL && (*errfunc) (directory, errno))
1306                       || (flags & GLOB_ERR)))
1307                 return GLOB_ABORTED;
1308               nfound = 0;
1309               meta = 0;
1310             }
1311           else
1312             {
1313               int fnm_flags = ((!(flags & GLOB_PERIOD) ? FNM_PERIOD : 0)
1314                                | ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0)
1315 #if defined HAVE_CASE_INSENSITIVE_FS
1316                                    | FNM_CASEFOLD
1317 #endif
1318                                    );
1319               nfound = 0;
1320               flags |= GLOB_MAGCHAR;
1321
1322               while (1)
1323                 {
1324                   const char *name;
1325                   size_t len;
1326                   struct dirent *d = ((flags & GLOB_ALTDIRFUNC)
1327                                       ? (*pglob->gl_readdir) (stream)
1328                                       : readdir ((DIR *) stream));
1329                   if (d == NULL)
1330                     break;
1331                   if (! REAL_DIR_ENTRY (d))
1332                     continue;
1333
1334 #ifdef HAVE_D_TYPE
1335                   /* If we shall match only directories use the information
1336                      provided by the dirent call if possible.  */
1337                   if ((flags & GLOB_ONLYDIR)
1338                       && d->d_type != DT_UNKNOWN && d->d_type != DT_DIR && d->d_type != DT_LNK)
1339                     continue;
1340 #endif
1341
1342                   name = d->d_name;
1343
1344                   if (fnmatch (pattern, name, fnm_flags) == 0)
1345                     {
1346                       struct globlink *new = (struct globlink *)
1347                         __alloca (sizeof (struct globlink));
1348                       len = NAMLEN (d);
1349                       new->name = (char *) malloc (len + 1);
1350                       if (new->name == NULL)
1351                         goto memory_error;
1352 #ifdef HAVE_MEMPCPY
1353                       *((char *) mempcpy ((__ptr_t) new->name, name, len))
1354                         = '\0';
1355 #else
1356                       memcpy ((__ptr_t) new->name, name, len);
1357                       new->name[len] = '\0';
1358 #endif
1359                       new->next = names;
1360                       names = new;
1361                       ++nfound;
1362                     }
1363                 }
1364             }
1365         }
1366     }
1367
1368   if (nfound == 0 && (flags & GLOB_NOCHECK))
1369     {
1370       size_t len = strlen (pattern);
1371       nfound = 1;
1372       names = (struct globlink *) __alloca (sizeof (struct globlink));
1373       names->next = NULL;
1374       names->name = (char *) malloc (len + 1);
1375       if (names->name == NULL)
1376         goto memory_error;
1377 #ifdef HAVE_MEMPCPY
1378       *((char *) mempcpy (names->name, pattern, len)) = '\0';
1379 #else
1380       memcpy (names->name, pattern, len);
1381       names->name[len] = '\0';
1382 #endif
1383     }
1384
1385   if (nfound != 0)
1386     {
1387       pglob->gl_pathv
1388         = (char **) realloc (pglob->gl_pathv,
1389                              (pglob->gl_pathc +
1390                               ((flags & GLOB_DOOFFS) ? pglob->gl_offs : 0) +
1391                               nfound + 1) *
1392                              sizeof (char *));
1393       if (pglob->gl_pathv == NULL)
1394         goto memory_error;
1395
1396       if (flags & GLOB_DOOFFS)
1397         while (pglob->gl_pathc < pglob->gl_offs)
1398           pglob->gl_pathv[pglob->gl_pathc++] = NULL;
1399
1400       for (; names != NULL; names = names->next)
1401         pglob->gl_pathv[pglob->gl_pathc++] = names->name;
1402       pglob->gl_pathv[pglob->gl_pathc] = NULL;
1403
1404       pglob->gl_flags = flags;
1405     }
1406
1407   save = errno;
1408   if (stream != NULL)
1409     {
1410       if (flags & GLOB_ALTDIRFUNC)
1411         (*pglob->gl_closedir) (stream);
1412       else
1413         closedir ((DIR *) stream);
1414     }
1415   __set_errno (save);
1416
1417   return nfound == 0 ? GLOB_NOMATCH : 0;
1418
1419  memory_error:
1420   {
1421     save = errno;
1422     if (flags & GLOB_ALTDIRFUNC)
1423       (*pglob->gl_closedir) (stream);
1424     else
1425       closedir ((DIR *) stream);
1426     __set_errno (save);
1427   }
1428   while (names != NULL)
1429     {
1430       if (names->name != NULL)
1431         free ((__ptr_t) names->name);
1432       names = names->next;
1433     }
1434   return GLOB_NOSPACE;
1435 }
1436
1437 #endif  /* Not ELIDE_CODE.  */