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++)
added
removed
lib/glob/glob.c
