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