mod_export zlong
cond_val(char **args, int num)
{
char *s = args[num];
if (has_token(s)) {
singsub(&s);
untokenize(s);
}
return mathevali(s);
}
int
execrepeat(Estate state, UNUSED(int do_exec))
{
Wordcode end, loop;
wordcode code = state->pc[-1];
int count, htok = 0;
char *tmp;
int old_simple_pline = simple_pline;
/* See comments in execwhile() */
simple_pline = 1;
end = state->pc + WC_REPEAT_SKIP(code);
lastval = 0;
tmp = ecgetstr(state, EC_DUPTOK, &htok);
if (htok)
singsub(&tmp);
count = mathevali(tmp);
if (errflag)
return 1;
pushheap();
cmdpush(CS_REPEAT);
loops++;
loop = state->pc;
while (count-- > 0) {
state->pc = loop;
execlist(state, 1, 0);
freeheap();
if (breaks) {
breaks--;
if (breaks || !contflag)
break;
contflag = 0;
}
if (errflag) {
lastval = 1;
break;
}
if (retflag)
break;
}
cmdpop();
popheap();
loops--;
simple_pline = old_simple_pline;
state->pc = end;
this_noerrexit = 1;
return lastval;
}
int
execfor(Estate state, int do_exec)
{
Wordcode end, loop;
wordcode code = state->pc[-1];
int iscond = (WC_FOR_TYPE(code) == WC_FOR_COND), ctok = 0, atok = 0;
int last = 0;
char *name, *str, *cond = NULL, *advance = NULL;
zlong val = 0;
LinkList vars = NULL, args = NULL;
int old_simple_pline = simple_pline;
/* See comments in execwhile() */
simple_pline = 1;
end = state->pc + WC_FOR_SKIP(code);
if (iscond) {
str = dupstring(ecgetstr(state, EC_NODUP, NULL));
singsub(&str);
if (isset(XTRACE)) {
char *str2 = dupstring(str);
untokenize(str2);
printprompt4();
fprintf(xtrerr, "%s\n", str2);
fflush(xtrerr);
}
if (!errflag) {
matheval(str);
}
if (errflag) {
state->pc = end;
simple_pline = old_simple_pline;
return 1;
}
cond = ecgetstr(state, EC_NODUP, &ctok);
advance = ecgetstr(state, EC_NODUP, &atok);
} else {
vars = ecgetlist(state, *state->pc++, EC_NODUP, NULL);
if (WC_FOR_TYPE(code) == WC_FOR_LIST) {
int htok = 0;
if (!(args = ecgetlist(state, *state->pc++, EC_DUPTOK, &htok))) {
state->pc = end;
simple_pline = old_simple_pline;
return 0;
}
if (htok) {
execsubst(args);
if (errflag) {
state->pc = end;
simple_pline = old_simple_pline;
return 1;
}
}
} else {
char **x;
args = newlinklist();
for (x = pparams; *x; x++)
addlinknode(args, dupstring(*x));
}
}
if (!args || empty(args))
lastval = 0;
loops++;
pushheap();
cmdpush(CS_FOR);
loop = state->pc;
while (!last) {
if (iscond) {
if (ctok) {
str = dupstring(cond);
singsub(&str);
} else
str = cond;
if (!errflag) {
while (iblank(*str))
str++;
if (*str) {
if (isset(XTRACE)) {
printprompt4();
fprintf(xtrerr, "%s\n", str);
fflush(xtrerr);
}
val = mathevali(str);
} else
val = 1;
}
if (errflag) {
if (breaks)
breaks--;
lastval = 1;
break;
}
if (!val)
break;
} else {
LinkNode node;
int count = 0;
for (node = firstnode(vars); node; incnode(node))
{
name = (char *)getdata(node);
if (!args || !(str = (char *) ugetnode(args)))
{
if (count) {
str = "";
last = 1;
} else
break;
}
if (isset(XTRACE)) {
printprompt4();
fprintf(xtrerr, "%s=%s\n", name, str);
fflush(xtrerr);
}
setsparam(name, ztrdup(str));
count++;
}
if (!count)
break;
}
state->pc = loop;
execlist(state, 1, do_exec && args && empty(args));
if (breaks) {
breaks--;
if (breaks || !contflag)
break;
contflag = 0;
}
if (retflag)
break;
if (iscond && !errflag) {
if (atok) {
str = dupstring(advance);
singsub(&str);
} else
str = advance;
if (isset(XTRACE)) {
printprompt4();
fprintf(xtrerr, "%s\n", str);
fflush(xtrerr);
}
if (!errflag)
matheval(str);
}
if (errflag) {
if (breaks)
breaks--;
lastval = 1;
break;
}
freeheap();
}
popheap();
cmdpop();
loops--;
simple_pline = old_simple_pline;
state->pc = end;
return lastval;
}
int
evalcond(Estate state, char *fromtest)
{
struct stat *st;
char *left, *right, *overridename, overridebuf[13];
Wordcode pcode;
wordcode code;
int ctype, htok = 0, ret;
rec:
left = right = overridename = NULL;
pcode = state->pc++;
code = *pcode;
ctype = WC_COND_TYPE(code);
switch (ctype) {
case COND_NOT:
if (tracingcond)
fprintf(xtrerr, " %s", condstr[ctype]);
ret = evalcond(state, fromtest);
if (ret == 2)
return ret;
else
return !ret;
case COND_AND:
if (!(ret = evalcond(state, fromtest))) {
if (tracingcond)
fprintf(xtrerr, " %s", condstr[ctype]);
goto rec;
} else {
state->pc = pcode + (WC_COND_SKIP(code) + 1);
return ret;
}
case COND_OR:
if ((ret = evalcond(state, fromtest)) == 1) {
if (tracingcond)
fprintf(xtrerr, " %s", condstr[ctype]);
goto rec;
} else {
state->pc = pcode + (WC_COND_SKIP(code) + 1);
return ret;
}
case COND_REGEX:
{
char *modname = isset(REMATCHPCRE) ? "zsh/pcre" : "zsh/regex";
sprintf(overridename = overridebuf, "-%s-match", modname+4);
(void)ensurefeature(modname, "C:", overridename+1);
ctype = COND_MODI;
}
/*FALLTHROUGH*/
case COND_MOD:
case COND_MODI:
{
Conddef cd;
char *name = overridename, *errname;
char **strs;
int l = WC_COND_SKIP(code);
if (name == NULL)
name = ecgetstr(state, EC_NODUP, NULL);
if (ctype == COND_MOD)
strs = ecgetarr(state, l, EC_DUP, NULL);
else {
char *sbuf[3];
sbuf[0] = ecgetstr(state, EC_NODUP, NULL);
sbuf[1] = ecgetstr(state, EC_NODUP, NULL);
sbuf[2] = NULL;
strs = arrdup(sbuf);
l = 2;
}
if (name && name[0] == '-')
errname = name;
else if (strs[0] && *strs[0] == '-')
errname = strs[0];
else
errname = "<null>";
if (name && name[0] == '-' &&
(cd = getconddef((ctype == COND_MODI), name + 1, 1))) {
if (ctype == COND_MOD &&
(l < cd->min || (cd->max >= 0 && l > cd->max))) {
zwarnnam(fromtest, "unknown condition: %s", name);
return 2;
}
if (tracingcond)
tracemodcond(name, strs, ctype == COND_MODI);
return !cd->handler(strs, cd->condid);
}
else {
char *s = strs[0];
if (overridename) {
/*
* Standard regex function not available: this
* is a hard error.
*/
zerrnam(fromtest, "%s not available for regex",
overridename);
return 2;
}
strs[0] = dupstring(name);
name = s;
if (name && name[0] == '-' &&
(cd = getconddef(0, name + 1, 1))) {
if (l < cd->min || (cd->max >= 0 && l > cd->max)) {
zwarnnam(fromtest, "unknown condition: %s",
errname);
return 2;
}
if (tracingcond)
tracemodcond(name, strs, ctype == COND_MODI);
return !cd->handler(strs, cd->condid);
} else {
zwarnnam(fromtest,
"unknown condition: %s",
errname);
}
}
/* module not found, error */
return 2;
}
}
left = ecgetstr(state, EC_DUPTOK, &htok);
if (htok) {
cond_subst(&left, !fromtest);
untokenize(left);
}
if (ctype <= COND_GE && ctype != COND_STREQ && ctype != COND_STRNEQ) {
right = ecgetstr(state, EC_DUPTOK, &htok);
if (htok) {
cond_subst(&right, !fromtest);
untokenize(right);
}
}
if (tracingcond) {
if (ctype < COND_MOD) {
fputc(' ',xtrerr);
quotedzputs(left, xtrerr);
fprintf(xtrerr, " %s ", condstr[ctype]);
if (ctype == COND_STREQ || ctype == COND_STRNEQ) {
char *rt = dupstring(ecrawstr(state->prog, state->pc, NULL));
cond_subst(&rt, !fromtest);
quote_tokenized_output(rt, xtrerr);
}
else
quotedzputs((char *)right, xtrerr);
} else {
fprintf(xtrerr, " -%c ", ctype);
quotedzputs(left, xtrerr);
}
}
if (ctype >= COND_EQ && ctype <= COND_GE) {
mnumber mn1, mn2;
if (fromtest) {
/*
* For test and [, the expressions must be base 10 integers,
* not integer expressions.
*/
char *eptr, *err;
mn1.u.l = zstrtol(left, &eptr, 10);
if (!*eptr)
{
mn2.u.l = zstrtol(right, &eptr, 10);
err = right;
}
else
err = left;
if (*eptr)
{
zwarnnam(fromtest, "integer expression expected: %s", err);
return 2;
}
mn1.type = mn2.type = MN_INTEGER;
} else {
mn1 = matheval(left);
mn2 = matheval(right);
}
if (((mn1.type|mn2.type) & (MN_INTEGER|MN_FLOAT)) ==
(MN_INTEGER|MN_FLOAT)) {
/* promote to float */
if (mn1.type & MN_INTEGER) {
mn1.type = MN_FLOAT;
mn1.u.d = (double)mn1.u.l;
}
if (mn2.type & MN_INTEGER) {
mn2.type = MN_FLOAT;
mn2.u.d = (double)mn2.u.l;
}
}
switch(ctype) {
case COND_EQ:
return !((mn1.type & MN_FLOAT) ? (mn1.u.d == mn2.u.d) :
(mn1.u.l == mn2.u.l));
case COND_NE:
return !((mn1.type & MN_FLOAT) ? (mn1.u.d != mn2.u.d) :
(mn1.u.l != mn2.u.l));
case COND_LT:
return !((mn1.type & MN_FLOAT) ? (mn1.u.d < mn2.u.d) :
(mn1.u.l < mn2.u.l));
case COND_GT:
return !((mn1.type & MN_FLOAT) ? (mn1.u.d > mn2.u.d) :
(mn1.u.l > mn2.u.l));
case COND_LE:
return !((mn1.type & MN_FLOAT) ? (mn1.u.d <= mn2.u.d) :
(mn1.u.l <= mn2.u.l));
case COND_GE:
return !((mn1.type & MN_FLOAT) ? (mn1.u.d >= mn2.u.d) :
(mn1.u.l >= mn2.u.l));
}
}
switch (ctype) {
case COND_STREQ:
case COND_STRNEQ:
{
int test, npat = state->pc[1];
Patprog pprog = state->prog->pats[npat];
if (pprog == dummy_patprog1 || pprog == dummy_patprog2) {
char *opat;
int save;
right = dupstring(opat = ecrawstr(state->prog, state->pc,
&htok));
singsub(&right);
save = (!(state->prog->flags & EF_HEAP) &&
!strcmp(opat, right) && pprog != dummy_patprog2);
if (!(pprog = patcompile(right, (save ? PAT_ZDUP : PAT_STATIC),
NULL))) {
zwarnnam(fromtest, "bad pattern: %s", right);
return 2;
}
else if (save)
state->prog->pats[npat] = pprog;
}
state->pc += 2;
test = (pprog && pattry(pprog, left));
return !(ctype == COND_STREQ ? test : !test);
}
case COND_STRLT:
return !(strcmp(left, right) < 0);
case COND_STRGTR:
return !(strcmp(left, right) > 0);
case 'e':
case 'a':
return (!doaccess(left, F_OK));
case 'b':
return (!S_ISBLK(dostat(left)));
case 'c':
return (!S_ISCHR(dostat(left)));
case 'd':
return (!S_ISDIR(dostat(left)));
case 'f':
return (!S_ISREG(dostat(left)));
case 'g':
return (!(dostat(left) & S_ISGID));
case 'k':
return (!(dostat(left) & S_ISVTX));
case 'n':
return (!strlen(left));
case 'o':
return (optison(fromtest, left));
case 'p':
return (!S_ISFIFO(dostat(left)));
case 'r':
return (!doaccess(left, R_OK));
case 's':
return !((st = getstat(left)) && !!(st->st_size));
case 'S':
return (!S_ISSOCK(dostat(left)));
case 'u':
return (!(dostat(left) & S_ISUID));
case 'w':
return (!doaccess(left, W_OK));
case 'x':
if (privasserted()) {
mode_t mode = dostat(left);
return !((mode & S_IXUGO) || S_ISDIR(mode));
}
return !doaccess(left, X_OK);
case 'z':
return !!(strlen(left));
case 'h':
case 'L':
return (!S_ISLNK(dolstat(left)));
case 'O':
return !((st = getstat(left)) && st->st_uid == geteuid());
case 'G':
return !((st = getstat(left)) && st->st_gid == getegid());
case 'N':
#if defined(GET_ST_MTIME_NSEC) && defined(GET_ST_ATIME_NSEC)
if (!(st = getstat(left)))
return 1;
return (st->st_atime == st->st_mtime) ?
GET_ST_ATIME_NSEC(*st) > GET_ST_MTIME_NSEC(*st) :
st->st_atime > st->st_mtime;
#else
return !((st = getstat(left)) && st->st_atime <= st->st_mtime);
#endif
case 't':
return !isatty(mathevali(left));
case COND_NT:
case COND_OT:
{
time_t a;
#ifdef GET_ST_MTIME_NSEC
long nsecs;
#endif
if (!(st = getstat(left)))
return 1;
a = st->st_mtime;
#ifdef GET_ST_MTIME_NSEC
nsecs = GET_ST_MTIME_NSEC(*st);
#endif
if (!(st = getstat(right)))
return 1;
#ifdef GET_ST_MTIME_NSEC
if (a == st->st_mtime) {
return !((ctype == COND_NT) ? nsecs > GET_ST_MTIME_NSEC(*st) :
nsecs < GET_ST_MTIME_NSEC(*st));
}
#endif
return !((ctype == COND_NT) ? a > st->st_mtime : a < st->st_mtime);
}
case COND_EF:
{
dev_t d;
ino_t i;
if (!(st = getstat(left)))
return 1;
d = st->st_dev;
i = st->st_ino;
if (!(st = getstat(right)))
return 1;
return !(d == st->st_dev && i == st->st_ino);
}
default:
zwarnnam(fromtest, "bad cond code");
return 2;
}
}
static int
bin_zsystem_flock(char *nam, char **args, UNUSED(Options ops), UNUSED(int func))
{
int cloexec = 1, unlock = 0, readlock = 0;
time_t timeout = 0;
char *fdvar = NULL;
#ifdef HAVE_FCNTL_H
struct flock lck;
int flock_fd, flags;
#endif
while (*args && **args == '-') {
int opt;
char *optptr = *args + 1, *optarg;
args++;
if (!*optptr || !strcmp(optptr, "-"))
break;
while ((opt = *optptr)) {
switch (opt) {
case 'e':
/* keep lock on "exec" */
cloexec = 0;
break;
case 'f':
/* variable for fd */
if (optptr[1]) {
fdvar = optptr + 1;
optptr += strlen(fdvar) - 1;
} else if (*args) {
fdvar = *args++;
}
if (fdvar == NULL || !isident(fdvar)) {
zwarnnam(nam, "flock: option %c requires a variable name",
opt);
return 1;
}
break;
case 'r':
/* read lock rather than read-write lock */
readlock = 1;
break;
case 't':
/* timeout in seconds */
if (optptr[1]) {
optarg = optptr + 1;
optptr += strlen(optarg) - 1;
} else if (!*args) {
zwarnnam(nam, "flock: option %c requires a numeric timeout",
opt);
return 1;
} else {
optarg = *args++;
}
timeout = (time_t)mathevali(optarg);
break;
case 'u':
/* unlock: argument is fd */
unlock = 1;
break;
default:
zwarnnam(nam, "flock: unknown option: %c", *optptr);
return 1;
}
optptr++;
}
}
if (!args[0]) {
zwarnnam(nam, "flock: not enough arguments");
return 1;
}
if (args[1]) {
zwarnnam(nam, "flock: too many arguments");
return 1;
}
#ifdef HAVE_FCNTL_H
if (unlock) {
flock_fd = (int)mathevali(args[0]);
if (zcloselockfd(flock_fd) < 0) {
zwarnnam(nam, "flock: file descriptor %d not in use for locking",
flock_fd);
return 1;
}
return 0;
}
if (readlock)
flags = O_RDONLY | O_NOCTTY;
else
flags = O_RDWR | O_NOCTTY;
if ((flock_fd = open(unmeta(args[0]), flags)) < 0) {
zwarnnam(nam, "failed to open %s for writing: %e", args[0], errno);
return 1;
}
flock_fd = movefd(flock_fd);
if (flock_fd == -1)
return 1;
#ifdef FD_CLOEXEC
if (cloexec)
{
long fdflags = fcntl(flock_fd, F_GETFD, 0);
if (fdflags != (long)-1)
fcntl(flock_fd, F_SETFD, fdflags | FD_CLOEXEC);
}
#endif
addlockfd(flock_fd, cloexec);
lck.l_type = readlock ? F_RDLCK : F_WRLCK;
lck.l_whence = SEEK_SET;
lck.l_start = 0;
lck.l_len = 0; /* lock the whole file */
if (timeout > 0) {
time_t end = time(NULL) + (time_t)timeout;
while (fcntl(flock_fd, F_SETLK, &lck) < 0) {
if (errflag)
return 1;
if (errno != EINTR && errno != EACCES && errno != EAGAIN) {
zwarnnam(nam, "failed to lock file %s: %e", args[0], errno);
return 1;
}
if (time(NULL) >= end)
return 2;
sleep(1);
}
} else {
while (fcntl(flock_fd, F_SETLKW, &lck) < 0) {
if (errflag)
return 1;
if (errno == EINTR)
continue;
zwarnnam(nam, "failed to lock file %s: %e", args[0], errno);
return 1;
}
}
if (fdvar)
setiparam(fdvar, flock_fd);
return 0;
#else /* HAVE_FCNTL_H */
zwarnnam(nam, "flock: not implemented on this system");
return 255;
#endif /* HAVE_FCNTL_H */
}
