1 /* glob.c -- file-name wildcard pattern matching for Bash.
3 Copyright (C) 1985-2009 Free Software Foundation, Inc.
5 This file is part of GNU Bash, the Bourne-Again SHell.
7 Bash is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 Bash is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with Bash. If not, see <http://www.gnu.org/licenses/>.
21 /* To whomever it may concern: I have never seen the code which most
22 Unix programs use to perform this function. I wrote this from scratch
23 based on specifications for the pattern matching. --RMS. */
27 #if !defined (__GNUC__) && !defined (HAVE_ALLOCA_H) && defined (_AIX)
29 #endif /* _AIX && RISC6000 && !__GNUC__ */
31 #include "bashtypes.h"
33 #if defined (HAVE_UNISTD_H)
39 #include "posixstat.h"
58 #if !defined (HAVE_BCOPY) && !defined (bcopy)
59 # define bcopy(s, d, n) ((void) memcpy ((d), (s), (n)))
60 #endif /* !HAVE_BCOPY && !bcopy */
63 # if defined (__STDC__)
64 # define NULL ((void *) 0)
67 # endif /* __STDC__ */
71 # define FREE(x) if (x) free (x)
74 /* Don't try to alloca() more than this much memory for `struct globval'
77 # define ALLOCA_MAX 100000
86 extern void throw_to_top_level __P((void));
87 extern int sh_eaccess __P((char *, int));
88 extern char *sh_makepath __P((const char *, const char *, int));
89 extern int signal_is_pending __P((int));
90 extern void run_pending_traps __P((void));
92 extern int extended_glob;
94 /* Global variable which controls whether or not * matches .*.
95 Non-zero means don't match .*. */
96 int noglob_dot_filenames = 1;
98 /* Global variable which controls whether or not filename globbing
99 is done without regard to case. */
100 int glob_ignore_case = 0;
102 /* Global variable to return to signify an error in globbing. */
103 char *glob_error_return;
105 static struct globval finddirs_error_return;
107 /* Some forward declarations. */
108 static int skipname __P((char *, char *, int));
110 static int mbskipname __P((char *, char *, int));
113 static void udequote_pathname __P((char *));
114 static void wdequote_pathname __P((char *));
116 # define dequote_pathname udequote_pathname
118 static void dequote_pathname __P((char *));
119 static int glob_testdir __P((char *, int));
120 static char **glob_dir_to_array __P((char *, char **, int));
122 /* Make sure these names continue to agree with what's in smatch.c */
123 extern char *glob_patscan __P((char *, char *, int));
124 extern wchar_t *glob_patscan_wc __P((wchar_t *, wchar_t *, int));
126 /* Compile `glob_loop.c' for single-byte characters. */
127 #define CHAR unsigned char
130 #define INTERNAL_GLOB_PATTERN_P internal_glob_pattern_p
131 #include "glob_loop.c"
133 /* Compile `glob_loop.c' again for multibyte characters. */
139 #define INTERNAL_GLOB_PATTERN_P internal_glob_wpattern_p
140 #include "glob_loop.c"
142 #endif /* HANDLE_MULTIBYTE */
144 /* And now a function that calls either the single-byte or multibyte version
145 of internal_glob_pattern_p. */
147 glob_pattern_p (pattern)
156 return (internal_glob_pattern_p ((unsigned char *)pattern));
158 /* Convert strings to wide chars, and call the multibyte version. */
159 n = xdupmbstowcs (&wpattern, NULL, pattern);
161 /* Oops. Invalid multibyte sequence. Try it as single-byte sequence. */
162 return (internal_glob_pattern_p ((unsigned char *)pattern));
164 r = internal_glob_wpattern_p (wpattern);
169 return (internal_glob_pattern_p (pattern));
174 /* Return 1 if all subpatterns in the extended globbing pattern PAT indicate
175 that the name should be skipped. XXX - doesn't handle pattern negation,
176 not sure if it should */
178 extglob_skipname (pat, dname, flags)
186 pe = pp + strlen (pp) - 1; /*(*/
189 if ((t = strchr (pp, '|')) == 0) /* easy case first */
192 r = skipname (pp, dname, flags); /*(*/
196 while (t = glob_patscan (pp, pe, '|'))
200 r = skipname (pp, dname, flags);
202 if (r == 0) /* if any pattern says not skip, we don't skip */
207 if (pp == pe) /* glob_patscan might find end of pattern */
211 # if defined (HANDLE_MULTIBYTE)
212 r = mbskipname (pp, dname, flags); /*(*/
214 r = skipname (pp, dname, flags); /*(*/
221 /* Return 1 if DNAME should be skipped according to PAT. Mostly concerned
222 with matching leading `.'. */
224 skipname (pat, dname, flags)
230 if (extglob_pattern_p (pat)) /* XXX */
231 return (extglob_skipname (pat, dname, flags));
234 /* If a leading dot need not be explicitly matched, and the pattern
235 doesn't start with a `.', don't match `.' or `..' */
236 if (noglob_dot_filenames == 0 && pat[0] != '.' &&
237 (pat[0] != '\\' || pat[1] != '.') &&
239 (dname[1] == '\0' || (dname[1] == '.' && dname[2] == '\0'))))
242 /* If a dot must be explicitly matched, check to see if they do. */
243 else if (noglob_dot_filenames && dname[0] == '.' && pat[0] != '.' &&
244 (pat[0] != '\\' || pat[1] != '.'))
253 wchkname (pat_wc, dn_wc)
254 wchar_t *pat_wc, *dn_wc;
256 /* If a leading dot need not be explicitly matched, and the
257 pattern doesn't start with a `.', don't match `.' or `..' */
258 if (noglob_dot_filenames == 0 && pat_wc[0] != L'.' &&
259 (pat_wc[0] != L'\\' || pat_wc[1] != L'.') &&
261 (dn_wc[1] == L'\0' || (dn_wc[1] == L'.' && dn_wc[2] == L'\0'))))
264 /* If a leading dot must be explicitly matched, check to see if the
265 pattern and dirname both have one. */
266 else if (noglob_dot_filenames && dn_wc[0] == L'.' &&
268 (pat_wc[0] != L'\\' || pat_wc[1] != L'.'))
275 wextglob_skipname (pat, dname, flags)
276 wchar_t *pat, *dname;
280 wchar_t *pp, *pe, *t, n;
284 pe = pp + wcslen (pp) - 1; /*(*/
287 if ((t = wcschr (pp, L'|')) == 0)
290 r = wchkname (pp, dname); /*(*/
294 while (t = glob_patscan_wc (pp, pe, '|'))
298 r = wchkname (pp, dname);
305 if (pp == pe) /* glob_patscan_wc might find end of pattern */
309 r = wchkname (pp, dname); /*(*/
313 return (wchkname (pat, dname));
317 /* Return 1 if DNAME should be skipped according to PAT. Handles multibyte
318 characters in PAT and DNAME. Mostly concerned with matching leading `.'. */
320 mbskipname (pat, dname, flags)
325 wchar_t *pat_wc, *dn_wc;
328 if (mbsmbchar (dname) == 0 && mbsmbchar (pat) == 0)
329 return (skipname (pat, dname, flags));
333 ext = extglob_pattern_p (pat);
336 pat_wc = dn_wc = (wchar_t *)NULL;
338 pat_n = xdupmbstowcs (&pat_wc, NULL, pat);
339 if (pat_n != (size_t)-1)
340 dn_n = xdupmbstowcs (&dn_wc, NULL, dname);
343 if (pat_n != (size_t)-1 && dn_n !=(size_t)-1)
344 ret = ext ? wextglob_skipname (pat_wc, dn_wc, flags) : wchkname (pat_wc, dn_wc);
346 ret = skipname (pat, dname, flags);
353 #endif /* HANDLE_MULTIBYTE */
355 /* Remove backslashes quoting characters in PATHNAME by modifying PATHNAME. */
357 udequote_pathname (pathname)
362 for (i = j = 0; pathname && pathname[i]; )
364 if (pathname[i] == '\\')
367 pathname[j++] = pathname[i++];
369 if (pathname[i - 1] == 0)
377 /* Remove backslashes quoting characters in PATHNAME by modifying PATHNAME. */
379 wdequote_pathname (pathname)
386 wchar_t *orig_wpathname;
388 len = strlen (pathname);
389 /* Convert the strings into wide characters. */
390 n = xdupmbstowcs (&wpathname, NULL, pathname);
391 if (n == (size_t) -1)
393 /* Something wrong. Fall back to single-byte */
394 udequote_pathname (pathname);
397 orig_wpathname = wpathname;
399 for (i = j = 0; wpathname && wpathname[i]; )
401 if (wpathname[i] == L'\\')
404 wpathname[j++] = wpathname[i++];
406 if (wpathname[i - 1] == L'\0')
410 wpathname[j] = L'\0';
412 /* Convert the wide character string into unibyte character set. */
413 memset (&ps, '\0', sizeof(mbstate_t));
414 n = wcsrtombs(pathname, (const wchar_t **)&wpathname, len, &ps);
415 pathname[len] = '\0';
417 /* Can't just free wpathname here; wcsrtombs changes it in many cases. */
418 free (orig_wpathname);
422 dequote_pathname (pathname)
426 wdequote_pathname (pathname);
428 udequote_pathname (pathname);
430 #endif /* HANDLE_MULTIBYTE */
432 /* Test whether NAME exists. */
434 #if defined (HAVE_LSTAT)
435 # define GLOB_TESTNAME(name) (lstat (name, &finfo))
436 #else /* !HAVE_LSTAT */
438 # define GLOB_TESTNAME(name) (sh_eaccess (name, F_OK))
440 # define GLOB_TESTNAME(name) (access (name, F_OK))
442 #endif /* !HAVE_LSTAT */
444 /* Return 0 if DIR is a directory, -1 otherwise. */
446 glob_testdir (dir, flags)
453 /*itrace("glob_testdir: testing %s" flags = %d, dir, flags);*/
454 #if defined (HAVE_LSTAT)
455 r = (flags & GX_ALLDIRS) ? lstat (dir, &finfo) : stat (dir, &finfo);
457 r = stat (dir, &finfo);
462 if (S_ISDIR (finfo.st_mode) == 0)
468 /* Recursively scan SDIR for directories matching PAT (PAT is always `**').
469 FLAGS is simply passed down to the recursive call to glob_vector. Returns
470 a list of matching directory names. EP, if non-null, is set to the last
471 element of the returned list. NP, if non-null, is set to the number of
472 directories in the returned list. These two variables exist for the
473 convenience of the caller (always glob_vector). */
474 static struct globval *
475 finddirs (pat, sdir, flags, ep, np)
484 struct globval *ret, *e, *g;
486 /*itrace("finddirs: pat = `%s' sdir = `%s' flags = 0x%x", pat, sdir, flags);*/
488 r = glob_vector (pat, sdir, flags);
489 if (r == 0 || r[0] == 0)
495 if (r && r != &glob_error_return)
497 return (struct globval *)0;
499 for (ndirs = 0; r[ndirs] != 0; ndirs++)
501 g = (struct globval *) malloc (sizeof (struct globval));
504 while (ret) /* free list built so far */
516 return (&finddirs_error_return);
536 /* Return a vector of names of files in directory DIR
537 whose names match glob pattern PAT.
538 The names are not in any particular order.
539 Wildcards at the beginning of PAT do not match an initial period.
541 The vector is terminated by an element that is a null pointer.
543 To free the space allocated, first free the vector's elements,
544 then free the vector.
546 Return 0 if cannot get enough memory to hold the pointer
549 Return -1 if cannot access directory DIR.
550 Look in errno for more information. */
553 glob_vector (pat, dir, flags)
559 register struct dirent *dp;
560 struct globval *lastlink, *e, *dirlist;
561 register struct globval *nextlink;
562 register char *nextname, *npat, *subdir;
564 int lose, skip, ndirs, isdir, sdlen, add_current, patlen;
565 register char **name_vector;
566 register unsigned int i;
567 int mflags; /* Flags passed to strmatch (). */
568 int pflags; /* flags passed to sh_makepath () */
570 struct globval *firstmalloc, *tmplink;
574 count = lose = skip = add_current = 0;
579 /*itrace("glob_vector: pat = `%s' dir = `%s' flags = 0x%x", pat, dir, flags);*/
580 /* If PAT is empty, skip the loop, but return one (empty) filename. */
581 if (pat == 0 || *pat == '\0')
583 if (glob_testdir (dir, 0) < 0)
584 return ((char **) &glob_error_return);
586 nextlink = (struct globval *)alloca (sizeof (struct globval));
587 if (nextlink == NULL)
588 return ((char **) NULL);
590 nextlink->next = (struct globval *)0;
591 nextname = (char *) malloc (1);
597 nextlink->name = nextname;
605 patlen = (pat && *pat) ? strlen (pat) : 0;
607 /* If the filename pattern (PAT) does not contain any globbing characters,
608 we can dispense with reading the directory, and just see if there is
609 a filename `DIR/PAT'. If there is, and we can access it, just make the
610 vector to return and bail immediately. */
611 if (skip == 0 && glob_pattern_p (pat) == 0)
616 if (glob_testdir (dir, 0) < 0)
617 return ((char **) &glob_error_return);
619 dirlen = strlen (dir);
620 nextname = (char *)malloc (dirlen + patlen + 2);
621 npat = (char *)malloc (patlen + 1);
622 if (nextname == 0 || npat == 0)
631 dequote_pathname (npat);
633 strcpy (nextname, dir);
634 nextname[dirlen++] = '/';
635 strcpy (nextname + dirlen, npat);
637 if (GLOB_TESTNAME (nextname) >= 0)
640 nextlink = (struct globval *)alloca (sizeof (struct globval));
643 nextlink->next = (struct globval *)0;
645 nextlink->name = npat;
666 /* Open the directory, punting immediately if we cannot. If opendir
667 is not robust (i.e., it opens non-directories successfully), test
668 that DIR is a directory and punt if it's not. */
669 #if defined (OPENDIR_NOT_ROBUST)
670 if (glob_testdir (dir, 0) < 0)
671 return ((char **) &glob_error_return);
676 return ((char **) &glob_error_return);
678 /* Compute the flags that will be passed to strmatch(). We don't
679 need to do this every time through the loop. */
680 mflags = (noglob_dot_filenames ? FNM_PERIOD : 0) | FNM_PATHNAME;
683 if (glob_ignore_case)
684 mflags |= FNM_CASEFOLD;
688 mflags |= FNM_EXTMATCH;
690 add_current = ((flags & (GX_ALLDIRS|GX_ADDCURDIR)) == (GX_ALLDIRS|GX_ADDCURDIR));
692 /* Scan the directory, finding all names that match.
693 For each name that matches, allocate a struct globval
694 on the stack and store the name in it.
695 Chain those structs together; lastlink is the front of the chain. */
698 /* Make globbing interruptible in the shell. */
699 if (interrupt_state || terminating_signal)
704 else if (signal_is_pending (SIGINT)) /* XXX - make SIGINT traps responsive */
714 /* If this directory entry is not to be used, try again. */
715 if (REAL_DIR_ENTRY (dp) == 0)
719 if (dp->d_name == 0 || *dp->d_name == 0)
724 if (MB_CUR_MAX > 1 && mbskipname (pat, dp->d_name, flags))
728 if (skipname (pat, dp->d_name, flags))
731 /* If we're only interested in directories, don't bother with files */
732 if (flags & (GX_MATCHDIRS|GX_ALLDIRS))
734 pflags = (flags & GX_ALLDIRS) ? MP_RMDOT : 0;
735 if (flags & GX_NULLDIR)
737 subdir = sh_makepath (dir, dp->d_name, pflags);
738 isdir = glob_testdir (subdir, flags);
739 if (isdir < 0 && (flags & GX_MATCHDIRS))
746 if (flags & GX_ALLDIRS)
750 dirlist = finddirs (pat, subdir, (flags & ~GX_ADDCURDIR), &e, &ndirs);
751 if (dirlist == &finddirs_error_return)
757 if (ndirs) /* add recursive directories to list */
759 if (firstmalloc == 0)
767 nextlink = (struct globval *) malloc (sizeof (struct globval));
768 if (firstmalloc == 0)
769 firstmalloc = nextlink;
770 sdlen = strlen (subdir);
771 nextname = (char *) malloc (sdlen + 1);
772 if (nextlink == 0 || nextname == 0)
780 nextlink->next = lastlink;
782 nextlink->name = nextname;
783 bcopy (subdir, nextname, sdlen + 1);
788 else if (flags & GX_MATCHDIRS)
791 convfn = fnx_fromfs (dp->d_name, D_NAMLEN (dp));
792 if (strmatch (pat, convfn, mflags) != FNM_NOMATCH)
794 if (nalloca < ALLOCA_MAX)
796 nextlink = (struct globval *) alloca (sizeof (struct globval));
797 nalloca += sizeof (struct globval);
801 nextlink = (struct globval *) malloc (sizeof (struct globval));
802 if (firstmalloc == 0)
803 firstmalloc = nextlink;
806 nextname = (char *) malloc (D_NAMLEN (dp) + 1);
807 if (nextlink == 0 || nextname == 0)
814 nextlink->next = lastlink;
816 nextlink->name = nextname;
817 bcopy (dp->d_name, nextname, D_NAMLEN (dp) + 1);
825 /* compat: if GX_ADDCURDIR, add the passed directory also. Add an empty
826 directory name as a placeholder if GX_NULLDIR (in which case the passed
827 directory name is "."). */
830 sdlen = strlen (dir);
831 nextname = (char *)malloc (sdlen + 1);
832 nextlink = (struct globval *) malloc (sizeof (struct globval));
833 if (nextlink == 0 || nextname == 0)
841 nextlink->name = nextname;
842 nextlink->next = lastlink;
844 if (flags & GX_NULLDIR)
847 bcopy (dir, nextname, sdlen + 1);
854 name_vector = (char **) malloc ((count + 1) * sizeof (char *));
855 lose |= name_vector == NULL;
858 /* Have we run out of memory? */
863 /* Here free the strings we have got. */
866 /* Since we build the list in reverse order, the first N entries
867 will be allocated with malloc, if firstmalloc is set, from
868 lastlink to firstmalloc. */
871 if (lastlink == firstmalloc)
877 free (lastlink->name);
878 lastlink = lastlink->next;
882 /* Don't call QUIT; here; let higher layers deal with it. */
884 return ((char **)NULL);
887 /* Copy the name pointers from the linked list into the vector. */
888 for (tmplink = lastlink, i = 0; i < count; ++i)
890 name_vector[i] = tmplink->name;
891 tmplink = tmplink->next;
894 name_vector[count] = NULL;
896 /* If we allocated some of the struct globvals, free them now. */
903 if (lastlink == firstmalloc)
904 lastlink = firstmalloc = 0;
906 lastlink = lastlink->next;
911 return (name_vector);
914 /* Return a new array which is the concatenation of each string in ARRAY
915 to DIR. This function expects you to pass in an allocated ARRAY, and
916 it takes care of free()ing that array. Thus, you might think of this
917 function as side-effecting ARRAY. This should handle GX_MARKDIRS. */
919 glob_dir_to_array (dir, array, flags)
923 register unsigned int i, l;
931 if (flags & GX_MARKDIRS)
932 for (i = 0; array[i]; i++)
934 if ((stat (array[i], &sb) == 0) && S_ISDIR (sb.st_mode))
936 l = strlen (array[i]);
937 new = (char *)realloc (array[i], l + 2);
948 add_slash = dir[l - 1] != '/';
951 while (array[i] != NULL)
954 result = (char **) malloc ((i + 1) * sizeof (char *));
958 for (i = 0; array[i] != NULL; i++)
960 /* 3 == 1 for NUL, 1 for slash at end of DIR, 1 for GX_MARKDIRS */
961 result[i] = (char *) malloc (l + strlen (array[i]) + 3);
963 if (result[i] == NULL)
966 for (ind = 0; ind < i; ind++)
972 strcpy (result[i], dir);
975 strcpy (result[i] + l + add_slash, array[i]);
976 if (flags & GX_MARKDIRS)
978 if ((stat (result[i], &sb) == 0) && S_ISDIR (sb.st_mode))
981 rlen = strlen (result[i]);
982 result[i][rlen] = '/';
983 result[i][rlen+1] = '\0';
989 /* Free the input array. */
990 for (i = 0; array[i] != NULL; i++)
992 free ((char *) array);
997 /* Do globbing on PATHNAME. Return an array of pathnames that match,
998 marking the end of the array with a null-pointer as an element.
999 If no pathnames match, then the array is empty (first element is null).
1000 If there isn't enough memory, then return NULL.
1001 If a file system error occurs, return -1; `errno' has the error code. */
1003 glob_filename (pathname, flags)
1008 unsigned int result_size;
1009 char *directory_name, *filename, *dname;
1010 unsigned int directory_len;
1011 int free_dirname; /* flag */
1014 result = (char **) malloc (sizeof (char *));
1021 directory_name = NULL;
1023 /* Find the filename. */
1024 filename = strrchr (pathname, '/');
1025 if (filename == NULL)
1027 filename = pathname;
1028 directory_name = "";
1034 directory_len = (filename - pathname) + 1;
1035 directory_name = (char *) malloc (directory_len + 1);
1037 if (directory_name == 0) /* allocation failed? */
1040 bcopy (pathname, directory_name, directory_len);
1041 directory_name[directory_len] = '\0';
1046 /* If directory_name contains globbing characters, then we
1047 have to expand the previous levels. Just recurse. */
1048 if (directory_len > 0 && glob_pattern_p (directory_name))
1050 char **directories, *d, *p;
1051 register unsigned int i;
1052 int all_starstar, last_starstar;
1054 all_starstar = last_starstar = 0;
1056 dflags = flags & ~GX_MARKDIRS;
1057 /* Collapse a sequence of ** patterns separated by one or more slashes
1058 to a single ** terminated by a slash or NUL */
1059 if ((flags & GX_GLOBSTAR) && d[0] == '*' && d[1] == '*' && (d[2] == '/' || d[2] == '\0'))
1062 while (d[0] == '*' && d[1] == '*' && (d[2] == '/' || d[2] == '\0'))
1077 dflags |= GX_ALLDIRS|GX_ADDCURDIR;
1078 directory_len = strlen (d);
1081 /* If there is a non [star][star]/ component in directory_name, we
1082 still need to collapse trailing sequences of [star][star]/ into
1083 a single one and note that the directory name ends with [star][star],
1084 so we can compensate if filename is [star][star] */
1085 if ((flags & GX_GLOBSTAR) && all_starstar == 0)
1088 prev = dl = directory_len;
1089 while (dl >= 4 && d[dl - 1] == '/' &&
1094 if (dl != directory_len)
1096 directory_len = prev;
1099 /* If the directory name ends in [star][star]/ but the filename is
1100 [star][star], just remove the final [star][star] from the directory
1101 so we don't have to scan everything twice. */
1102 if (last_starstar && directory_len > 4 &&
1103 filename[0] == '*' && filename[1] == '*' && filename[2] == 0)
1108 if (d[directory_len - 1] == '/')
1109 d[directory_len - 1] = '\0';
1111 directories = glob_filename (d, dflags);
1115 free (directory_name);
1116 directory_name = NULL;
1119 if (directories == NULL)
1121 else if (directories == (char **)&glob_error_return)
1123 free ((char *) result);
1124 return ((char **) &glob_error_return);
1126 else if (*directories == NULL)
1128 free ((char *) directories);
1129 free ((char *) result);
1130 return ((char **) &glob_error_return);
1133 /* If we have something like [star][star]/[star][star], it's no use to
1134 glob **, then do it again, and throw half the results away. */
1135 if (all_starstar && filename[0] == '*' && filename[1] == '*' && filename[2] == 0)
1137 free ((char *) directories);
1138 free (directory_name);
1139 directory_name = NULL;
1144 /* We have successfully globbed the preceding directory name.
1145 For each name in DIRECTORIES, call glob_vector on it and
1146 FILENAME. Concatenate the results together. */
1147 for (i = 0; directories[i] != NULL; ++i)
1149 char **temp_results;
1153 /* XXX -- we've recursively scanned any directories resulting from
1154 a `**', so turn off the flag. We turn it on again below if
1156 /* Scan directory even on a NULL filename. That way, `*h/'
1157 returns only directories ending in `h', instead of all
1158 files ending in `h' with a `/' appended. */
1159 dname = directories[i];
1160 dflags = flags & ~(GX_MARKDIRS|GX_ALLDIRS|GX_ADDCURDIR);
1161 if ((flags & GX_GLOBSTAR) && filename[0] == '*' && filename[1] == '*' && filename[2] == '\0')
1162 dflags |= GX_ALLDIRS|GX_ADDCURDIR;
1163 if (dname[0] == '\0' && filename[0])
1165 dflags |= GX_NULLDIR;
1166 dname = "."; /* treat null directory name and non-null filename as current directory */
1168 temp_results = glob_vector (filename, dname, dflags);
1170 /* Handle error cases. */
1171 if (temp_results == NULL)
1173 else if (temp_results == (char **)&glob_error_return)
1174 /* This filename is probably not a directory. Ignore it. */
1179 register unsigned int l;
1181 /* If we're expanding **, we don't need to glue the directory
1182 name to the results; we've already done it in glob_vector */
1183 if ((dflags & GX_ALLDIRS) && filename[0] == '*' && filename[1] == '*' && (filename[2] == '\0' || filename[2] == '/'))
1185 /* When do we remove null elements from temp_results? And
1186 how to avoid duplicate elements in the final result? */
1187 /* If (dflags & GX_NULLDIR) glob_filename potentially left a
1188 NULL placeholder in the temp results just in case
1189 glob_vector/glob_dir_to_array did something with it, but
1190 if it didn't, and we're not supposed to be passing them
1191 through for some reason ((flags & GX_NULLDIR) == 0) we
1192 need to remove all the NULL elements from the beginning
1194 /* If we have a null directory name and ** as the filename,
1195 we have just searched for everything from the current
1196 directory on down. Break now (shouldbreak = 1) to avoid
1197 duplicate entries in the final result. */
1198 #define NULL_PLACEHOLDER(x) ((x) && *(x) && **(x) == 0)
1199 if ((dflags & GX_NULLDIR) && (flags & GX_NULLDIR) == 0 &&
1200 NULL_PLACEHOLDER (temp_results))
1201 #undef NULL_PLACEHOLDER
1204 for (n = 0; temp_results[n] && *temp_results[n] == 0; n++)
1208 temp_results[i - n] = temp_results[i];
1209 while (temp_results[i++] != 0);
1210 array = temp_results;
1214 array = temp_results;
1217 array = glob_dir_to_array (directories[i], temp_results, flags);
1219 while (array[l] != NULL)
1223 (char **)realloc (result, (result_size + l) * sizeof (char *));
1228 for (l = 0; array[l] != NULL; ++l)
1229 result[result_size++ - 1] = array[l];
1231 result[result_size - 1] = NULL;
1233 /* Note that the elements of ARRAY are not freed. */
1234 if (array != temp_results)
1235 free ((char *) array);
1236 else if ((dflags & GX_ALLDIRS) && filename[0] == '*' && filename[1] == '*' && filename[2] == '\0')
1237 free (temp_results); /* expanding ** case above */
1243 /* Free the directories. */
1244 for (i = 0; directories[i]; i++)
1245 free (directories[i]);
1247 free ((char *) directories);
1253 /* If there is only a directory name, return it. */
1254 if (*filename == '\0')
1256 result = (char **) realloc ((char *) result, 2 * sizeof (char *));
1259 /* Handle GX_MARKDIRS here. */
1260 result[0] = (char *) malloc (directory_len + 1);
1261 if (result[0] == NULL)
1263 bcopy (directory_name, result[0], directory_len + 1);
1265 free (directory_name);
1271 char **temp_results;
1273 /* There are no unquoted globbing characters in DIRECTORY_NAME.
1274 Dequote it before we try to open the directory since there may
1275 be quoted globbing characters which should be treated verbatim. */
1276 if (directory_len > 0)
1277 dequote_pathname (directory_name);
1279 /* We allocated a small array called RESULT, which we won't be using.
1280 Free that memory now. */
1283 /* Just return what glob_vector () returns appended to the
1285 /* If flags & GX_ALLDIRS, we're called recursively */
1286 dflags = flags & ~GX_MARKDIRS;
1287 if (directory_len == 0)
1288 dflags |= GX_NULLDIR;
1289 if ((flags & GX_GLOBSTAR) && filename[0] == '*' && filename[1] == '*' && filename[2] == '\0')
1291 dflags |= GX_ALLDIRS|GX_ADDCURDIR;
1293 /* If we want all directories (dflags & GX_ALLDIRS) and we're not
1294 being called recursively as something like `echo [star][star]/[star].o'
1295 ((flags & GX_ALLDIRS) == 0), we want to prevent glob_vector from
1296 adding a null directory name to the front of the temp_results
1297 array. We turn off ADDCURDIR if not called recursively and
1300 if (directory_len == 0 && (flags & GX_ALLDIRS) == 0)
1301 dflags &= ~GX_ADDCURDIR;
1303 temp_results = glob_vector (filename,
1304 (directory_len == 0 ? "." : directory_name),
1307 if (temp_results == NULL || temp_results == (char **)&glob_error_return)
1310 free (directory_name);
1311 QUIT; /* XXX - shell */
1312 run_pending_traps ();
1313 return (temp_results);
1316 result = glob_dir_to_array ((dflags & GX_ALLDIRS) ? "" : directory_name, temp_results, flags);
1319 free (directory_name);
1323 /* We get to memory_error if the program has run out of memory, or
1324 if this is the shell, and we have been interrupted. */
1328 register unsigned int i;
1329 for (i = 0; result[i] != NULL; ++i)
1331 free ((char *) result);
1334 if (free_dirname && directory_name)
1335 free (directory_name);
1338 run_pending_traps ();
1351 for (i = 1; i < argc; ++i)
1353 char **value = glob_filename (argv[i], 0);
1355 puts ("Out of memory.");
1356 else if (value == &glob_error_return)
1359 for (i = 0; value[i] != NULL; i++)