Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
branch: master
Fetching contributors…

Cannot retrieve contributors at this time

3606 lines (3313 sloc) 90.204 kb
/*
* glob.c - filename generation
*
* This file is part of zsh, the Z shell.
*
* Copyright (c) 1992-1997 Paul Falstad
* All rights reserved.
*
* Permission is hereby granted, without written agreement and without
* license or royalty fees, to use, copy, modify, and distribute this
* software and to distribute modified versions of this software for any
* purpose, provided that the above copyright notice and the following
* two paragraphs appear in all copies of this software.
*
* In no event shall Paul Falstad or the Zsh Development Group be liable
* to any party for direct, indirect, special, incidental, or consequential
* damages arising out of the use of this software and its documentation,
* even if Paul Falstad and the Zsh Development Group have been advised of
* the possibility of such damage.
*
* Paul Falstad and the Zsh Development Group specifically disclaim any
* warranties, including, but not limited to, the implied warranties of
* merchantability and fitness for a particular purpose. The software
* provided hereunder is on an "as is" basis, and Paul Falstad and the
* Zsh Development Group have no obligation to provide maintenance,
* support, updates, enhancements, or modifications.
*
*/
#include "zsh.mdh"
#include "glob.pro"
#if defined(OFF_T_IS_64_BIT) && defined(__GNUC__)
# define ALIGN64 __attribute__((aligned(8)))
#else
# define ALIGN64
#endif
/* flag for CSHNULLGLOB */
typedef struct gmatch *Gmatch;
struct gmatch {
char *name;
/*
* Array of sort strings: one for each GS_EXEC sort type in
* the glob qualifiers.
*/
char **sortstrs;
off_t size ALIGN64;
long atime;
long mtime;
long ctime;
long links;
off_t _size ALIGN64;
long _atime;
long _mtime;
long _ctime;
long _links;
#ifdef GET_ST_ATIME_NSEC
long ansec;
long _ansec;
#endif
#ifdef GET_ST_MTIME_NSEC
long mnsec;
long _mnsec;
#endif
#ifdef GET_ST_CTIME_NSEC
long cnsec;
long _cnsec;
#endif
};
#define GS_NAME 1
#define GS_DEPTH 2
#define GS_EXEC 4
#define GS_SHIFT_BASE 8
#define GS_SIZE (GS_SHIFT_BASE)
#define GS_ATIME (GS_SHIFT_BASE << 1)
#define GS_MTIME (GS_SHIFT_BASE << 2)
#define GS_CTIME (GS_SHIFT_BASE << 3)
#define GS_LINKS (GS_SHIFT_BASE << 4)
#define GS_SHIFT 5
#define GS__SIZE (GS_SIZE << GS_SHIFT)
#define GS__ATIME (GS_ATIME << GS_SHIFT)
#define GS__MTIME (GS_MTIME << GS_SHIFT)
#define GS__CTIME (GS_CTIME << GS_SHIFT)
#define GS__LINKS (GS_LINKS << GS_SHIFT)
#define GS_DESC (GS_SHIFT_BASE << (2*GS_SHIFT))
#define GS_NONE (GS_SHIFT_BASE << (2*GS_SHIFT+1))
#define GS_NORMAL (GS_SIZE | GS_ATIME | GS_MTIME | GS_CTIME | GS_LINKS)
#define GS_LINKED (GS_NORMAL << GS_SHIFT)
/**/
int badcshglob;
/**/
int pathpos; /* position in pathbuf (needed by pattern code) */
/**/
char *pathbuf; /* pathname buffer (needed by pattern code) */
typedef struct stat *Statptr; /* This makes the Ultrix compiler happy. Go figure. */
/* modifier for unit conversions */
#define TT_DAYS 0
#define TT_HOURS 1
#define TT_MINS 2
#define TT_WEEKS 3
#define TT_MONTHS 4
#define TT_SECONDS 5
#define TT_BYTES 0
#define TT_POSIX_BLOCKS 1
#define TT_KILOBYTES 2
#define TT_MEGABYTES 3
typedef int (*TestMatchFunc) _((char *, struct stat *, off_t, char *));
struct qual {
struct qual *next; /* Next qualifier, must match */
struct qual *or; /* Alternative set of qualifiers to match */
TestMatchFunc func; /* Function to call to test match */
off_t data ALIGN64; /* Argument passed to function */
int sense; /* Whether asserting or negating */
int amc; /* Flag for which time to test (a, m, c) */
int range; /* Whether to test <, > or = (as per signum) */
int units; /* Multiplier for time or size, respectively */
char *sdata; /* currently only: expression to eval */
};
/* Prefix, suffix for doing zle trickery */
/**/
mod_export char *glob_pre, *glob_suf;
/* Element of a glob sort */
struct globsort {
/* Sort type */
int tp;
/* Sort code to eval, if type is GS_EXEC */
char *exec;
};
/* Maximum entries in sort array */
#define MAX_SORTS (12)
/* struct to easily save/restore current state */
struct globdata {
int gd_pathpos;
char *gd_pathbuf;
int gd_matchsz; /* size of matchbuf */
int gd_matchct; /* number of matches found */
int gd_pathbufsz; /* size of pathbuf */
int gd_pathbufcwd; /* where did we chdir()'ed */
Gmatch gd_matchbuf; /* array of matches */
Gmatch gd_matchptr; /* &matchbuf[matchct] */
char *gd_colonmod; /* colon modifiers in qualifier list */
/* Qualifiers pertaining to current pattern */
struct qual *gd_quals;
/* Other state values for current pattern */
int gd_qualct, gd_qualorct;
int gd_range, gd_amc, gd_units;
int gd_gf_nullglob, gd_gf_markdirs, gd_gf_noglobdots, gd_gf_listtypes;
int gd_gf_numsort;
int gd_gf_follow, gd_gf_sorts, gd_gf_nsorts;
struct globsort gd_gf_sortlist[MAX_SORTS];
LinkList gd_gf_pre_words;
char *gd_glob_pre, *gd_glob_suf;
};
/* The variable with the current globbing state and convenience macros */
static struct globdata curglobdata;
#define matchsz (curglobdata.gd_matchsz)
#define matchct (curglobdata.gd_matchct)
#define pathbufsz (curglobdata.gd_pathbufsz)
#define pathbufcwd (curglobdata.gd_pathbufcwd)
#define matchbuf (curglobdata.gd_matchbuf)
#define matchptr (curglobdata.gd_matchptr)
#define colonmod (curglobdata.gd_colonmod)
#define quals (curglobdata.gd_quals)
#define qualct (curglobdata.gd_qualct)
#define qualorct (curglobdata.gd_qualorct)
#define g_range (curglobdata.gd_range)
#define g_amc (curglobdata.gd_amc)
#define g_units (curglobdata.gd_units)
#define gf_nullglob (curglobdata.gd_gf_nullglob)
#define gf_markdirs (curglobdata.gd_gf_markdirs)
#define gf_noglobdots (curglobdata.gd_gf_noglobdots)
#define gf_listtypes (curglobdata.gd_gf_listtypes)
#define gf_numsort (curglobdata.gd_gf_numsort)
#define gf_follow (curglobdata.gd_gf_follow)
#define gf_sorts (curglobdata.gd_gf_sorts)
#define gf_nsorts (curglobdata.gd_gf_nsorts)
#define gf_sortlist (curglobdata.gd_gf_sortlist)
#define gf_pre_words (curglobdata.gd_gf_pre_words)
/* and macros for save/restore */
#define save_globstate(N) \
do { \
memcpy(&(N), &curglobdata, sizeof(struct globdata)); \
(N).gd_pathpos = pathpos; \
(N).gd_pathbuf = pathbuf; \
(N).gd_glob_pre = glob_pre; \
(N).gd_glob_suf = glob_suf; \
pathbuf = NULL; \
} while (0)
#define restore_globstate(N) \
do { \
zfree(pathbuf, pathbufsz); \
memcpy(&curglobdata, &(N), sizeof(struct globdata)); \
pathpos = (N).gd_pathpos; \
pathbuf = (N).gd_pathbuf; \
glob_pre = (N).gd_glob_pre; \
glob_suf = (N).gd_glob_suf; \
} while (0)
/* pathname component in filename patterns */
struct complist {
Complist next;
Patprog pat;
int closure; /* 1 if this is a (foo/)# */
int follow; /* 1 to go thru symlinks */
};
/* Add a component to pathbuf: This keeps track of how *
* far we are into a file name, since each path component *
* must be matched separately. */
/**/
static void
addpath(char *s, int l)
{
DPUTS(!pathbuf, "BUG: pathbuf not initialised");
while (pathpos + l + 1 >= pathbufsz)
pathbuf = realloc(pathbuf, pathbufsz *= 2);
while (l--)
pathbuf[pathpos++] = *s++;
pathbuf[pathpos++] = '/';
pathbuf[pathpos] = '\0';
}
/* stat the filename s appended to pathbuf. l should be true for lstat, *
* false for stat. If st is NULL, the file is only checked for existance. *
* s == "" is treated as s == ".". This is necessary since on most systems *
* foo/ can be used to reference a non-directory foo. Returns nonzero if *
* the file does not exists. */
/**/
static int
statfullpath(const char *s, struct stat *st, int l)
{
char buf[PATH_MAX];
DPUTS(strlen(s) + !*s + pathpos - pathbufcwd >= PATH_MAX,
"BUG: statfullpath(): pathname too long");
strcpy(buf, pathbuf + pathbufcwd);
strcpy(buf + pathpos - pathbufcwd, s);
if (!*s && *buf) {
/*
* Don't add the '.' if the path so far is empty, since
* then we get bogus empty strings inserted as files.
*/
buf[pathpos - pathbufcwd] = '.';
buf[pathpos - pathbufcwd + 1] = '\0';
l = 0;
}
unmetafy(buf, NULL);
if (!st) {
char lbuf[1];
return access(buf, F_OK) && (!l || readlink(buf, lbuf, 1) < 0);
}
return l ? lstat(buf, st) : stat(buf, st);
}
/* This may be set by qualifier functions to an array of strings to insert
* into the list instead of the original string. */
char **inserts;
/* add a match to the list */
/**/
static void
insert(char *s, int checked)
{
struct stat buf, buf2, *bp;
char *news = s;
int statted = 0;
queue_signals();
inserts = NULL;
if (gf_listtypes || gf_markdirs) {
/* Add the type marker to the end of the filename */
mode_t mode;
checked = statted = 1;
if (statfullpath(s, &buf, 1)) {
unqueue_signals();
return;
}
mode = buf.st_mode;
if (gf_follow) {
if (!S_ISLNK(mode) || statfullpath(s, &buf2, 0))
memcpy(&buf2, &buf, sizeof(buf));
statted |= 2;
mode = buf2.st_mode;
}
if (gf_listtypes || S_ISDIR(mode)) {
int ll = strlen(s);
news = (char *) hcalloc(ll + 2);
strcpy(news, s);
news[ll] = file_type(mode);
news[ll + 1] = '\0';
}
}
if (qualct || qualorct) {
/* Go through the qualifiers, rejecting the file if appropriate */
struct qual *qo, *qn;
if (!statted && statfullpath(s, &buf, 1)) {
unqueue_signals();
return;
}
news = dyncat(pathbuf, news);
statted = 1;
qo = quals;
for (qn = qo; qn && qn->func;) {
g_range = qn->range;
g_amc = qn->amc;
g_units = qn->units;
if ((qn->sense & 2) && !(statted & 2)) {
/* If (sense & 2), we're following links */
if (!S_ISLNK(buf.st_mode) || statfullpath(s, &buf2, 0))
memcpy(&buf2, &buf, sizeof(buf));
statted |= 2;
}
bp = (qn->sense & 2) ? &buf2 : &buf;
/* Reject the file if the function returned zero *
* and the sense was positive (sense&1 == 0), or *
* vice versa. */
if ((!((qn->func) (news, bp, qn->data, qn->sdata))
^ qn->sense) & 1) {
/* Try next alternative, or return if there are no more */
if (!(qo = qo->or)) {
unqueue_signals();
return;
}
qn = qo;
continue;
}
qn = qn->next;
}
} else if (!checked) {
if (statfullpath(s, NULL, 1)) {
unqueue_signals();
return;
}
statted = 1;
news = dyncat(pathbuf, news);
} else
news = dyncat(pathbuf, news);
while (!inserts || (news = dupstring(*inserts++))) {
if (colonmod) {
/* Handle the remainder of the qualifier: e.g. (:r:s/foo/bar/). */
s = colonmod;
modify(&news, &s);
}
if (!statted && (gf_sorts & GS_NORMAL)) {
statfullpath(s, &buf, 1);
statted = 1;
}
if (!(statted & 2) && (gf_sorts & GS_LINKED)) {
if (statted) {
if (!S_ISLNK(buf.st_mode) || statfullpath(s, &buf2, 0))
memcpy(&buf2, &buf, sizeof(buf));
} else if (statfullpath(s, &buf2, 0))
statfullpath(s, &buf2, 1);
statted |= 2;
}
matchptr->name = news;
if (statted & 1) {
matchptr->size = buf.st_size;
matchptr->atime = buf.st_atime;
matchptr->mtime = buf.st_mtime;
matchptr->ctime = buf.st_ctime;
matchptr->links = buf.st_nlink;
#ifdef GET_ST_ATIME_NSEC
matchptr->ansec = GET_ST_ATIME_NSEC(buf);
#endif
#ifdef GET_ST_MTIME_NSEC
matchptr->mnsec = GET_ST_MTIME_NSEC(buf);
#endif
#ifdef GET_ST_CTIME_NSEC
matchptr->cnsec = GET_ST_CTIME_NSEC(buf);
#endif
}
if (statted & 2) {
matchptr->_size = buf2.st_size;
matchptr->_atime = buf2.st_atime;
matchptr->_mtime = buf2.st_mtime;
matchptr->_ctime = buf2.st_ctime;
matchptr->_links = buf2.st_nlink;
#ifdef GET_ST_ATIME_NSEC
matchptr->_ansec = GET_ST_ATIME_NSEC(buf2);
#endif
#ifdef GET_ST_MTIME_NSEC
matchptr->_mnsec = GET_ST_MTIME_NSEC(buf2);
#endif
#ifdef GET_ST_CTIME_NSEC
matchptr->_cnsec = GET_ST_CTIME_NSEC(buf2);
#endif
}
matchptr++;
if (++matchct == matchsz) {
matchbuf = (Gmatch )realloc((char *)matchbuf,
sizeof(struct gmatch) * (matchsz *= 2));
matchptr = matchbuf + matchct;
}
if (!inserts)
break;
}
unqueue_signals();
}
/* Check to see if str is eligible for filename generation. */
/**/
mod_export int
haswilds(char *str)
{
/* `[' and `]' are legal even if bad patterns are usually not. */
if ((*str == Inbrack || *str == Outbrack) && !str[1])
return 0;
/* If % is immediately followed by ?, then that ? is *
* not treated as a wildcard. This is so you don't have *
* to escape job references such as %?foo. */
if (str[0] == '%' && str[1] == Quest)
str[1] = '?';
for (; *str; str++) {
switch (*str) {
case Inpar:
case Bar:
case Star:
case Inbrack:
case Inang:
case Quest:
return 1;
case Pound:
case Hat:
if (isset(EXTENDEDGLOB))
return 1;
break;
}
}
return 0;
}
/* Do the globbing: scanner is called recursively *
* with successive bits of the path until we've *
* tried all of it. */
/**/
static void
scanner(Complist q)
{
Patprog p;
int closure;
int pbcwdsav = pathbufcwd;
int errssofar = errsfound;
struct dirsav ds;
init_dirsav(&ds);
if (!q)
return;
if ((closure = q->closure)) {
/* (foo/)# - match zero or more dirs */
if (q->closure == 2) /* (foo/)## - match one or more dirs */
q->closure = 1;
else
scanner(q->next);
}
p = q->pat;
/* Now the actual matching for the current path section. */
if (p->flags & PAT_PURES) {
/*
* It's a straight string to the end of the path section.
*/
char *str = (char *)p + p->startoff;
int l = p->patmlen;
if (l + !l + pathpos - pathbufcwd >= PATH_MAX) {
int err;
if (l >= PATH_MAX)
return;
err = lchdir(pathbuf + pathbufcwd, &ds, 0);
if (err == -1)
return;
if (err) {
zerr("current directory lost during glob");
return;
}
pathbufcwd = pathpos;
}
if (q->next) {
/* Not the last path section. Just add it to the path. */
int oppos = pathpos;
if (!errflag) {
int add = 1;
if (q->closure && *pathbuf) {
if (!strcmp(str, "."))
add = 0;
else if (!strcmp(str, "..")) {
struct stat sc, sr;
add = (stat("/", &sr) || stat(pathbuf, &sc) ||
sr.st_ino != sc.st_ino ||
sr.st_dev != sc.st_dev);
}
}
if (add) {
addpath(str, l);
if (!closure || !statfullpath("", NULL, 1))
scanner((q->closure) ? q : q->next);
pathbuf[pathpos = oppos] = '\0';
}
}
} else {
if (str[l])
str = dupstrpfx(str, l);
insert(str, 0);
}
} else {
/* Do pattern matching on current path section. */
char *fn = pathbuf[pathbufcwd] ? unmeta(pathbuf + pathbufcwd) : ".";
int dirs = !!q->next;
DIR *lock = opendir(fn);
char *subdirs = NULL;
int subdirlen = 0;
if (lock == NULL)
return;
while ((fn = zreaddir(lock, 1)) && !errflag) {
/* prefix and suffix are zle trickery */
if (!dirs && !colonmod &&
((glob_pre && !strpfx(glob_pre, fn))
|| (glob_suf && !strsfx(glob_suf, fn))))
continue;
errsfound = errssofar;
if (pattry(p, fn)) {
/* if this name matchs the pattern... */
if (pbcwdsav == pathbufcwd &&
strlen(fn) + pathpos - pathbufcwd >= PATH_MAX) {
int err;
DPUTS(pathpos == pathbufcwd,
"BUG: filename longer than PATH_MAX");
err = lchdir(pathbuf + pathbufcwd, &ds, 0);
if (err == -1)
break;
if (err) {
zerr("current directory lost during glob");
break;
}
pathbufcwd = pathpos;
}
if (dirs) {
int l;
/*
* If not the last component in the path:
*
* If we made an approximation in the new path segment,
* then it is possible we made too many errors. For
* example, (ab)#(cb)# will match the directory abcb
* with one error if allowed to, even though it can
* match with none. This will stop later parts of the
* path matching, so we need to check by reducing the
* maximum number of errors and seeing if the directory
* still matches. Luckily, this is not a terribly
* common case, since complex patterns typically occur
* in the last part of the path which is not affected
* by this problem.
*/
if (errsfound > errssofar) {
forceerrs = errsfound - 1;
while (forceerrs >= errssofar) {
errsfound = errssofar;
if (!pattry(p, fn))
break;
forceerrs = errsfound - 1;
}
errsfound = forceerrs + 1;
forceerrs = -1;
}
if (closure) {
/* if matching multiple directories */
struct stat buf;
if (statfullpath(fn, &buf, !q->follow)) {
if (errno != ENOENT && errno != EINTR &&
errno != ENOTDIR && !errflag) {
zwarn("%e: %s", errno, fn);
}
continue;
}
if (!S_ISDIR(buf.st_mode))
continue;
}
l = strlen(fn) + 1;
subdirs = hrealloc(subdirs, subdirlen, subdirlen + l
+ sizeof(int));
strcpy(subdirs + subdirlen, fn);
subdirlen += l;
/* store the count of errors made so far, too */
memcpy(subdirs + subdirlen, (char *)&errsfound,
sizeof(int));
subdirlen += sizeof(int);
} else
/* if the last filename component, just add it */
insert(fn, 1);
}
}
closedir(lock);
if (subdirs) {
int oppos = pathpos;
for (fn = subdirs; fn < subdirs+subdirlen; ) {
int l = strlen(fn);
addpath(fn, l);
fn += l + 1;
memcpy((char *)&errsfound, fn, sizeof(int));
fn += sizeof(int);
scanner((q->closure) ? q : q->next); /* scan next level */
pathbuf[pathpos = oppos] = '\0';
}
hrealloc(subdirs, subdirlen, 0);
}
}
if (pbcwdsav < pathbufcwd) {
if (restoredir(&ds))
zerr("current directory lost during glob");
zsfree(ds.dirname);
if (ds.dirfd >= 0)
close(ds.dirfd);
pathbufcwd = pbcwdsav;
}
}
/* This function tokenizes a zsh glob pattern */
/**/
static Complist
parsecomplist(char *instr)
{
Patprog p1;
Complist l1;
char *str;
int compflags = gf_noglobdots ? (PAT_FILE|PAT_NOGLD) : PAT_FILE;
if (instr[0] == Star && instr[1] == Star &&
(instr[2] == '/' || (instr[2] == Star && instr[3] == '/'))) {
/* Match any number of directories. */
int follow;
/* with three stars, follow symbolic links */
follow = (instr[2] == Star);
instr += (3 + follow);
/* Now get the next path component if there is one. */
l1 = (Complist) zhalloc(sizeof *l1);
if ((l1->next = parsecomplist(instr)) == NULL) {
errflag = 1;
return NULL;
}
l1->pat = patcompile(NULL, compflags | PAT_ANY, NULL);
l1->closure = 1; /* ...zero or more times. */
l1->follow = follow;
return l1;
}
/* Parse repeated directories such as (dir/)# and (dir/)## */
if (*(str = instr) == Inpar && !skipparens(Inpar, Outpar, (char **)&str) &&
*str == Pound && isset(EXTENDEDGLOB) && str[-2] == '/') {
instr++;
if (!(p1 = patcompile(instr, compflags, &instr)))
return NULL;
if (instr[0] == '/' && instr[1] == Outpar && instr[2] == Pound) {
int pdflag = 0;
instr += 3;
if (*instr == Pound) {
pdflag = 1;
instr++;
}
l1 = (Complist) zhalloc(sizeof *l1);
l1->pat = p1;
l1->closure = 1 + pdflag;
l1->follow = 0;
l1->next = parsecomplist(instr);
return (l1->pat) ? l1 : NULL;
}
} else {
/* parse single path component */
if (!(p1 = patcompile(instr, compflags|PAT_FILET, &instr)))
return NULL;
/* then do the remaining path components */
if (*instr == '/' || !*instr) {
int ef = *instr == '/';
l1 = (Complist) zhalloc(sizeof *l1);
l1->pat = p1;
l1->closure = 0;
l1->next = ef ? parsecomplist(instr+1) : NULL;
return (ef && !l1->next) ? NULL : l1;
}
}
errflag = 1;
return NULL;
}
/* turn a string into a Complist struct: this has path components */
/**/
static Complist
parsepat(char *str)
{
long assert;
int ignore;
patcompstart();
/*
* Check for initial globbing flags, so that they don't form
* a bogus path component.
*/
if ((*str == Inpar && str[1] == Pound && isset(EXTENDEDGLOB)) ||
(isset(KSHGLOB) && *str == '@' && str[1] == Inpar &&
str[2] == Pound)) {
str += (*str == Inpar) ? 2 : 3;
if (!patgetglobflags(&str, &assert, &ignore))
return NULL;
}
/* Now there is no (#X) in front, we can check the path. */
if (!pathbuf)
pathbuf = zalloc(pathbufsz = PATH_MAX);
DPUTS(pathbufcwd, "BUG: glob changed directory");
if (*str == '/') { /* pattern has absolute path */
str++;
pathbuf[0] = '/';
pathbuf[pathpos = 1] = '\0';
} else /* pattern is relative to pwd */
pathbuf[pathpos = 0] = '\0';
return parsecomplist(str);
}
/* get number after qualifier */
/**/
static off_t
qgetnum(char **s)
{
off_t v = 0;
if (!idigit(**s)) {
zerr("number expected");
return 0;
}
while (idigit(**s))
v = v * 10 + *(*s)++ - '0';
return v;
}
/* get mode spec after qualifier */
/**/
static zlong
qgetmodespec(char **s)
{
zlong yes = 0, no = 0, val, mask, t;
char *p = *s, c, how, end;
if ((c = *p) == '=' || c == Equals || c == '+' || c == '-' ||
c == '?' || c == Quest || (c >= '0' && c <= '7')) {
end = 0;
c = 0;
} else {
end = (c == '<' ? '>' :
(c == '[' ? ']' :
(c == '{' ? '}' :
(c == Inang ? Outang :
(c == Inbrack ? Outbrack :
(c == Inbrace ? Outbrace : c))))));
p++;
}
do {
mask = 0;
while (((c = *p) == 'u' || c == 'g' || c == 'o' || c == 'a') && end) {
switch (c) {
case 'o': mask |= 01007; break;
case 'g': mask |= 02070; break;
case 'u': mask |= 04700; break;
case 'a': mask |= 07777; break;
}
p++;
}
how = ((c == '+' || c == '-') ? c : '=');
if (c == '+' || c == '-' || c == '=' || c == Equals)
p++;
val = 0;
if (mask) {
while ((c = *p++) != ',' && c != end) {
switch (c) {
case 'x': val |= 00111; break;
case 'w': val |= 00222; break;
case 'r': val |= 00444; break;
case 's': val |= 06000; break;
case 't': val |= 01000; break;
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
t = ((zlong) c - '0');
val |= t | (t << 3) | (t << 6);
break;
default:
zerr("invalid mode specification");
return 0;
}
}
if (how == '=' || how == '+') {
yes |= val & mask;
val = ~val;
}
if (how == '=' || how == '-')
no |= val & mask;
} else if (!(end && c == end) && c != ',' && c) {
t = 07777;
while ((c = *p) == '?' || c == Quest ||
(c >= '0' && c <= '7')) {
if (c == '?' || c == Quest) {
t = (t << 3) | 7;
val <<= 3;
} else {
t <<= 3;
val = (val << 3) | ((zlong) c - '0');
}
p++;
}
if (end && c != end && c != ',') {
zerr("invalid mode specification");
return 0;
}
if (how == '=') {
yes = (yes & ~t) | val;
no = (no & ~t) | (~val & ~t);
} else if (how == '+')
yes |= val;
else
no |= val;
} else {
zerr("invalid mode specification");
return 0;
}
} while (end && c != end);
*s = p;
return ((yes & 07777) | ((no & 07777) << 12));
}
static int
gmatchcmp(Gmatch a, Gmatch b)
{
int i;
off_t r = 0L;
struct globsort *s;
char **asortstrp = NULL, **bsortstrp = NULL;
for (i = gf_nsorts, s = gf_sortlist; i; i--, s++) {
switch (s->tp & ~GS_DESC) {
case GS_NAME:
r = zstrcmp(b->name, a->name, gf_numsort ? SORTIT_NUMERICALLY : 0);
break;
case GS_DEPTH:
{
char *aptr = a->name, *bptr = b->name;
int slasha = 0, slashb = 0;
/* Count slashes. Trailing slashes don't count. */
while (*aptr && *aptr == *bptr)
aptr++, bptr++;
if (*aptr)
for (; aptr[1]; aptr++)
if (*aptr == '/') {
slasha = 1;
break;
}
if (*bptr)
for (; bptr[1]; bptr++)
if (*bptr == '/') {
slashb = 1;
break;
}
r = slasha - slashb;
}
break;
case GS_EXEC:
if (!asortstrp) {
asortstrp = a->sortstrs;
bsortstrp = b->sortstrs;
} else {
asortstrp++;
bsortstrp++;
}
r = zstrcmp(*bsortstrp, *asortstrp,
gf_numsort ? SORTIT_NUMERICALLY : 0);
break;
case GS_SIZE:
r = b->size - a->size;
break;
case GS_ATIME:
r = a->atime - b->atime;
#ifdef GET_ST_ATIME_NSEC
if (!r)
r = a->ansec - b->ansec;
#endif
break;
case GS_MTIME:
r = a->mtime - b->mtime;
#ifdef GET_ST_MTIME_NSEC
if (!r)
r = a->mnsec - b->mnsec;
#endif
break;
case GS_CTIME:
r = a->ctime - b->ctime;
#ifdef GET_ST_CTIME_NSEC
if (!r)
r = a->cnsec - b->cnsec;
#endif
break;
case GS_LINKS:
r = b->links - a->links;
break;
case GS__SIZE:
r = b->_size - a->_size;
break;
case GS__ATIME:
r = a->_atime - b->_atime;
#ifdef GET_ST_ATIME_NSEC
if (!r)
r = a->_ansec - b->_ansec;
#endif
break;
case GS__MTIME:
r = a->_mtime - b->_mtime;
#ifdef GET_ST_MTIME_NSEC
if (!r)
r = a->_mnsec - b->_mnsec;
#endif
break;
case GS__CTIME:
r = a->_ctime - b->_ctime;
#ifdef GET_ST_CTIME_NSEC
if (!r)
r = a->_cnsec - b->_cnsec;
#endif
break;
case GS__LINKS:
r = b->_links - a->_links;
break;
}
if (r)
return (int) ((s->tp & GS_DESC) ? -r : r);
}
return 0;
}
/*
* Duplicate a list of qualifiers using the `next' linkage (not the
* `or' linkage). Return the head element and set *last (if last non-NULL)
* to point to the last element of the new list. All allocation is on the
* heap (or off the heap?)
*/
static struct qual *dup_qual_list(struct qual *orig, struct qual **lastp)
{
struct qual *qfirst = NULL, *qlast = NULL;
while (orig) {
struct qual *qnew = (struct qual *)zhalloc(sizeof(struct qual));
*qnew = *orig;
qnew->next = qnew->or = NULL;
if (!qfirst)
qfirst = qnew;
if (qlast)
qlast->next = qnew;
qlast = qnew;
orig = orig->next;
}
if (lastp)
*lastp = qlast;
return qfirst;
}
/*
* Get a glob string for execution, following e, P or + qualifiers.
* Pointer is character after the e, P or +.
*/
/**/
static char *
glob_exec_string(char **sp)
{
char sav, *tt, *sdata, *s = *sp;
int plus;
if (s[-1] == '+') {
plus = 0;
tt = itype_end(s, IIDENT, 0);
if (tt == s)
{
zerr("missing identifier after `+'");
return NULL;
}
} else {
tt = get_strarg(s, &plus);
if (!*tt)
{
zerr("missing end of string");
return NULL;
}
}
sav = *tt;
*tt = '\0';
sdata = dupstring(s + plus);
untokenize(sdata);
*tt = sav;
if (sav)
*sp = tt + plus;
else
*sp = tt;
return sdata;
}
/*
* Insert a glob match.
* If there were words to prepend given by the P glob qualifier, do so.
*/
static void
insert_glob_match(LinkList list, LinkNode next, char *data)
{
if (gf_pre_words) {
LinkNode added;
for (added = firstnode(gf_pre_words); added; incnode(added)) {
next = insertlinknode(list, next, dupstring(getdata(added)));
}
}
insertlinknode(list, next, data);
}
/* Main entry point to the globbing code for filename globbing. *
* np points to a node in the list list which will be expanded *
* into a series of nodes. */
/**/
void
zglob(LinkList list, LinkNode np, int nountok)
{
struct qual *qo, *qn, *ql;
LinkNode node = prevnode(np);
char *str; /* the pattern */
int sl; /* length of the pattern */
Complist q; /* pattern after parsing */
char *ostr = (char *)getdata(np); /* the pattern before the parser */
/* chops it up */
int first = 0, end = -1; /* index of first match to return */
/* and index+1 of the last match */
struct globdata saved; /* saved glob state */
int nobareglob = !isset(BAREGLOBQUAL);
if (unset(GLOBOPT) || !haswilds(ostr) || unset(EXECOPT)) {
if (!nountok)
untokenize(ostr);
return;
}
save_globstate(saved);
str = dupstring(ostr);
uremnode(list, np);
/* quals will hold the complete list of qualifiers (file static). */
quals = NULL;
/*
* qualct and qualorct indicate we have qualifiers in the last
* alternative, or a set of alternatives, respectively. They
* are not necessarily an accurate count, however.
*/
qualct = qualorct = 0;
/*
* colonmod is a concatenated list of all colon modifiers found in
* all sets of qualifiers.
*/
colonmod = NULL;
/* The gf_* flags are qualifiers which are applied globally. */
gf_nullglob = isset(NULLGLOB);
gf_markdirs = isset(MARKDIRS);
gf_listtypes = gf_follow = 0;
gf_noglobdots = unset(GLOBDOTS);
gf_numsort = isset(NUMERICGLOBSORT);
gf_sorts = gf_nsorts = 0;
gf_pre_words = NULL;
/* Check for qualifiers */
while (!nobareglob || isset(EXTENDEDGLOB)) {
struct qual *newquals;
char *s;
int sense, paren;
off_t data;
char *sdata, *newcolonmod;
int (*func) _((char *, Statptr, off_t, char *));
/*
* Initialise state variables for current file pattern.
* newquals is the root for the linked list of all qualifiers.
* qo is the root of the current list of alternatives.
* ql is the end of the current alternative where the `next' will go.
* qn is the current qualifier node to be added.
*
* Here is an attempt at a diagram. An `or' is added horizontally
* to the top line, a `next' at the bottom of the right hand line.
* `qn' is usually NULL unless a new `or' has just been added.
*
* quals -> x -> x -> qo
* | | |
* x x x
* | |
* x ql
*
* In fact, after each loop the complete set is in the file static
* `quals'. Then, if we have a second set of qualifiers, we merge
* the lists together. This is only tricky if one or both have an
* `or' in them; then we need to distribute over all alternatives.
*/
newquals = qo = qn = ql = NULL;
sl = strlen(str);
if (str[sl - 1] != Outpar)
break;
/* Check these are really qualifiers, not a set of *
* alternatives or exclusions. We can be more *
* lenient with an explicit (#q) than with a bare *
* set of qualifiers. */
paren = 0;
for (s = str + sl - 2; *s && (*s != Inpar || paren); s--) {
switch (*s) {
case Outpar:
paren++; /*FALLTHROUGH*/
case Bar:
nobareglob = 1;
break;
case Tilde:
if (isset(EXTENDEDGLOB))
nobareglob = 1;
break;
case Inpar:
paren--;
break;
}
}
if (*s != Inpar)
break;
if (isset(EXTENDEDGLOB) && s[1] == Pound) {
if (s[2] == 'q') {
*s = 0;
s += 2;
} else
break;
} else if (nobareglob)
break;
/* Real qualifiers found. */
nobareglob = 1;
sense = 0; /* bit 0 for match (0)/don't match (1) */
/* bit 1 for follow links (2), don't (0) */
data = 0; /* Any numerical argument required */
sdata = NULL; /* Any list argument required */
newcolonmod = NULL; /* Contains trailing colon modifiers */
str[sl-1] = 0;
*s++ = 0;
while (*s && !newcolonmod) {
func = (int (*) _((char *, Statptr, off_t, char *)))0;
if (idigit(*s)) {
/* Store numeric argument for qualifier */
func = qualflags;
data = 0;
sdata = NULL;
while (idigit(*s))
data = data * 010 + (*s++ - '0');
} else if (*s == ',') {
/* A comma separates alternative sets of qualifiers */
s++;
sense = 0;
if (qualct) {
qn = (struct qual *)hcalloc(sizeof *qn);
qo->or = qn;
qo = qn;
qualorct++;
qualct = 0;
ql = NULL;
}
} else {
switch (*s++) {
case ':':
/* Remaining arguments are history-type *
* colon substitutions, handled separately. */
newcolonmod = s - 1;
untokenize(newcolonmod);
if (colonmod) {
/* remember we're searching backwards */
colonmod = dyncat(newcolonmod, colonmod);
} else
colonmod = newcolonmod;
break;
case Hat:
case '^':
/* Toggle sense: go from positive to *
* negative match and vice versa. */
sense ^= 1;
break;
case '-':
/* Toggle matching of symbolic links */
sense ^= 2;
break;
case '@':
/* Match symbolic links */
func = qualislnk;
break;
case Equals:
case '=':
/* Match sockets */
func = qualissock;
break;
case 'p':
/* Match named pipes */
func = qualisfifo;
break;
case '/':
/* Match directories */
func = qualisdir;
break;
case '.':
/* Match regular files */
func = qualisreg;
break;
case '%':
/* Match special files: block, *
* character or any device */
if (*s == 'b')
s++, func = qualisblk;
else if (*s == 'c')
s++, func = qualischr;
else
func = qualisdev;
break;
case Star:
/* Match executable plain files */
func = qualiscom;
break;
case 'R':
/* Match world-readable files */
func = qualflags;
data = 0004;
break;
case 'W':
/* Match world-writeable files */
func = qualflags;
data = 0002;
break;
case 'X':
/* Match world-executable files */
func = qualflags;
data = 0001;
break;
case 'A':
func = qualflags;
data = 0040;
break;
case 'I':
func = qualflags;
data = 0020;
break;
case 'E':
func = qualflags;
data = 0010;
break;
case 'r':
/* Match files readable by current process */
func = qualflags;
data = 0400;
break;
case 'w':
/* Match files writeable by current process */
func = qualflags;
data = 0200;
break;
case 'x':
/* Match files executable by current process */
func = qualflags;
data = 0100;
break;
case 's':
/* Match setuid files */
func = qualflags;
data = 04000;
break;
case 'S':
/* Match setgid files */
func = qualflags;
data = 02000;
break;
case 't':
func = qualflags;
data = 01000;
break;
case 'd':
/* Match device files by device number *
* (as given by stat's st_dev element). */
func = qualdev;
data = qgetnum(&s);
break;
case 'l':
/* Match files with the given no. of hard links */
func = qualnlink;
g_amc = -1;
goto getrange;
case 'U':
/* Match files owned by effective user ID */
func = qualuid;
data = geteuid();
break;
case 'G':
/* Match files owned by effective group ID */
func = qualgid;
data = getegid();
break;
case 'u':
/* Match files owned by given user id */
func = qualuid;
/* either the actual uid... */
if (idigit(*s))
data = qgetnum(&s);
else {
/* ... or a user name */
char sav, *tt;
int arglen;
/* Find matching delimiters */
tt = get_strarg(s, &arglen);
if (!*tt) {
zerr("missing end of name");
data = 0;
} else {
#ifdef USE_GETPWNAM
struct passwd *pw;
sav = *tt;
*tt = '\0';
if ((pw = getpwnam(s + arglen)))
data = pw->pw_uid;
else {
zerr("unknown user");
data = 0;
}
*tt = sav;
#else /* !USE_GETPWNAM */
sav = *tt;
zerr("unknown user");
data = 0;
#endif /* !USE_GETPWNAM */
if (sav)
s = tt + arglen;
else
s = tt;
}
}
break;
case 'g':
/* Given gid or group id... works like `u' */
func = qualgid;
/* either the actual gid... */
if (idigit(*s))
data = qgetnum(&s);
else {
/* ...or a delimited group name. */
char sav, *tt;
int arglen;
tt = get_strarg(s, &arglen);
if (!*tt) {
zerr("missing end of name");
data = 0;
} else {
#ifdef USE_GETGRNAM
struct group *gr;
sav = *tt;
*tt = '\0';
if ((gr = getgrnam(s + arglen)))
data = gr->gr_gid;
else {
zerr("unknown group");
data = 0;
}
*tt = sav;
#else /* !USE_GETGRNAM */
sav = *tt;
zerr("unknown group");
data = 0;
#endif /* !USE_GETGRNAM */
if (sav)
s = tt + arglen;
else
s = tt;
}
}
break;
case 'f':
/* Match modes with chmod-spec. */
func = qualmodeflags;
data = qgetmodespec(&s);
break;
case 'F':
func = qualnonemptydir;
break;
case 'M':
/* Mark directories with a / */
if ((gf_markdirs = !(sense & 1)))
gf_follow = sense & 2;
break;
case 'T':
/* Mark types in a `ls -F' type fashion */
if ((gf_listtypes = !(sense & 1)))
gf_follow = sense & 2;
break;
case 'N':
/* Nullglob: remove unmatched patterns. */
gf_nullglob = !(sense & 1);
break;
case 'D':
/* Glob dots: match leading dots implicitly */
gf_noglobdots = sense & 1;
break;
case 'n':
/* Numeric glob sort */
gf_numsort = !(sense & 1);
break;
case 'a':
/* Access time in given range */
g_amc = 0;
func = qualtime;
goto getrange;
case 'm':
/* Modification time in given range */
g_amc = 1;
func = qualtime;
goto getrange;
case 'c':
/* Inode creation time in given range */
g_amc = 2;
func = qualtime;
goto getrange;
case 'L':
/* File size (Length) in given range */
func = qualsize;
g_amc = -1;
/* Get size multiplier */
g_units = TT_BYTES;
if (*s == 'p' || *s == 'P')
g_units = TT_POSIX_BLOCKS, ++s;
else if (*s == 'k' || *s == 'K')
g_units = TT_KILOBYTES, ++s;
else if (*s == 'm' || *s == 'M')
g_units = TT_MEGABYTES, ++s;
getrange:
/* Get time multiplier */
if (g_amc >= 0) {
g_units = TT_DAYS;
if (*s == 'h')
g_units = TT_HOURS, ++s;
else if (*s == 'm')
g_units = TT_MINS, ++s;
else if (*s == 'w')
g_units = TT_WEEKS, ++s;
else if (*s == 'M')
g_units = TT_MONTHS, ++s;
else if (*s == 's')
g_units = TT_SECONDS, ++s;
else if (*s == 'd')
++s;
}
/* See if it's greater than, equal to, or less than */
if ((g_range = *s == '+' ? 1 : *s == '-' ? -1 : 0))
++s;
data = qgetnum(&s);
break;
case 'o':
case 'O':
{
int t;
char *send;
if (gf_nsorts == MAX_SORTS) {
zerr("too many glob sort specifiers");
restore_globstate(saved);
return;
}
/* usually just one character */
send = s+1;
switch (*s) {
case 'n': t = GS_NAME; break;
case 'L': t = GS_SIZE; break;
case 'l': t = GS_LINKS; break;
case 'a': t = GS_ATIME; break;
case 'm': t = GS_MTIME; break;
case 'c': t = GS_CTIME; break;
case 'd': t = GS_DEPTH; break;
case 'N': t = GS_NONE; break;
case 'e':
case '+':
{
t = GS_EXEC;
if ((gf_sortlist[gf_nsorts].exec =
glob_exec_string(&send)) == NULL)
{
restore_globstate(saved);
return;
}
break;
}
default:
zerr("unknown sort specifier");
restore_globstate(saved);
return;
}
if (t != GS_EXEC) {
if ((sense & 2) && !(t & (GS_NAME|GS_DEPTH)))
t <<= GS_SHIFT; /* HERE: GS_EXEC? */
if (gf_sorts & t) {
zerr("doubled sort specifier");
restore_globstate(saved);
return;
}
}
gf_sorts |= t;
gf_sortlist[gf_nsorts++].tp = t |
(((sense & 1) ^ (s[-1] == 'O')) ? GS_DESC : 0);
s = send;
break;
}
case '+':
case 'e':
{
char *tt;
tt = glob_exec_string(&s);
if (tt == NULL) {
data = 0;
} else {
func = qualsheval;
sdata = tt;
}
break;
}
case '[':
case Inbrack:
{
char *os = --s;
struct value v;
v.isarr = SCANPM_WANTVALS;
v.pm = NULL;
v.end = -1;
v.flags = 0;
if (getindex(&s, &v, 0) || s == os) {
zerr("invalid subscript");
restore_globstate(saved);
return;
}
first = v.start;
end = v.end;
break;
}
case 'P':
{
char *tt;
tt = glob_exec_string(&s);
if (tt != NULL)
{
if (!gf_pre_words)
gf_pre_words = newlinklist();
addlinknode(gf_pre_words, tt);
}
break;
}
default:
zerr("unknown file attribute");
restore_globstate(saved);
return;
}
}
if (func) {
/* Requested test is performed by function func */
if (!qn)
qn = (struct qual *)hcalloc(sizeof *qn);
if (ql)
ql->next = qn;
ql = qn;
if (!newquals)
newquals = qo = qn;
qn->func = func;
qn->sense = sense;
qn->data = data;
qn->sdata = sdata;
qn->range = g_range;
qn->units = g_units;
qn->amc = g_amc;
qn = NULL;
qualct++;
}
if (errflag) {
restore_globstate(saved);
return;
}
}
if (quals && newquals) {
/* Merge previous group of qualifiers with new set. */
if (quals->or || newquals->or) {
/* The hard case. */
struct qual *qorhead = NULL, *qortail = NULL;
/*
* Distribute in the most trivial way, by creating
* all possible combinations of the two sets and chaining
* these into one long set of alternatives given
* by qorhead and qortail.
*/
for (qn = newquals; qn; qn = qn->or) {
for (qo = quals; qo; qo = qo->or) {
struct qual *qfirst, *qlast;
int islast = !qn->or && !qo->or;
/* Generate first set of qualifiers... */
if (islast) {
/* Last time round: don't bother copying. */
qfirst = qn;
for (qlast = qfirst; qlast->next;
qlast = qlast->next)
;
} else
qfirst = dup_qual_list(qn, &qlast);
/* ... link into new `or' chain ... */
if (!qorhead)
qorhead = qfirst;
if (qortail)
qortail->or = qfirst;
qortail = qfirst;
/* ... and concatenate second set. */
qlast->next = islast ? qo : dup_qual_list(qo, NULL);
}
}
quals = qorhead;
} else {
/*
* Easy: we can just chain the qualifiers together.
* This is an optimisation; the code above will work, too.
* We retain the original left to right ordering --- remember
* we are searching for sets of qualifiers from the right.
*/
qn = newquals;
for ( ; newquals->next; newquals = newquals->next)
;
newquals->next = quals;
quals = qn;
}
} else if (newquals)
quals = newquals;
}
q = parsepat(str);
if (!q || errflag) { /* if parsing failed */
restore_globstate(saved);
if (unset(BADPATTERN)) {
if (!nountok)
untokenize(ostr);
insertlinknode(list, node, ostr);
return;
}
errflag = 0;
zerr("bad pattern: %s", ostr);
return;
}
if (!gf_nsorts) {
gf_sortlist[0].tp = gf_sorts = GS_NAME;
gf_nsorts = 1;
}
/* Initialise receptacle for matched files, *
* expanded by insert() where necessary. */
matchptr = matchbuf = (Gmatch)zalloc((matchsz = 16) *
sizeof(struct gmatch));
matchct = 0;
pattrystart();
/* The actual processing takes place here: matches go into *
* matchbuf. This is the only top-level call to scanner(). */
scanner(q);
/* Deal with failures to match depending on options */
if (matchct)
badcshglob |= 2; /* at least one cmd. line expansion O.K. */
else if (!gf_nullglob) {
if (isset(CSHNULLGLOB)) {
badcshglob |= 1; /* at least one cmd. line expansion failed */
} else if (isset(NOMATCH)) {
zerr("no matches found: %s", ostr);
free(matchbuf);
restore_globstate(saved);
return;
} else {
/* treat as an ordinary string */
untokenize(matchptr->name = dupstring(ostr));
matchptr++;
matchct = 1;
}
}
if (!(gf_sortlist[0].tp & GS_NONE)) {
/*
* Get the strings to use for sorting by executing
* the code chunk. We allow more than one of these.
*/
int nexecs = 0;
struct globsort *sortp;
struct globsort *lastsortp = gf_sortlist + gf_nsorts;
/* First find out if there are any GS_EXECs, counting them. */
for (sortp = gf_sortlist; sortp < lastsortp; sortp++)
{
if (sortp->tp & GS_EXEC)
nexecs++;
}
if (nexecs) {
Gmatch tmpptr;
int iexec = 0;
/* Yes; allocate enough space for strings for each */
for (tmpptr = matchbuf; tmpptr < matchptr; tmpptr++)
tmpptr->sortstrs = (char **)zhalloc(nexecs*sizeof(char*));
/* Loop over each one, incrementing iexec */
for (sortp = gf_sortlist; sortp < lastsortp; sortp++)
{
/* Ignore unless this is a GS_EXEC */
if (sortp->tp & GS_EXEC) {
Eprog prog;
if ((prog = parse_string(sortp->exec, 0))) {
int ef = errflag, lv = lastval;
/* Parsed OK, execute for each name */
for (tmpptr = matchbuf; tmpptr < matchptr; tmpptr++) {
setsparam("REPLY", ztrdup(tmpptr->name));
execode(prog, 1, 0, "globsort");
if (!errflag)
tmpptr->sortstrs[iexec] =
dupstring(getsparam("REPLY"));
else
tmpptr->sortstrs[iexec] = tmpptr->name;
}
errflag = ef;
lastval = lv;
} else {
/* Failed, let's be safe */
for (tmpptr = matchbuf; tmpptr < matchptr; tmpptr++)
tmpptr->sortstrs[iexec] = tmpptr->name;
}
iexec++;
}
}
}
/* Sort arguments in to lexical (and possibly numeric) order. *
* This is reversed to facilitate insertion into the list. */
qsort((void *) & matchbuf[0], matchct, sizeof(struct gmatch),
(int (*) _((const void *, const void *)))gmatchcmp);
}
if (first < 0) {
first += matchct;
if (first < 0)
first = 0;
}
if (end < 0)
end += matchct + 1;
else if (end > matchct)
end = matchct;
if ((end -= first) > 0) {
if (gf_sortlist[0].tp & GS_NONE) {
/* Match list was never reversed, so insert back to front. */
matchptr = matchbuf + matchct - first - 1;
while (end-- > 0) {
/* insert matches in the arg list */
insert_glob_match(list, node, matchptr->name);
matchptr--;
}
} else {
matchptr = matchbuf + matchct - first - end;
while (end-- > 0) {
/* insert matches in the arg list */
insert_glob_match(list, node, matchptr->name);
matchptr++;
}
}
}
free(matchbuf);
restore_globstate(saved);
}
/* Return the trailing character for marking file types */
/**/
mod_export char
file_type(mode_t filemode)
{
if(S_ISBLK(filemode))
return '#';
else if(S_ISCHR(filemode))
return '%';
else if(S_ISDIR(filemode))
return '/';
else if(S_ISFIFO(filemode))
return '|';
else if(S_ISLNK(filemode))
return '@';
else if(S_ISREG(filemode))
return (filemode & S_IXUGO) ? '*' : ' ';
else if(S_ISSOCK(filemode))
return '=';
else
return '?';
}
/* check to see if str is eligible for brace expansion */
/**/
mod_export int
hasbraces(char *str)
{
char *lbr, *mbr, *comma;
if (isset(BRACECCL)) {
/* In this case, any properly formed brace expression *
* will match and expand to the characters in between. */
int bc, c;
for (bc = 0; (c = *str); ++str)
if (c == Inbrace) {
if (!bc && str[1] == Outbrace)
*str++ = '{', *str = '}';
else
bc++;
} else if (c == Outbrace) {
if (!bc)
*str = '}';
else if (!--bc)
return 1;
}
return 0;
}
/* Otherwise we need to look for... */
lbr = mbr = comma = NULL;
for (;;) {
switch (*str++) {
case Inbrace:
if (!lbr) {
lbr = str - 1;
if (*str == '-')
str++;
while (idigit(*str))
str++;
if (*str == '.' && str[1] == '.') {
str++; str++;
if (*str == '-')
str++;
while (idigit(*str))
str++;
if (*str == Outbrace &&
(idigit(lbr[1]) || idigit(str[-1])))
return 1;
else if (*str == '.' && str[1] == '.') {
str++; str++;
if (*str == '-')
str++;
while (idigit(*str))
str++;
if (*str == Outbrace &&
(idigit(lbr[1]) || idigit(str[-1])))
return 1;
}
}
} else {
char *s = --str;
if (skipparens(Inbrace, Outbrace, &str)) {
*lbr = *s = '{';
if (comma)
str = comma;
if (mbr && mbr < str)
str = mbr;
lbr = mbr = comma = NULL;
} else if (!mbr)
mbr = s;
}
break;
case Outbrace:
if (!lbr)
str[-1] = '}';
else if (comma)
return 1;
else {
*lbr = '{';
str[-1] = '}';
if (mbr)
str = mbr;
mbr = lbr = NULL;
}
break;
case Comma:
if (!lbr)
str[-1] = ',';
else if (!comma)
comma = str - 1;
break;
case '\0':
if (lbr)
*lbr = '{';
if (!mbr && !comma)
return 0;
if (comma)
str = comma;
if (mbr && mbr < str)
str = mbr;
lbr = mbr = comma = NULL;
break;
}
}
}
/* expand stuff like >>*.c */
/**/
int
xpandredir(struct redir *fn, LinkList redirtab)
{
char *nam;
struct redir *ff;
int ret = 0;
local_list1(fake);
/* Stick the name in a list... */
init_list1(fake, fn->name);
/* ...which undergoes all the usual shell expansions */
prefork(&fake, isset(MULTIOS) ? 0 : PREFORK_SINGLE);
/* Globbing is only done for multios. */
if (!errflag && isset(MULTIOS))
globlist(&fake, 0);
if (errflag)
return 0;
if (nonempty(&fake) && !nextnode(firstnode(&fake))) {
/* Just one match, the usual case. */
char *s = peekfirst(&fake);
fn->name = s;
untokenize(s);
if (fn->type == REDIR_MERGEIN || fn->type == REDIR_MERGEOUT) {
if (s[0] == '-' && !s[1])
fn->type = REDIR_CLOSE;
else if (s[0] == 'p' && !s[1])
fn->fd2 = -2;
else {
while (idigit(*s))
s++;
if (!*s && s > fn->name)
fn->fd2 = zstrtol(fn->name, NULL, 10);
else if (fn->type == REDIR_MERGEIN)
zerr("file number expected");
else
fn->type = REDIR_ERRWRITE;
}
}
} else if (fn->type == REDIR_MERGEIN)
zerr("file number expected");
else {
if (fn->type == REDIR_MERGEOUT)
fn->type = REDIR_ERRWRITE;
while ((nam = (char *)ugetnode(&fake))) {
/* Loop over matches, duplicating the *
* redirection for each file found. */
ff = (struct redir *) zhalloc(sizeof *ff);
*ff = *fn;
ff->name = nam;
addlinknode(redirtab, ff);
ret = 1;
}
}
return ret;
}
/* brace expansion */
/**/
mod_export void
xpandbraces(LinkList list, LinkNode *np)
{
LinkNode node = (*np), last = prevnode(node);
char *str = (char *)getdata(node), *str3 = str, *str2;
int prev, bc, comma, dotdot;
for (; *str != Inbrace; str++);
/* First, match up braces and see what we have. */
for (str2 = str, bc = comma = dotdot = 0; *str2; ++str2)
if (*str2 == Inbrace)
++bc;
else if (*str2 == Outbrace) {
if (--bc == 0)
break;
} else if (bc == 1) {
if (*str2 == Comma)
++comma; /* we have {foo,bar} */
else if (*str2 == '.' && str2[1] == '.') {
dotdot++; /* we have {num1..num2} */
++str2;
}
}
DPUTS(bc, "BUG: unmatched brace in xpandbraces()");
if (!comma && dotdot) {
/* Expand range like 0..10 numerically: comma or recursive
brace expansion take precedence. */
char *dots, *p, *dots2 = NULL;
LinkNode olast = last;
/* Get the first number of the range */
zlong rstart = zstrtol(str+1,&dots,10), rend = 0;
int err = 0, rev = 0, rincr = 1;
int wid1 = (dots - str) - 1, wid2 = (str2 - dots) - 2, wid3 = 0;
int strp = str - str3;
if (dots == str + 1 || *dots != '.' || dots[1] != '.')
err++;
else {
/* Get the last number of the range */
rend = zstrtol(dots+2,&p,10);
if (p == dots+2)
err++;
/* check for {num1..num2..incr} */
if (p != str2) {
wid2 = (p - dots) - 2;
dots2 = p;
if (dotdot == 2 && *p == '.' && p[1] == '.') {
rincr = zstrtol(p+2, &p, 10);
wid3 = p - dots2 - 2;
if (p != str2 || !rincr)
err++;
} else
err++;
}
}
if (!err) {
/* If either no. begins with a zero, pad the output with *
* zeroes. Otherwise, set min width to 0 to suppress them.
* str+1 is the first number in the range, dots+2 the last,
* and dots2+2 is the increment if that's given. */
/* TODO: sorry about this */
int minw = (str[1] == '0' || (str[1] == '-' && str[2] == '0'))
? wid1
: (dots[2] == '0' || (dots[2] == '-' && dots[3] == '0'))
? wid2
: (dots2 && (dots2[2] == '0' ||
(dots2[2] == '-' && dots2[3] == '0')))
? wid3
: 0;
if (rincr < 0) {
/* Handle negative increment */
rincr = -rincr;
rev = !rev;
}
if (rstart > rend) {
/* Handle decreasing ranges correctly. */
zlong rt = rend;
rend = rstart;
rstart = rt;
rev = !rev;
} else if (rincr > 1) {
/* when incr > 1, range is aligned to the highest number of str1,
* compensate for this so that it is aligned to the first number */
rend -= (rend - rstart) % rincr;
}
uremnode(list, node);
for (; rend >= rstart; rend -= rincr) {
/* Node added in at end, so do highest first */
p = dupstring(str3);
#if defined(ZLONG_IS_LONG_LONG) && defined(PRINTF_HAS_LLD)
sprintf(p + strp, "%0*lld", minw, rend);
#else
sprintf(p + strp, "%0*ld", minw, (long)rend);
#endif
strcat(p + strp, str2 + 1);
insertlinknode(list, last, p);
if (rev) /* decreasing: add in reverse order. */
last = nextnode(last);
}
*np = nextnode(olast);
return;
}
}
if (!comma && isset(BRACECCL)) { /* {a-mnop} */
/* Here we expand each character to a separate node, *
* but also ranges of characters like a-m. ccl is a *
* set of flags saying whether each character is present; *
* the final list is in lexical order. */
char ccl[256], *p;
unsigned char c1, c2;
unsigned int len, pl;
int lastch = -1;
uremnode(list, node);
memset(ccl, 0, sizeof(ccl) / sizeof(ccl[0]));
for (p = str + 1; p < str2;) {
if (itok(c1 = *p++))
c1 = ztokens[c1 - STOUC(Pound)];
if ((char) c1 == Meta)
c1 = 32 ^ *p++;
if (itok(c2 = *p))
c2 = ztokens[c2 - STOUC(Pound)];
if ((char) c2 == Meta)
c2 = 32 ^ p[1];
if (c1 == '-' && lastch >= 0 && p < str2 && lastch <= (int)c2) {
while (lastch < (int)c2)
ccl[lastch++] = 1;
lastch = -1;
} else
ccl[lastch = c1] = 1;
}
pl = str - str3;
len = pl + strlen(++str2) + 2;
for (p = ccl + 256; p-- > ccl;)
if (*p) {
c1 = p - ccl;
if (imeta(c1)) {
str = hcalloc(len + 1);
str[pl] = Meta;
str[pl+1] = c1 ^ 32;
strcpy(str + pl + 2, str2);
} else {
str = hcalloc(len);
str[pl] = c1;
strcpy(str + pl + 1, str2);
}
memcpy(str, str3, pl);
insertlinknode(list, last, str);
}
*np = nextnode(last);
return;
}
prev = str++ - str3;
str2++;
uremnode(list, node);
node = last;
/* Finally, normal comma expansion *
* str1{foo,bar}str2 -> str1foostr2 str1barstr2. *
* Any number of intervening commas is allowed. */
for (;;) {
char *zz, *str4;
int cnt;
for (str4 = str, cnt = 0; cnt || (*str != Comma && *str !=
Outbrace); str++) {
if (*str == Inbrace)
cnt++;
else if (*str == Outbrace)
cnt--;
DPUTS(!*str, "BUG: illegal brace expansion");
}
/* Concatenate the string before the braces (str3), the section *
* just found (str4) and the text after the braces (str2) */
zz = (char *) hcalloc(prev + (str - str4) + strlen(str2) + 1);
ztrncpy(zz, str3, prev);
strncat(zz, str4, str - str4);
strcat(zz, str2);
/* and add this text to the argument list. */
insertlinknode(list, node, zz);
incnode(node);
if (*str != Outbrace)
str++;
else
break;
}
*np = nextnode(last);
}
/* check to see if a matches b (b is not a filename pattern) */
/**/
int
matchpat(char *a, char *b)
{
Patprog p = patcompile(b, PAT_STATIC, NULL);
if (!p) {
zerr("bad pattern: %s", b);
return 0;
}
return pattry(p, a);
}
/* do the ${foo%%bar}, ${foo#bar} stuff */
/* please do not laugh at this code. */
/* Having found a match in getmatch, decide what part of string
* to return. The matched part starts b characters into string s
* and finishes e characters in: 0 <= b <= e <= strlen(s)
* (yes, empty matches should work).
* fl is a set of the SUB_* matches defined in zsh.h from SUB_MATCH onwards;
* the lower parts are ignored.
* replstr is the replacement string for a substitution
*/
/**/
static char *
get_match_ret(char *s, int b, int e, int fl, char *replstr,
LinkList repllist)
{
char buf[80], *r, *p, *rr;
int ll = 0, l = strlen(s), bl = 0, t = 0, i;
if (replstr || (fl & SUB_LIST)) {
if (fl & SUB_DOSUBST) {
replstr = dupstring(replstr);
singsub(&replstr);
untokenize(replstr);
}
if ((fl & (SUB_GLOBAL|SUB_LIST)) && repllist) {
/* We are replacing the chunk, just add this to the list */
Repldata rd = (Repldata)
((fl & SUB_LIST) ? zalloc(sizeof(*rd)) : zhalloc(sizeof(*rd)));
rd->b = b;
rd->e = e;
rd->replstr = replstr;
if (fl & SUB_LIST)
zaddlinknode(repllist, rd);
else
addlinknode(repllist, rd);
return s;
}
ll += strlen(replstr);
}
if (fl & SUB_MATCH) /* matched portion */
ll += 1 + (e - b);
if (fl & SUB_REST) /* unmatched portion */
ll += 1 + (l - (e - b));
if (fl & SUB_BIND) {
/* position of start of matched portion */
sprintf(buf, "%d ", b + 1);
ll += (bl = strlen(buf));
}
if (fl & SUB_EIND) {
/* position of end of matched portion */
sprintf(buf + bl, "%d ", e + 1);
ll += (bl = strlen(buf));
}
if (fl & SUB_LEN) {
/* length of matched portion */
sprintf(buf + bl, "%d ", e - b);
ll += (bl = strlen(buf));
}
if (bl)
buf[bl - 1] = '\0';
rr = r = (char *) hcalloc(ll);
if (fl & SUB_MATCH) {
/* copy matched portion to new buffer */
for (i = b, p = s + b; i < e; i++)
*rr++ = *p++;
t = 1;
}
if (fl & SUB_REST) {
/* Copy unmatched portion to buffer. If both portions *
* requested, put a space in between (why?) */
if (t)
*rr++ = ' ';
/* there may be unmatched bits at both beginning and end of string */
for (i = 0, p = s; i < b; i++)
*rr++ = *p++;
if (replstr)
for (p = replstr; *p; )
*rr++ = *p++;
for (i = e, p = s + e; i < l; i++)
*rr++ = *p++;
t = 1;
}
*rr = '\0';
if (bl) {
/* if there was a buffer (with a numeric result), add it; *
* if there was other stuff too, stick in a space first. */
if (t)
*rr++ = ' ';
strcpy(rr, buf);
}
return r;
}
static Patprog
compgetmatch(char *pat, int *flp, char **replstrp)
{
Patprog p;
/*
* Flags to pattern compiler: use static buffer since we only
* have one pattern at a time; we will try the must-match test ourselves,
* so tell the pattern compiler we are scanning.
*/
/* int patflags = PAT_STATIC|PAT_SCAN|PAT_NOANCH;*/
/* Unfortunately, PAT_STATIC doesn't work if we have a replstr with
* something like ${x#...} in it which will be singsub()ed below because
* that would overwrite the pattern buffer. */
int patflags = PAT_SCAN|PAT_NOANCH | (*replstrp ? 0 : PAT_STATIC);
/*
* Search is anchored to the end of the string if we want to match
* it all, or if we are matching at the end of the string and not
* using substrings.
*/
if ((*flp & SUB_ALL) || ((*flp & SUB_END) && !(*flp & SUB_SUBSTR)))
patflags &= ~PAT_NOANCH;
p = patcompile(pat, patflags, NULL);
if (!p) {
zerr("bad pattern: %s", pat);
return NULL;
}
if (*replstrp) {
if (p->patnpar || (p->globend & GF_MATCHREF)) {
/*
* Either backreferences or match references, so we
* need to re-substitute replstr each time round.
*/
*flp |= SUB_DOSUBST;
} else {
singsub(replstrp);
untokenize(*replstrp);
}
}
return p;
}
/*
* This is called from paramsubst to get the match for ${foo#bar} etc.
* fl is a set of the SUB_* flags defined in zsh.h
* *sp points to the string we have to modify. The n'th match will be
* returned in *sp. The heap is used to get memory for the result string.
* replstr is the replacement string from a ${.../orig/repl}, in
* which case pat is the original.
*
* n is now ignored unless we are looking for a substring, in
* which case the n'th match from the start is counted such that
* there is no more than one match from each position.
*/
/**/
int
getmatch(char **sp, char *pat, int fl, int n, char *replstr)
{
Patprog p;
if (!(p = compgetmatch(pat, &fl, &replstr)))
return 1;
return igetmatch(sp, p, fl, n, replstr, NULL);
}
/*
* This is the corresponding function for array variables.
* Matching is done with the same pattern on each element.
*/
/**/
void
getmatcharr(char ***ap, char *pat, int fl, int n, char *replstr)
{
char **arr = *ap, **pp;
Patprog p;
if (!(p = compgetmatch(pat, &fl, &replstr)))
return;
*ap = pp = hcalloc(sizeof(char *) * (arrlen(arr) + 1));
while ((*pp = *arr++))
if (igetmatch(pp, p, fl, n, replstr, NULL))
pp++;
}
/*
* Match against str using pattern pp; return a list of
* Repldata matches in the linked list *repllistp; this is
* in permanent storage and to be freed by freematchlist()
*/
/**/
mod_export int
getmatchlist(char *str, Patprog p, LinkList *repllistp)
{
char **sp = &str;
/*
* We don't care if we have longest or shortest match, but SUB_LONG
* is cheaper since the pattern code does that by default.
* We need SUB_GLOBAL to get all matches.
* We need SUB_SUBSTR to scan through for substrings.
* We need SUB_LIST to activate the special handling of the list
* passed in.
*/
return igetmatch(sp, p, SUB_LONG|SUB_GLOBAL|SUB_SUBSTR|SUB_LIST,
0, NULL, repllistp);
}
static void
freerepldata(void *ptr)
{
zfree(ptr, sizeof(struct repldata));
}
/**/
mod_export void
freematchlist(LinkList repllist)
{
freelinklist(repllist, freerepldata);
}
/**/
static void
set_pat_start(Patprog p, int offs)
{
/*
* If we are messing around with the test string by advancing up
* it from the start, we need to tell the pattern matcher that
* a start-of-string assertion, i.e. (#s), should fail. Hence
* we test whether the offset of the real start of string from
* the actual start, passed as offs, is zero.
*/
if (offs)
p->flags |= PAT_NOTSTART;
else
p->flags &= ~PAT_NOTSTART;
}
/**/
static void
set_pat_end(Patprog p, char null_me)
{
/*
* If we are messing around with the string by shortening it at the
* tail, we need to tell the pattern matcher that an end-of-string
* assertion, i.e. (#e), should fail. Hence we test whether
* the character null_me about to be zapped is or is not already a null.
*/
if (null_me)
p->flags |= PAT_NOTEND;
else
p->flags &= ~PAT_NOTEND;
}
/**/
#ifdef MULTIBYTE_SUPPORT
/*
* Increment *tp over character which may be multibyte.
* Return number of bytes that remain in the character after unmetafication.
*/
/**/
static int iincchar(char **tp)
{
char *t = *tp;
int mbclen = mb_metacharlenconv(t, NULL);
int umlen = 0;
while (mbclen--) {
umlen++;
if (*t++ == Meta) {
t++;
mbclen--;
}
}
*tp = t;
return umlen;
}
/**/
static int
igetmatch(char **sp, Patprog p, int fl, int n, char *replstr,
LinkList *repllistp)
{
char *s = *sp, *t, *tmatch;
/*
* Note that ioff counts (possibly multibyte) characters in the
* character set (Meta's are not included), while l counts characters in
* the metafied string.
*
* umlen is a counter for (unmetafied) byte lengths---neither characters
* nor raw byte indices; this is simply an optimisation for allocation.
* umltot is the full length of the string in this scheme.
*
* l is the raw string length, used together with any pointers into
* the string (typically t).
*/
int ioff, l = strlen(*sp), matched = 1, umltot = ztrlen(*sp);
int umlen, nmatches;
/*
* List of bits of matches to concatenate with replacement string.
* The data is a struct repldata. It is not used in cases like
* ${...//#foo/bar} even though SUB_GLOBAL is set, since the match
* is anchored. It goes on the heap.
*/
LinkList repllist = NULL;
/* perform must-match test for complex closures */
if (p->mustoff)
{
/*
* Yuk. Probably we should rewrite this whole function to
* use an unmetafied test string.
*
* Use META_HEAPDUP because we need a terminating NULL.
*/
char *muststr = metafy((char *)p + p->mustoff,
p->patmlen, META_HEAPDUP);
if (!strstr(s, muststr))
matched = 0;
}
/* in case we used the prog before... */
p->flags &= ~(PAT_NOTSTART|PAT_NOTEND);
if (fl & SUB_ALL) {
int i = matched && pattry(p, s);
*sp = get_match_ret(*sp, 0, i ? l : 0, fl, i ? replstr : 0, NULL);
if (! **sp && (((fl & SUB_MATCH) && !i) || ((fl & SUB_REST) && i)))
return 0;
return 1;
}
if (matched) {
/*
* The default behaviour is to match at the start; this
* is modified by SUB_END and SUB_SUBSTR. SUB_END matches
* at the end of the string instead of the start. SUB_SUBSTR
* without SUB_END matches substrings searching from the start;
* with SUB_END it matches substrings searching from the end.
*
* The possibilities are further modified by whether we want the
* longest (SUB_LONG) or shortest possible match.
*
* SUB_START is only used in the case where we are also
* forcing a match at the end (SUB_END with no SUB_SUBSTR,
* with or without SUB_LONG), to indicate we should match
* the entire string.
*/
switch (fl & (SUB_END|SUB_LONG|SUB_SUBSTR)) {
case 0:
case SUB_LONG:
/*
* Largest/smallest possible match at head of string.
* First get the longest match...
*/
if (pattry(p, s)) {
/* patmatchlen returns metafied length, as we need */
int mlen = patmatchlen();
if (!(fl & SUB_LONG) && !(p->flags & PAT_PURES)) {
/*
* ... now we know whether it's worth looking for the
* shortest, which we do by brute force.
*/
mb_metacharinit();
for (t = s, umlen = 0; t < s + mlen; ) {
set_pat_end(p, *t);
if (pattrylen(p, s, t - s, umlen, 0)) {
mlen = patmatchlen();
break;
}
umlen += iincchar(&t);
}
}
*sp = get_match_ret(*sp, 0, mlen, fl, replstr, NULL);
return 1;
}
break;
case SUB_END:
/*
* Smallest possible match at tail of string.
* As we can only be sure we've got wide characters right
* when going forwards, we need to match at every point
* until we fail and record the last successful match.
*
* It's important that we return the last successful match
* so that match, mbegin, mend and MATCH, MBEGIN, MEND are
* correct.
*/
mb_metacharinit();
tmatch = NULL;
for (ioff = 0, t = s, umlen = umltot; t < s + l; ioff++) {
set_pat_start(p, t-s);
if (pattrylen(p, t, s + l - t, umlen, ioff))
tmatch = t;
if (fl & SUB_START)
break;
umlen -= iincchar(&t);
}
if (tmatch) {
*sp = get_match_ret(*sp, tmatch - s, l, fl, replstr, NULL);
return 1;
}
if (!(fl & SUB_START) && pattrylen(p, s + l, 0, 0, ioff)) {
*sp = get_match_ret(*sp, l, l, fl, replstr, NULL);
return 1;
}
break;
case (SUB_END|SUB_LONG):
/* Largest possible match at tail of string: *
* move forward along string until we get a match. *
* Again there's no optimisation. */
mb_metacharinit();
for (ioff = 0, t = s, umlen = umltot; t < s + l; ioff++) {
set_pat_start(p, t-s);
if (pattrylen(p, t, s + l - t, umlen, ioff)) {
*sp = get_match_ret(*sp, t-s, l, fl, replstr, NULL);
return 1;
}
if (fl & SUB_START)
break;
umlen -= iincchar(&t);
}
if (!(fl & SUB_START) && pattrylen(p, s + l, 0, 0, ioff)) {
*sp = get_match_ret(*sp, l, l, fl, replstr, NULL);
return 1;
}
break;
case SUB_SUBSTR:
/* Smallest at start, but matching substrings. */
set_pat_start(p, l);
if (!(fl & SUB_GLOBAL) && pattry(p, s + l) && !--n) {
*sp = get_match_ret(*sp, 0, 0, fl, replstr, NULL);
return 1;
} /* fall through */
case (SUB_SUBSTR|SUB_LONG):
/* longest or smallest at start with substrings */
t = s;
if (fl & SUB_GLOBAL) {
repllist = (fl & SUB_LIST) ? znewlinklist() : newlinklist();
if (repllistp)
*repllistp = repllist;
}
ioff = 0; /* offset into string */
umlen = umltot;
mb_metacharinit();
do {
/* loop over all matches for global substitution */
matched = 0;
for (; t < s + l; ioff++) {
/* Find the longest match from this position. */
set_pat_start(p, t-s);
if (pattrylen(p, t, s + l - t, umlen, ioff)) {
char *mpos = t + patmatchlen();
if (!(fl & SUB_LONG) && !(p->flags & PAT_PURES)) {
char *ptr;
int umlen2;
/*
* If searching for the shortest match,
* start with a zero length and increase
* it until we reach the longest possible
* match, accepting the first successful
* match.
*/
for (ptr = t, umlen2 = 0; ptr < mpos;) {
set_pat_end(p, *ptr);
if (pattrylen(p, t, ptr - t, umlen2, ioff)) {
mpos = t + patmatchlen();
break;
}
umlen2 += iincchar(&ptr);
}
}
if (!--n || (n <= 0 && (fl & SUB_GLOBAL))) {
*sp = get_match_ret(*sp, t-s, mpos-s, fl,
replstr, repllist);
if (mpos == t)
mpos += mb_metacharlenconv(mpos, NULL);
}
if (!(fl & SUB_GLOBAL)) {
if (n) {
/*
* Looking for a later match: in this case,
* we can continue looking for matches from
* the next character, even if it overlaps
* with what we just found.
*/
umlen -= iincchar(&t);
continue;
} else {
return 1;
}
}
/*
* For a global match, we need to skip the stuff
* which is already marked for replacement.
*/
matched = 1;
while (t < mpos) {
ioff++;
umlen -= iincchar(&t);
}
break;
}
umlen -= iincchar(&t);
}
} while (matched);
/*
* check if we can match a blank string, if so do it
* at the start. Goodness knows if this is a good idea
* with global substitution, so it doesn't happen.
*/
set_pat_start(p, l);
if ((fl & (SUB_LONG|SUB_GLOBAL)) == SUB_LONG &&
pattry(p, s + l) && !--n) {
*sp = get_match_ret(*sp, 0, 0, fl, replstr, repllist);
return 1;
}
break;
case (SUB_END|SUB_SUBSTR):
case (SUB_END|SUB_LONG|SUB_SUBSTR):
/* Longest/shortest at end, matching substrings. */
if (!(fl & SUB_LONG)) {
set_pat_start(p, l);
if (pattrylen(p, s + l, 0, 0, umltot) && !--n) {
*sp = get_match_ret(*sp, l, l, fl, replstr, NULL);
return 1;
}
}
/*
* If multibyte characters are present we need to start from the
* beginning. This is a bit unpleasant because we can't tell in
* advance how many times it will match and from where, so if n is
* greater then 1 we will need to count the number of times it
* matched and then go through again until we reach the right
* point. (Either that or record every single match in a list,
* which isn't stupid; it involves more memory management at this
* level but less use of the pattern matcher.)
*/
nmatches = 0;
tmatch = NULL;
mb_metacharinit();
for (ioff = 0, t = s, umlen = umltot; t < s + l; ioff++) {
set_pat_start(p, t-s);
if (pattrylen(p, t, s + l - t, umlen, ioff)) {
nmatches++;
tmatch = t;
}
umlen -= iincchar(&t);
}
if (nmatches) {
char *mpos;
if (n > 1) {
/*
* We need to find the n'th last match.
*/
n = nmatches - n;
mb_metacharinit();
for (ioff = 0, t = s, umlen = umltot; t < s + l; ioff++) {
set_pat_start(p, t-s);
if (pattrylen(p, t, s + l - t, umlen, ioff) &&
!n--) {
tmatch = t;
break;
}
umlen -= iincchar(&t);
}
}
mpos = tmatch + patmatchlen();
/* Look for the shortest match if necessary */
if (!(fl & SUB_LONG) && !(p->flags & PAT_PURES)) {
for (t = tmatch, umlen = 0; t < mpos; ) {
set_pat_end(p, *t);
if (pattrylen(p, tmatch, t - tmatch, umlen, ioff)) {
mpos = tmatch + patmatchlen();
break;
}
umlen += iincchar(&t);
}
}
*sp = get_match_ret(*sp, tmatch-s, mpos-s, fl,
replstr, NULL);
return 1;
}
set_pat_start(p, l);
if ((fl & SUB_LONG) && pattrylen(p, s + l, 0, 0, umltot) && !--n) {
*sp = get_match_ret(*sp, l, l, fl, replstr, NULL);
return 1;
}
break;
}
}
if (repllist && nonempty(repllist)) {
/* Put all the bits of a global search and replace together. */
LinkNode nd;
Repldata rd;
int lleft;
char *ptr, *start;
int i;
if (!(fl & SUB_LIST)) {
lleft = 0; /* size of returned string */
i = 0; /* start of last chunk we got from *sp */
for (nd = firstnode(repllist); nd; incnode(nd)) {
rd = (Repldata) getdata(nd);
lleft += rd->b - i; /* previous chunk of *sp */
lleft += strlen(rd->replstr); /* the replaced bit */
i = rd->e; /* start of next chunk of *sp */
}
lleft += l - i; /* final chunk from *sp */
start = t = zhalloc(lleft+1);
i = 0;
for (nd = firstnode(repllist); nd; incnode(nd)) {
rd = (Repldata) getdata(nd);
memcpy(t, s + i, rd->b - i);
t += rd->b - i;
ptr = rd->replstr;
while (*ptr)
*t++ = *ptr++;
i = rd->e;
}
memcpy(t, s + i, l - i);
start[lleft] = '\0';
*sp = (char *)start;
}
return 1;
}
if (fl & SUB_LIST) /* safety: don't think this can happen */
return 0;
/* munge the whole string: no match, so no replstr */
*sp = get_match_ret(*sp, 0, 0, fl, 0, 0);
return (fl & SUB_RETFAIL) ? 0 : 1;
}
/**/
#else
/*
* Increment pointer which may be on a Meta (x is a pointer variable),
* returning the incremented value (i.e. like pre-increment).
*/
#define METAINC(x) ((x) += (*(x) == Meta) ? 2 : 1)
/**/
static int
igetmatch(char **sp, Patprog p, int fl, int n, char *replstr,
LinkList *repllistp)
{
char *s = *sp, *t;
/*
* Note that ioff and uml count characters in the character
* set (Meta's are not included), while l counts characters in the
* metafied string. umlen is a counter for (unmetafied) character
* lengths.
*/
int ioff, l = strlen(*sp), uml = ztrlen(*sp), matched = 1, umlen;
/*
* List of bits of matches to concatenate with replacement string.
* The data is a struct repldata. It is not used in cases like
* ${...//#foo/bar} even though SUB_GLOBAL is set, since the match
* is anchored. It goes on the heap.
*/
LinkList repllist = NULL;
/* perform must-match test for complex closures */
if (p->mustoff)
{
/*
* Yuk. Probably we should rewrite this whole function to
* use an unmetafied test string.
*
* Use META_HEAPDUP because we need a terminating NULL.
*/
char *muststr = metafy((char *)p + p->mustoff,
p->patmlen, META_HEAPDUP);
if (!strstr(s, muststr))
matched = 0;
}
/* in case we used the prog before... */
p->flags &= ~(PAT_NOTSTART|PAT_NOTEND);
if (fl & SUB_ALL) {
int i = matched && pattry(p, s);
*sp = get_match_ret(*sp, 0, i ? l : 0, fl, i ? replstr : 0, NULL);
if (! **sp && (((fl & SUB_MATCH) && !i) || ((fl & SUB_REST) && i)))
return 0;
return 1;
}
if (matched) {
switch (fl & (SUB_END|SUB_LONG|SUB_SUBSTR)) {
case 0:
case SUB_LONG:
/*
* Largest/smallest possible match at head of string.
* First get the longest match...
*/
if (pattry(p, s)) {
/* patmatchlen returns metafied length, as we need */
int mlen = patmatchlen();
if (!(fl & SUB_LONG) && !(p->flags & PAT_PURES)) {
/*
* ... now we know whether it's worth looking for the
* shortest, which we do by brute force.
*/
for (t = s, umlen = 0; t < s + mlen; METAINC(t), umlen++) {
set_pat_end(p, *t);
if (pattrylen(p, s, t - s, umlen, 0)) {
mlen = patmatchlen();
break;
}
}
}
*sp = get_match_ret(*sp, 0, mlen, fl, replstr, NULL);
return 1;
}
break;
case SUB_END:
/* Smallest possible match at tail of string: *
* move back down string until we get a match. *
* There's no optimization here. */
for (ioff = uml, t = s + l, umlen = 0; t >= s;
t--, ioff--, umlen++) {
if (t > s && t[-1] == Meta)
t--;
set_pat_start(p, t-s);
if (pattrylen(p, t, s + l - t, umlen, ioff)) {
*sp = get_match_ret(*sp, t - s, l, fl, replstr, NULL);
return 1;
}
if (t > s+1 && t[-2] == Meta)
t--;
}
break;
case (SUB_END|SUB_LONG):
/* Largest possible match at tail of string: *
* move forward along string until we get a match. *
* Again there's no optimisation. */
for (ioff = 0, t = s, umlen = uml; t < s + l;
ioff++, METAINC(t), umlen--) {
set_pat_start(p, t-s);
if (pattrylen(p, t, s + l - t, umlen, ioff)) {
*sp = get_match_ret(*sp, t-s, l, fl, replstr, NULL);
return 1;
}
if (*t == Meta)
t++;
}
break;
case SUB_SUBSTR:
/* Smallest at start, but matching substrings. */
set_pat_start(p, l);
if (!(fl & SUB_GLOBAL) && pattry(p, s + l) && !--n) {
*sp = get_match_ret(*sp, 0, 0, fl, replstr, NULL);
return 1;
} /* fall through */
case (SUB_SUBSTR|SUB_LONG):
/* longest or smallest at start with substrings */
t = s;
if (fl & SUB_GLOBAL) {
repllist = newlinklist();
if (repllistp)
*repllistp = repllist;
}
ioff = 0; /* offset into string */
umlen = uml;
do {
/* loop over all matches for global substitution */
matched = 0;
for (; t < s + l; METAINC(t), ioff++, umlen--) {
/* Find the longest match from this position. */
set_pat_start(p, t-s);
if (pattrylen(p, t, s + l - t, umlen, ioff)) {
char *mpos = t + patmatchlen();
if (!(fl & SUB_LONG) && !(p->flags & PAT_PURES)) {
char *ptr;
int umlen2;
for (ptr = t, umlen2 = 0; ptr < mpos;
METAINC(ptr), umlen2++) {
set_pat_end(p, *ptr);
if (pattrylen(p, t, ptr - t, umlen2, ioff)) {
mpos = t + patmatchlen();
break;
}
}
}
if (!--n || (n <= 0 && (fl & SUB_GLOBAL))) {
*sp = get_match_ret(*sp, t-s, mpos-s, fl,
replstr, repllist);
if (mpos == t)
METAINC(mpos);
}
if (!(fl & SUB_GLOBAL)) {
if (n) {
/*
* Looking for a later match: in this case,
* we can continue looking for matches from
* the next character, even if it overlaps
* with what we just found.
*/
continue;
} else {
return 1;
}
}
/*
* For a global match, we need to skip the stuff
* which is already marked for replacement.
*/
matched = 1;
for ( ; t < mpos; t++, ioff++, umlen--)
if (*t == Meta)
t++;
break;
}
if (*t == Meta)
t++;
}
} while (matched);
/*
* check if we can match a blank string, if so do it
* at the start. Goodness knows if this is a good idea
* with global substitution, so it doesn't happen.
*/
set_pat_start(p, l);
if ((fl & (SUB_LONG|SUB_GLOBAL)) == SUB_LONG &&
pattry(p, s + l) && !--n) {
*sp = get_match_ret(*sp, 0, 0, fl, replstr, repllist);
return 1;
}
break;
case (SUB_END|SUB_SUBSTR):
case (SUB_END|SUB_LONG|SUB_SUBSTR):
/* Longest/shortest at end, matching substrings. */
if (!(fl & SUB_LONG)) {
set_pat_start(p, l);
if (pattrylen(p, s + l, 0, 0, uml) && !--n) {
*sp = get_match_ret(*sp, l, l, fl, replstr, NULL);
return 1;
}
}
for (ioff = uml - 1, t = s + l - 1, umlen = 1; t >= s;
t--, ioff--, umlen++) {
if (t > s && t[-1] == Meta)
t--;
set_pat_start(p, t-s);
if (pattrylen(p, t, s + l - t, umlen, ioff) && !--n) {
/* Found the longest match */
char *mpos = t + patmatchlen();
if (!(fl & SUB_LONG) && !(p->flags & PAT_PURES)) {
char *ptr;
int umlen2;
for (ptr = t, umlen2 = 0; ptr < mpos;
METAINC(ptr), umlen2++) {
set_pat_end(p, *ptr);
if (pattrylen(p, t, ptr - t, umlen2, ioff)) {
mpos = t + patmatchlen();
break;
}
}
}
*sp = get_match_ret(*sp, t-s, mpos-s, fl,
replstr, NULL);
return 1;
}
}
set_pat_start(p, l);
if ((fl & SUB_LONG) && pattrylen(p, s + l, 0, 0, uml) && !--n) {
*sp = get_match_ret(*sp, l, l, fl, replstr, NULL);
return 1;
}
break;
}
}
if (repllist && nonempty(repllist)) {
/* Put all the bits of a global search and replace together. */
LinkNode nd;
Repldata rd;
int lleft = 0; /* size of returned string */
char *ptr, *start;
int i;
i = 0; /* start of last chunk we got from *sp */
for (nd = firstnode(repllist); nd; incnode(nd)) {
rd = (Repldata) getdata(nd);
lleft += rd->b - i; /* previous chunk of *sp */
lleft += strlen(rd->replstr); /* the replaced bit */
i = rd->e; /* start of next chunk of *sp */
}
lleft += l - i; /* final chunk from *sp */
start = t = zhalloc(lleft+1);
i = 0;
for (nd = firstnode(repllist); nd; incnode(nd)) {
rd = (Repldata) getdata(nd);
memcpy(t, s + i, rd->b - i);
t += rd->b - i;
ptr = rd->replstr;
while (*ptr)
*t++ = *ptr++;
i = rd->e;
}
memcpy(t, s + i, l - i);
start[lleft] = '\0';
*sp = (char *)start;
return 1;
}
/* munge the whole string: no match, so no replstr */
*sp = get_match_ret(*sp, 0, 0, fl, 0, 0);
return 1;
}
/**/
#endif /* MULTIBYTE_SUPPORT */
/* blindly turn a string into a tokenised expression without lexing */
/**/
mod_export void
tokenize(char *s)
{
zshtokenize(s, 0);
}
/*
* shtokenize is used when we tokenize a string with GLOB_SUBST set.
* In that case we need to retain backslashes when we turn the
* pattern back into a string, so that the string is not
* modified if it failed to match a pattern.
*
* It may be modified by the effect of SH_GLOB which turns off
* various zsh-specific options.
*/
/**/
mod_export void
shtokenize(char *s)
{
int flags = ZSHTOK_SUBST;
if (isset(SHGLOB))
flags |= ZSHTOK_SHGLOB;
zshtokenize(s, flags);
}
/**/
static void
zshtokenize(char *s, int flags)
{
char *t;
int bslash = 0;
for (; *s; s++) {
cont:
switch (*s) {
case Bnull:
case Bnullkeep:
case '\\':
if (bslash) {
s[-1] = (flags & ZSHTOK_SUBST) ? Bnullkeep : Bnull;
break;
}
bslash = 1;
continue;
case '<':
if (flags & ZSHTOK_SHGLOB)
break;
if (bslash) {
s[-1] = (flags & ZSHTOK_SUBST) ? Bnullkeep : Bnull;
break;
}
t = s;
while (idigit(*++s));
if (*s != '-')
goto cont;
while (idigit(*++s));
if (*s != '>')
goto cont;
*t = Inang;
*s = Outang;
break;
case '(':
case '|':
case ')':
if (flags & ZSHTOK_SHGLOB)
break;
case '>':
case '^':
case '#':
case '~':
case '[':
case ']':
case '*':
case '?':
case '=':
for (t = ztokens; *t; t++)
if (*t == *s) {
if (bslash)
s[-1] = (flags & ZSHTOK_SUBST) ? Bnullkeep : Bnull;
else
*s = (t - ztokens) + Pound;
break;
}
}
bslash = 0;
}
}
/* remove unnecessary Nulargs */
/**/
mod_export void
remnulargs(char *s)
{
if (*s) {
char *o = s, c;
while ((c = *s++))
if (c == Bnullkeep) {
/*
* An active backslash that needs to be turned back into
* a real backslash for output. However, we don't
* do that yet since we need to ignore it during
* pattern matching.
*/
continue;
} else if (inull(c)) {
char *t = s - 1;
while ((c = *s++)) {
if (c == Bnullkeep)
*t++ = '\\';
else if (!inull(c))
*t++ = c;
}
*t = '\0';
if (!*o) {
o[0] = Nularg;
o[1] = '\0';
}
break;
}
}
}
/* qualifier functions: mostly self-explanatory, see glob(). */
/* device number */
/**/
static int
qualdev(UNUSED(char *name), struct stat *buf, off_t dv, UNUSED(char *dummy))
{
return (off_t)buf->st_dev == dv;
}
/* number of hard links to file */
/**/
static int
qualnlink(UNUSED(char *name), struct stat *buf, off_t ct, UNUSED(char *dummy))
{
return (g_range < 0 ? buf->st_nlink < ct :
g_range > 0 ? buf->st_nlink > ct :
buf->st_nlink == ct);
}
/* user ID */
/**/
static int
qualuid(UNUSED(char *name), struct stat *buf, off_t uid, UNUSED(char *dummy))
{
return buf->st_uid == uid;
}
/* group ID */
/**/
static int
qualgid(UNUSED(char *name), struct stat *buf, off_t gid, UNUSED(char *dummy))
{
return buf->st_gid == gid;
}
/* device special file? */
/**/
static int
qualisdev(UNUSED(char *name), struct stat *buf, UNUSED(off_t junk), UNUSED(char *dummy))
{
return S_ISBLK(buf->st_mode) || S_ISCHR(buf->st_mode);
}
/* block special file? */
/**/
static int
qualisblk(UNUSED(char *name), struct stat *buf, UNUSED(off_t junk), UNUSED(char *dummy))
{
return S_ISBLK(buf->st_mode);
}
/* character special file? */
/**/
static int
qualischr(UNUSED(char *name), struct stat *buf, UNUSED(off_t junk), UNUSED(char *dummy))
{
return S_ISCHR(buf->st_mode);
}
/* directory? */
/**/
static int
qualisdir(UNUSED(char *name), struct stat *buf, UNUSED(off_t junk), UNUSED(char *dummy))
{
return S_ISDIR(buf->st_mode);
}
/* FIFO? */
/**/
static int
qualisfifo(UNUSED(char *name), struct stat *buf, UNUSED(off_t junk), UNUSED(char *dummy))
{
return S_ISFIFO(buf->st_mode);
}
/* symbolic link? */
/**/
static int
qualislnk(UNUSED(char *name), struct stat *buf, UNUSED(off_t junk), UNUSED(char *dummy))
{
return S_ISLNK(buf->st_mode);
}
/* regular file? */
/**/
static int
qualisreg(UNUSED(char *name), struct stat *buf, UNUSED(off_t junk), UNUSED(char *dummy))
{
return S_ISREG(buf->st_mode);
}
/* socket? */
/**/
static int
qualissock(UNUSED(char *name), struct stat *buf, UNUSED(off_t junk), UNUSED(char *dummy))
{
return S_ISSOCK(buf->st_mode);
}
/* given flag is set in mode */
/**/
static int
qualflags(UNUSED(char *name), struct stat *buf, off_t mod, UNUSED(char *dummy))
{
return mode_to_octal(buf->st_mode) & mod;
}
/* mode matches specification */
/**/
static int
qualmodeflags(UNUSED(char *name), struct stat *buf, off_t mod, UNUSED(char *dummy))
{
long v = mode_to_octal(buf->st_mode), y = mod & 07777, n = mod >> 12;
return ((v & y) == y && !(v & n));
}
/* regular executable file? */
/**/
static int
qualiscom(UNUSED(char *name), struct stat *buf, UNUSED(off_t mod), UNUSED(char *dummy))
{
return S_ISREG(buf->st_mode) && (buf->st_mode & S_IXUGO);
}
/* size in required range? */
/**/
static int
qualsize(UNUSED(char *name), struct stat *buf, off_t size, UNUSED(char *dummy))
{
#if defined(LONG_IS_64_BIT) || defined(OFF_T_IS_64_BIT)
# define QS_CAST_SIZE()
off_t scaled = buf->st_size;
#else
# define QS_CAST_SIZE() (unsigned long)
unsigned long scaled = (unsigned long)buf->st_size;
#endif
switch (g_units) {
case TT_POSIX_BLOCKS:
scaled += 511l;
scaled /= 512l;
break;
case TT_KILOBYTES:
scaled += 1023l;
scaled /= 1024l;
break;
case TT_MEGABYTES:
scaled += 1048575l;
scaled /= 1048576l;
break;
}
return (g_range < 0 ? scaled < QS_CAST_SIZE() size :
g_range > 0 ? scaled > QS_CAST_SIZE() size :
scaled == QS_CAST_SIZE() size);
#undef QS_CAST_SIZE
}
/* time in required range? */
/**/
static int
qualtime(UNUSED(char *name), struct stat *buf, off_t days, UNUSED(char *dummy))
{
time_t now, diff;
time(&now);
diff = now - (g_amc == 0 ? buf->st_atime : g_amc == 1 ? buf->st_mtime :
buf->st_ctime);
/* handle multipliers indicating units */
switch (g_units) {
case TT_DAYS:
diff /= 86400l;
break;
case TT_HOURS:
diff /= 3600l;
break;
case TT_MINS:
diff /= 60l;
break;
case TT_WEEKS:
diff /= 604800l;
break;
case TT_MONTHS:
diff /= 2592000l;
break;
}
return (g_range < 0 ? diff < days :
g_range > 0 ? diff > days :
diff == days);
}
/* evaluate a string */
/**/
static int
qualsheval(char *name, UNUSED(struct stat *buf), UNUSED(off_t days), char *str)
{
Eprog prog;
if ((prog = parse_string(str, 0))) {
int ef = errflag, lv = lastval, ret;
unsetparam("reply");
setsparam("REPLY", ztrdup(name));
execode(prog, 1, 0, "globqual");
ret = lastval;
errflag = ef;
lastval = lv;
if (!(inserts = getaparam("reply")) &&
!(inserts = gethparam("reply"))) {
char *tmp;
if ((tmp = getsparam("reply")) || (tmp = getsparam("REPLY"))) {
static char *tmparr[2];
tmparr[0] = tmp;
tmparr[1] = NULL;
inserts = tmparr;
}
}
return !ret;
}
return 0;
}
/**/
static int
qualnonemptydir(char *name, struct stat *buf, UNUSED(off_t days), UNUSED(char *str))
{
DIR *dirh;
struct dirent *de;
int unamelen;
char *uname = unmetafy(dupstring(name), &unamelen);
if (!S_ISDIR(buf->st_mode))
return 0;
if (buf->st_nlink > 2)
return 1;
if (!(dirh = opendir(uname)))
return 0;
while ((de = readdir(dirh))) {
if (strcmp(de->d_name, ".") && strcmp(de->d_name, "..")) {
closedir(dirh);
return 1;
}
}
closedir(dirh);
return 0;
}
Jump to Line
Something went wrong with that request. Please try again.