From 48525452555a24b9d41748f26b4b77f160f01220 Mon Sep 17 00:00:00 2001 From: Peter Stephenson Date: Sat, 1 Apr 2000 20:49:47 +0000 Subject: Updated from list as far as 10376 --- Src/cond.c | 326 ++++++++++++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 269 insertions(+), 57 deletions(-) (limited to 'Src/cond.c') diff --git a/Src/cond.c b/Src/cond.c index 79886a720..8a54eeeb2 100644 --- a/Src/cond.c +++ b/Src/cond.c @@ -30,125 +30,277 @@ #include "zsh.mdh" #include "cond.pro" +int tracingcond; + +static char *condstr[COND_MOD] = { + "!", "&&", "||", "==", "!=", "<", ">", "-nt", "-ot", "-ef", "-eq", + "-ne", "-lt", "-gt", "-le", "-ge" +}; + /**/ int -evalcond(Cond c) +evalcond(Estate state) { struct stat *st; + char *left, *right; + Wordcode pcode; + wordcode code; + int ctype, htok = 0; + + rec: + + left = right = NULL; + pcode = state->pc++; + code = *pcode; + ctype = WC_COND_TYPE(code); - switch (c->type) { + switch (ctype) { case COND_NOT: - return !evalcond(c->left); + if (tracingcond) + fprintf(xtrerr, " %s", condstr[ctype]); + return !evalcond(state); case COND_AND: - return evalcond(c->left) && evalcond(c->right); + if (evalcond(state)) { + if (tracingcond) + fprintf(xtrerr, " %s", condstr[ctype]); + goto rec; + } else { + state->pc = pcode + (WC_COND_SKIP(code) + 1); + return 0; + } case COND_OR: - return evalcond(c->left) || evalcond(c->right); + if (!evalcond(state)) { + if (tracingcond) + fprintf(xtrerr, " %s", condstr[ctype]); + goto rec; + } else { + state->pc = pcode + (WC_COND_SKIP(code) + 1); + return 1; + } + case COND_MOD: + case COND_MODI: + { + Conddef cd; + char *name = ecgetstr(state, EC_NODUP, NULL), **strs; + int l = WC_COND_SKIP(code); + + 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 ((cd = getconddef((ctype == COND_MODI), name + 1, 1))) { + if (ctype == COND_MOD && + (l < cd->min || (cd->max >= 0 && l > cd->max))) { + zerr("unrecognized condition: `%s'", name, 0); + return 0; + } + if (tracingcond) + tracemodcond(name, strs, ctype == COND_MODI); + return cd->handler(strs, cd->condid); + } + else { + char *s = strs[0]; + + 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)) { + zerr("unrecognized condition: `%s'", name, 0); + return 0; + } + if (tracingcond) + tracemodcond(name, strs, ctype == COND_MODI); + return cd->handler(strs, cd->condid); + } else + zerr("unrecognized condition: `%s'", name, 0); + } + return 0; + } } - singsub((char **)&c->left); - untokenize(c->left); - if (c->right) { - singsub((char **)&c->right); - if (c->type != COND_STREQ && c->type != COND_STRNEQ) - untokenize(c->right); + left = ecgetstr(state, EC_DUPTOK, &htok); + if (htok) { + singsub(&left); + untokenize(left); } - switch (c->type) { + if (ctype <= COND_GE && ctype != COND_STREQ && ctype != COND_STRNEQ) { + right = ecgetstr(state, EC_DUPTOK, &htok); + if (htok) { + singsub(&right); + untokenize(right); + } + } + if (tracingcond) { + if (ctype < COND_MOD) { + char *rt = (char *) right; + if (ctype == COND_STREQ || ctype == COND_STRNEQ) { + rt = dupstring(ecrawstr(state->prog, state->pc, NULL)); + singsub(&rt); + untokenize(rt); + } + fprintf(xtrerr, " %s %s %s", left, condstr[ctype], rt); + } else + fprintf(xtrerr, " -%c %s", ctype, left); + } + + if (ctype >= COND_EQ && ctype <= COND_GE) { + mnumber mn1, mn2; + 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: - return matchpat(c->left, c->right); case COND_STRNEQ: - return !matchpat(c->left, c->right); + { + int test, npat = state->pc[1]; + Patprog pprog = state->prog->pats[npat]; + + if (pprog == dummy_patprog1 || pprog == dummy_patprog2) { + char *opat; + int save; + + right = opat = dupstring(ecrawstr(state->prog, state->pc, + &htok)); + if (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))) + zerr("bad pattern: %s", right, 0); + 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(c->left, c->right) < 0; + return strcmp(left, right) < 0; case COND_STRGTR: - return strcmp(c->left, c->right) > 0; + return strcmp(left, right) > 0; case 'e': case 'a': - return (doaccess(c->left, F_OK)); + return (doaccess(left, F_OK)); case 'b': - return (S_ISBLK(dostat(c->left))); + return (S_ISBLK(dostat(left))); case 'c': - return (S_ISCHR(dostat(c->left))); + return (S_ISCHR(dostat(left))); case 'd': - return (S_ISDIR(dostat(c->left))); + return (S_ISDIR(dostat(left))); case 'f': - return (S_ISREG(dostat(c->left))); + return (S_ISREG(dostat(left))); case 'g': - return (!!(dostat(c->left) & S_ISGID)); + return (!!(dostat(left) & S_ISGID)); case 'k': - return (!!(dostat(c->left) & S_ISVTX)); + return (!!(dostat(left) & S_ISVTX)); case 'n': - return (!!strlen(c->left)); + return (!!strlen(left)); case 'o': - return (optison(c->left)); + return (optison(left)); case 'p': - return (S_ISFIFO(dostat(c->left))); + return (S_ISFIFO(dostat(left))); case 'r': - return (doaccess(c->left, R_OK)); + return (doaccess(left, R_OK)); case 's': - return ((st = getstat(c->left)) && !!(st->st_size)); + return ((st = getstat(left)) && !!(st->st_size)); case 'S': - return (S_ISSOCK(dostat(c->left))); + return (S_ISSOCK(dostat(left))); case 'u': - return (!!(dostat(c->left) & S_ISUID)); + return (!!(dostat(left) & S_ISUID)); case 'w': - return (doaccess(c->left, W_OK)); + return (doaccess(left, W_OK)); case 'x': if (privasserted()) { - mode_t mode = dostat(c->left); + mode_t mode = dostat(left); return (mode & S_IXUGO) || S_ISDIR(mode); } - return doaccess(c->left, X_OK); + return doaccess(left, X_OK); case 'z': - return (!strlen(c->left)); + return (!strlen(left)); case 'h': case 'L': - return (S_ISLNK(dolstat(c->left))); + return (S_ISLNK(dolstat(left))); case 'O': - return ((st = getstat(c->left)) && st->st_uid == geteuid()); + return ((st = getstat(left)) && st->st_uid == geteuid()); case 'G': - return ((st = getstat(c->left)) && st->st_gid == getegid()); + return ((st = getstat(left)) && st->st_gid == getegid()); case 'N': - return ((st = getstat(c->left)) && st->st_atime <= st->st_mtime); + return ((st = getstat(left)) && st->st_atime <= st->st_mtime); case 't': - return isatty(matheval(c->left)); - case COND_EQ: - return matheval(c->left) == matheval(c->right); - case COND_NE: - return matheval(c->left) != matheval(c->right); - case COND_LT: - return matheval(c->left) < matheval(c->right); - case COND_GT: - return matheval(c->left) > matheval(c->right); - case COND_LE: - return matheval(c->left) <= matheval(c->right); - case COND_GE: - return matheval(c->left) >= matheval(c->right); + return isatty(mathevali(left)); case COND_NT: case COND_OT: { time_t a; - if (!(st = getstat(c->left))) + if (!(st = getstat(left))) return 0; a = st->st_mtime; - if (!(st = getstat(c->right))) + if (!(st = getstat(right))) return 0; - return (c->type == COND_NT) ? a > st->st_mtime : a < st->st_mtime; + return (ctype == COND_NT) ? a > st->st_mtime : a < st->st_mtime; } case COND_EF: { dev_t d; ino_t i; - if (!(st = getstat(c->left))) + if (!(st = getstat(left))) return 0; d = st->st_dev; i = st->st_ino; - if (!(st = getstat(c->right))) + if (!(st = getstat(right))) return 0; return d == st->st_dev && i == st->st_ino; } default: - zerr("bad cond structure", NULL, 0); + zerr("bad cond code", NULL, 0); } return 0; } @@ -158,6 +310,10 @@ evalcond(Cond c) static int doaccess(char *s, int c) { +#ifdef HAVE_FACCESSX + if (!strncmp(s, "/dev/fd/", 8)) + return !faccessx(atoi(s + 8), c, ACC_SELF); +#endif return !access(unmeta(s), c); } @@ -224,3 +380,59 @@ optison(char *s) else return isset(i); } + +/**/ +mod_export char * +cond_str(char **args, int num, int raw) +{ + char *s = args[num]; + + if (has_token(s)) { + singsub(&s); + if (!raw) + untokenize(s); + } + return s; +} + +/**/ +mod_export zlong +cond_val(char **args, int num) +{ + char *s = args[num]; + + if (has_token(s)) { + singsub(&s); + untokenize(s); + } + return mathevali(s); +} + +/**/ +mod_export int +cond_match(char **args, int num, char *str) +{ + char *s = args[num]; + + singsub(&s); + + return matchpat(str, s); +} + +/**/ +static void +tracemodcond(char *name, char **args, int inf) +{ + char **aptr; + + args = arrdup(args); + for (aptr = args; *aptr; aptr++) + untokenize(*aptr); + if (inf) { + fprintf(xtrerr, " %s %s %s", args[0], name, args[1]); + } else { + fprintf(xtrerr, " %s", name); + while (*args) + fprintf(xtrerr, " %s", *args++); + } +} -- cgit 1.4.1