* Update to GPLv3
[make.git] / glob / glob.c
blob1f306176bcf79fe67fb0f2f5eba36a62265d3b47
1 /* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999 Free
2 Software Foundation, Inc.
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.
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.
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. */
19 /* AIX requires this to be the first thing in the file. */
20 #if defined _AIX && !defined __GNUC__
21 #pragma alloca
22 #endif
24 #ifdef HAVE_CONFIG_H
25 # include <config.h>
26 #endif
28 /* Enable GNU extensions in glob.h. */
29 #ifndef _GNU_SOURCE
30 # define _GNU_SOURCE 1
31 #endif
33 #include <errno.h>
34 #include <sys/types.h>
35 #include <sys/stat.h>
37 /* Outcomment the following line for production quality code. */
38 /* #define NDEBUG 1 */
39 #include <assert.h>
41 #include <stdio.h> /* Needed on stupid SunOS for assert. */
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. */
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
60 #ifndef ELIDE_CODE
62 #if defined STDC_HEADERS || defined __GNU_LIBRARY__
63 # include <stddef.h>
64 #endif
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
75 #if !defined _AMIGA && !defined VMS && !defined WINDOWS32
76 # include <pwd.h>
77 #endif
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
86 #ifndef NULL
87 # define NULL 0
88 #endif
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
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
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
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 */
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. */
139 extern char *getenv ();
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
151 extern char *malloc (), *realloc ();
152 extern void free ();
154 extern void qsort ();
155 extern void abort (), exit ();
157 #endif /* Standard headers. */
159 #ifndef ANSI_STRING
161 # ifndef bzero
162 extern void bzero ();
163 # endif
164 # ifndef bcopy
165 extern void bcopy ();
166 # endif
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. */
175 #if !defined HAVE_STRCOLL && !defined _LIBC
176 # define strcoll strcmp
177 #endif
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
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
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);
206 # define realloc my_realloc
207 # endif /* __SASC */
208 #endif /* __GNU_LIBRARY__ */
211 #if !defined __alloca && !defined __GNU_LIBRARY__
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. */
230 # define __alloca alloca
232 #endif
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
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
258 #if !(defined STDC_HEADERS || defined __GNU_LIBRARY__)
259 # undef size_t
260 # define size_t unsigned int
261 #endif
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>
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>
286 #ifdef HAVE_GETLOGIN_R
287 extern int getlogin_r __P ((char *, size_t));
288 #else
289 extern char *getlogin __P ((void));
290 #endif
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));
304 #if !defined _LIBC || !defined NO_GLOB_PATTERN_P
305 int __glob_pattern_p __P ((const char *pattern, int quote));
306 #endif
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;
318 unsigned int depth = 0;
319 const char *cp = begin;
321 while (1)
323 if (depth == 0)
325 if (*cp != ',' && *cp != '}' && *cp != '\0')
327 if (*cp == '{')
328 ++depth;
329 ++cp;
330 continue;
333 else
335 while (*cp != '\0' && (*cp != '}' || depth > 0))
337 if (*cp == '}')
338 --depth;
339 ++cp;
341 if (*cp == '\0')
342 /* An incorrectly terminated brace expression. */
343 return NULL;
345 continue;
347 break;
350 return cp;
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. */
362 glob (pattern, flags, errfunc, pglob)
363 const char *pattern;
364 int flags;
365 int (*errfunc) __P ((const char *, int));
366 glob_t *pglob;
368 const char *filename;
369 const char *dirname;
370 size_t dirlen;
371 int status;
372 int oldcount;
374 if (pattern == NULL || pglob == NULL || (flags & ~__GLOB_FLAGS) != 0)
376 __set_errno (EINVAL);
377 return -1;
380 if (flags & GLOB_BRACE)
382 const char *begin = strchr (pattern, '{');
383 if (begin != NULL)
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)
399 if (!(flags & GLOB_APPEND))
400 globfree (pglob);
401 return GLOB_NOSPACE;
403 #endif
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
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)
418 /* It is an illegal expression. */
419 #ifndef __GNUC__
420 free (onealt);
421 #endif
422 return glob (pattern, flags & ~GLOB_BRACE, errfunc, pglob);
425 /* Now find the end of the whole brace expression. */
426 rest = next;
427 while (*rest != '}')
429 rest = next_brace_sub (rest + 1);
430 if (rest == NULL)
432 /* It is an illegal expression. */
433 #ifndef __GNUC__
434 free (onealt);
435 #endif
436 return glob (pattern, flags & ~GLOB_BRACE, errfunc, pglob);
439 /* Please note that we now can be sure the brace expression
440 is well-formed. */
441 rest_len = strlen (++rest) + 1;
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. */
449 if (!(flags & GLOB_APPEND))
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;
456 firstc = pglob->gl_pathc;
458 p = begin + 1;
459 while (1)
461 int result;
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
471 result = glob (onealt,
472 ((flags & ~(GLOB_NOCHECK|GLOB_NOMAGIC))
473 | GLOB_APPEND), errfunc, pglob);
475 /* If we got an error, return it. */
476 if (result && result != GLOB_NOMATCH)
478 #ifndef __GNUC__
479 free (onealt);
480 #endif
481 if (!(flags & GLOB_APPEND))
482 globfree (pglob);
483 return result;
486 if (*next == '}')
487 /* We saw the last entry. */
488 break;
490 p = next + 1;
491 next = next_brace_sub (p);
492 assert (next != NULL);
495 #ifndef __GNUC__
496 free (onealt);
497 #endif
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;
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)
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] == '~')
523 dirname = pattern;
524 dirlen = strlen (pattern);
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;
531 else
533 filename = pattern;
534 #ifdef _AMIGA
535 dirname = "";
536 #else
537 dirname = ".";
538 #endif
539 dirlen = 0;
542 else if (filename == pattern)
544 /* "/pattern". */
545 dirname = "/";
546 dirlen = 1;
547 ++filename;
549 else
551 char *newp;
552 dirlen = filename - pattern;
553 #if defined __MSDOS__ || defined WINDOWS32
554 if (*filename == ':'
555 || (filename > pattern + 1 && filename[-1] == ':'))
557 char *drive_spec;
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.*/
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;
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. */
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;
603 if (!(flags & GLOB_APPEND))
605 pglob->gl_pathc = 0;
606 pglob->gl_pathv = NULL;
609 oldcount = pglob->gl_pathc;
611 #ifndef VMS
612 if ((flags & (GLOB_TILDE|GLOB_TILDE_CHECK)) && dirname[0] == '~')
614 if (dirname[1] == '\0' || dirname[1] == '/')
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')
638 int success;
639 char *name;
640 # if defined HAVE_GETLOGIN_R || defined _LIBC
641 size_t buflen = sysconf (_SC_LOGIN_NAME_MAX) + 1;
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);
649 success = getlogin_r (name, buflen) >= 0;
650 # else
651 success = (name = getlogin ()) != NULL;
652 # endif
653 if (success)
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;
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);
668 while (getpwnam_r (name, &pwbuf, pwtmpbuf, pwbuflen, &p)
669 != 0)
671 if (errno != ERANGE)
673 p = NULL;
674 break;
676 pwbuflen *= 2;
677 pwtmpbuf = (char *) __alloca (pwbuflen);
678 __set_errno (save);
680 # else
681 p = getpwnam (name);
682 # endif
683 if (p != NULL)
684 home_dir = p->pw_dir;
687 if (home_dir == NULL || home_dir[0] == '\0')
689 if (flags & GLOB_TILDE_CHECK)
690 return GLOB_NOMATCH;
691 else
692 home_dir = "~"; /* No luck. */
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
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;
715 # if !defined _AMIGA && !defined WINDOWS32 && !defined VMS
716 else
718 char *end_name = strchr (dirname, '/');
719 const char *user_name;
720 const char *home_dir;
722 if (end_name == NULL)
723 user_name = dirname + 1;
724 else
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;
738 /* Look up specific user's home directory. */
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;
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);
753 while (getpwnam_r (user_name, &pwbuf, pwtmpbuf, buflen, &p) != 0)
755 if (errno != ERANGE)
757 p = NULL;
758 break;
760 buflen *= 2;
761 pwtmpbuf = __alloca (buflen);
762 __set_errno (save);
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;
772 /* If we found a home directory use this. */
773 if (home_dir != NULL)
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;
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;
795 # endif /* Not Amiga && not WINDOWS32 && not VMS. */
797 #endif /* Not VMS. */
799 /* Now test whether we looked for "~" or "~NAME". In this case we
800 can give the answer now. */
801 if (filename == NULL)
803 struct stat st;
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)))
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;
822 if (flags & GLOB_DOOFFS)
823 while (pglob->gl_pathc < pglob->gl_offs)
824 pglob->gl_pathv[pglob->gl_pathc++] = NULL;
826 #if defined HAVE_STRDUP || defined _LIBC
827 pglob->gl_pathv[pglob->gl_pathc] = strdup (dirname);
828 #else
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);
836 #endif
837 if (pglob->gl_pathv[pglob->gl_pathc] == NULL)
839 free (pglob->gl_pathv);
840 return GLOB_NOSPACE;
842 pglob->gl_pathv[++pglob->gl_pathc] = NULL;
843 pglob->gl_flags = flags;
845 return 0;
848 /* Not found. */
849 return GLOB_NOMATCH;
852 if (__glob_pattern_p (dirname, !(flags & GLOB_NOESCAPE)))
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;
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;
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)
872 int old_pathc;
874 #ifdef SHELL
876 /* Make globbing interruptible in the bash shell. */
877 extern int interrupt_state;
879 if (interrupt_state)
881 globfree (&dirs);
882 globfree (&files);
883 return GLOB_ABORTED;
886 #endif /* SHELL. */
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;
897 if (status != 0)
899 globfree (&dirs);
900 globfree (pglob);
901 return status;
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))
909 globfree (&dirs);
910 globfree (pglob);
911 return GLOB_NOSPACE;
915 flags |= GLOB_MAGCHAR;
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)
923 /* No matches. */
924 if (flags & GLOB_NOCHECK)
926 size_t filename_len = strlen (filename) + 1;
927 char **new_pathv;
928 struct stat st;
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)
940 globfree (&dirs);
941 return GLOB_NOSPACE;
944 if (flags & GLOB_DOOFFS)
945 while (pglob->gl_pathc < pglob->gl_offs)
946 pglob->gl_pathv[pglob->gl_pathc++] = NULL;
948 for (i = 0; i < dirs.gl_pathc; ++i)
950 const char *dir = dirs.gl_pathv[i];
951 size_t dir_len = strlen (dir);
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;
960 pglob->gl_pathv[pglob->gl_pathc] = malloc (dir_len + 1
961 + filename_len);
962 if (pglob->gl_pathv[pglob->gl_pathc] == NULL)
964 globfree (&dirs);
965 globfree (pglob);
966 return GLOB_NOSPACE;
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;
983 pglob->gl_pathv[pglob->gl_pathc] = NULL;
984 pglob->gl_flags = flags;
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;
993 else
994 return GLOB_NOMATCH;
997 globfree (&dirs);
999 else
1001 status = glob_in_dir (filename, dirname, flags, errfunc, pglob);
1002 if (status != 0)
1003 return status;
1005 if (dirlen > 0)
1007 /* Stick the directory on the front of each name. */
1008 int ignore = oldcount;
1010 if ((flags & GLOB_DOOFFS) && ignore < pglob->gl_offs)
1011 ignore = pglob->gl_offs;
1013 if (prefix_array (dirname,
1014 &pglob->gl_pathv[ignore],
1015 pglob->gl_pathc - ignore))
1017 globfree (pglob);
1018 return GLOB_NOSPACE;
1023 if (flags & GLOB_MARK)
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))
1034 size_t len = strlen (pglob->gl_pathv[i]) + 2;
1035 char *new = realloc (pglob->gl_pathv[i], len);
1036 if (new == NULL)
1038 globfree (pglob);
1039 return GLOB_NOSPACE;
1041 strcpy (&new[len - 2], "/");
1042 pglob->gl_pathv[i] = new;
1046 if (!(flags & GLOB_NOSORT))
1048 /* Sort the vector. */
1049 int non_sort = oldcount;
1051 if ((flags & GLOB_DOOFFS) && pglob->gl_offs > oldcount)
1052 non_sort = pglob->gl_offs;
1054 qsort ((__ptr_t) &pglob->gl_pathv[non_sort],
1055 pglob->gl_pathc - non_sort,
1056 sizeof (char *), collated_compare);
1059 return 0;
1063 /* Free storage allocated in PGLOB by a previous `glob' call. */
1064 void
1065 globfree (pglob)
1066 register glob_t *pglob;
1068 if (pglob->gl_pathv != NULL)
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);
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;
1085 const char *const s1 = *(const char *const * const) a;
1086 const char *const s2 = *(const char *const * const) b;
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);
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;
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
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)
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] == ':')
1129 /* DIRNAME is "d:". Use `:' instead of `/'. */
1130 --dirlen;
1131 sep_char = ':';
1134 #endif
1136 for (i = 0; i < n; ++i)
1138 size_t eltlen = strlen (array[i]) + 1;
1139 char *new = (char *) malloc (dirlen + 1 + eltlen);
1140 if (new == NULL)
1142 while (i > 0)
1143 free ((__ptr_t) array[--i]);
1144 return 1;
1147 #ifdef HAVE_MEMPCPY
1149 char *endp = (char *) mempcpy (new, dirname, dirlen);
1150 *endp++ = DIRSEP_CHAR;
1151 mempcpy (endp, array[i], eltlen);
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;
1162 return 0;
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. */
1171 __glob_pattern_p (pattern, quote)
1172 const char *pattern;
1173 int quote;
1175 register const char *p;
1176 int open = 0;
1178 for (p = pattern; *p != '\0'; ++p)
1179 switch (*p)
1181 case '?':
1182 case '*':
1183 return 1;
1185 case '\\':
1186 if (quote && p[1] != '\0')
1187 ++p;
1188 break;
1190 case '[':
1191 open = 1;
1192 break;
1194 case ']':
1195 if (open)
1196 return 1;
1197 break;
1200 return 0;
1202 # ifdef _LIBC
1203 weak_alias (__glob_pattern_p, glob_pattern_p)
1204 # endif
1205 #endif
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;
1220 __ptr_t stream = NULL;
1222 struct globlink
1224 struct globlink *next;
1225 char *name;
1227 struct globlink *names = NULL;
1228 size_t nfound;
1229 int meta;
1230 int save;
1232 #ifdef VMS
1233 if (*directory == 0)
1234 directory = "[]";
1235 #endif
1236 meta = __glob_pattern_p (pattern, !(flags & GLOB_NOESCAPE));
1237 if (meta == 0)
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
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);
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;
1270 nfound = 0;
1272 else
1274 if (pattern[0] == '\0')
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;
1287 else
1289 stream = ((flags & GLOB_ALTDIRFUNC)
1290 ? (*pglob->gl_opendir) (directory)
1291 : (__ptr_t) opendir (directory));
1292 if (stream == NULL)
1294 if (errno != ENOTDIR
1295 && ((errfunc != NULL && (*errfunc) (directory, errno))
1296 || (flags & GLOB_ERR)))
1297 return GLOB_ABORTED;
1298 nfound = 0;
1299 meta = 0;
1301 else
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
1309 nfound = 0;
1310 flags |= GLOB_MAGCHAR;
1312 while (1)
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;
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
1332 name = d->d_name;
1334 if (fnmatch (pattern, name, fnm_flags) == 0)
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;
1358 if (nfound == 0 && (flags & GLOB_NOCHECK))
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
1375 if (nfound != 0)
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;
1386 if (flags & GLOB_DOOFFS)
1387 while (pglob->gl_pathc < pglob->gl_offs)
1388 pglob->gl_pathv[pglob->gl_pathc++] = NULL;
1390 for (; names != NULL; names = names->next)
1391 pglob->gl_pathv[pglob->gl_pathc++] = names->name;
1392 pglob->gl_pathv[pglob->gl_pathc] = NULL;
1394 pglob->gl_flags = flags;
1397 save = errno;
1398 if (stream != NULL)
1400 if (flags & GLOB_ALTDIRFUNC)
1401 (*pglob->gl_closedir) (stream);
1402 else
1403 closedir ((DIR *) stream);
1405 __set_errno (save);
1407 return nfound == 0 ? GLOB_NOMATCH : 0;
1409 memory_error:
1411 int save = errno;
1412 if (flags & GLOB_ALTDIRFUNC)
1413 (*pglob->gl_closedir) (stream);
1414 else
1415 closedir ((DIR *) stream);
1416 __set_errno (save);
1418 while (names != NULL)
1420 if (names->name != NULL)
1421 free ((__ptr_t) names->name);
1422 names = names->next;
1424 return GLOB_NOSPACE;
1427 #endif /* Not ELIDE_CODE. */