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 void
statprint(struct stat *sbuf, char *outbuf, char *fname, int iwhich, int flags)
{
char *optr = outbuf;
if (flags & STF_NAME) {
sprintf(outbuf, (flags & (STF_PICK|STF_ARRAY)) ?
"%s " : "%-8s", statelts[iwhich]);
optr += strlen(outbuf);
}
*optr = '\0';
/* cast values to unsigned long as safest bet */
switch (iwhich) {
case ST_DEV:
statulprint((unsigned long)sbuf->st_dev, optr);
break;
case ST_INO:
#ifdef INO_T_IS_64_BIT
convbase(optr, sbuf->st_ino, 0);
#else
DPUTS(sizeof(sbuf->st_ino) > sizeof(unsigned long),
"Shell compiled with wrong ino_t size");
statulprint((unsigned long)sbuf->st_ino, optr);
#endif
break;
case ST_MODE:
statmodeprint(sbuf->st_mode, optr, flags);
break;
case ST_NLINK:
statulprint((unsigned long)sbuf->st_nlink, optr);
break;
case ST_UID:
statuidprint(sbuf->st_uid, optr, flags);
break;
case ST_GID:
statgidprint(sbuf->st_gid, optr, flags);
break;
case ST_RDEV:
statulprint((unsigned long)sbuf->st_rdev, optr);
break;
case ST_SIZE:
#ifdef OFF_T_IS_64_BIT
convbase(optr, sbuf->st_size, 0);
#else
DPUTS(sizeof(sbuf->st_size) > sizeof(unsigned long),
"Shell compiled with wrong off_t size");
statulprint((unsigned long)sbuf->st_size, optr);
#endif
break;
case ST_ATIM:
#ifdef GET_ST_ATIME_NSEC
stattimeprint(sbuf->st_atime, GET_ST_ATIME_NSEC(*sbuf), optr, flags);
#else
stattimeprint(sbuf->st_atime, 0L, optr, flags);
#endif
break;
case ST_MTIM:
#ifdef GET_ST_MTIME_NSEC
stattimeprint(sbuf->st_mtime, GET_ST_MTIME_NSEC(*sbuf), optr, flags);
#else
stattimeprint(sbuf->st_mtime, 0L, optr, flags);
#endif
break;
case ST_CTIM:
#ifdef GET_ST_CTIME_NSEC
stattimeprint(sbuf->st_ctime, GET_ST_CTIME_NSEC(*sbuf), optr, flags);
#else
stattimeprint(sbuf->st_ctime, 0L, optr, flags);
#endif
break;
case ST_BLKSIZE:
statulprint((unsigned long)sbuf->st_blksize, optr);
break;
case ST_BLOCKS:
statulprint((unsigned long)sbuf->st_blocks, optr);
break;
case ST_READLINK:
statlinkprint(sbuf, optr, fname);
break;
case ST_COUNT: /* keep some compilers happy */
break;
}
}
