Index: head/bin/test/TEST.sh =================================================================== --- head/bin/test/TEST.sh (revision 192861) +++ head/bin/test/TEST.sh (revision 192862) @@ -1,137 +1,177 @@ #!/bin/sh #- # Copyright (c) June 1996 Wolfram Schneider . Berlin. # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS # OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) # HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY # OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF # SUCH DAMAGE. # # TEST.sh - check if test(1) or builtin test works # # $FreeBSD$ # force a specified test program, e.g. `env test=/bin/test sh TEST.sh' : ${test=test} ERROR=0 FAILED=0 t () { # $1 -> exit code # $2 -> $test expression echo -n "$1: $test $2 " # check for syntax errors syntax="`eval $test $2 2>&1`" if test -z "$syntax"; then case $1 in 0) if eval $test $2; then echo " OK"; else failed;fi;; 1) if eval $test $2; then failed; else echo " OK";fi;; esac else error fi } error () { echo ""; echo " $syntax" ERROR=`expr $ERROR + 1` } failed () { echo ""; echo " failed" FAILED=`expr $FAILED + 1` } t 0 'b = b' t 1 'b != b' t 0 '\( b = b \)' t 1 '! \( b = b \)' t 1 '! -f /etc/passwd' t 0 '-h = -h' t 0 '-o = -o' t 1 '-f = h' t 1 '-h = f' t 1 '-o = f' t 1 'f = -o' t 0 '\( -h = -h \)' t 1 '\( a = -h \)' t 1 '\( -f = h \)' t 0 '-h = -h -o a' t 0 '\( -h = -h \) -o 1' t 0 '-h = -h -o -h = -h' t 0 '\( -h = -h \) -o \( -h = -h \)' t 0 'roedelheim = roedelheim' t 1 'potsdam = berlin-dahlem' t 0 '-d /' t 0 '-d / -a a != b' t 1 '-z "-z"' t 0 '-n -n' t 0 '0' t 0 '\( 0 \)' t 0 '-E' t 0 '-X -a -X' t 0 '-XXX' t 0 '\( -E \)' t 0 'true -o X' t 0 'true -o -X' t 0 '\( \( \( a = a \) -o 1 \) -a 1 \) -a true' t 1 '-h /' t 0 '-r /' t 1 '-w /' t 0 '-x /bin/sh' t 0 '-c /dev/null' t 0 '-f /etc/passwd' t 0 '-s /etc/passwd' t 1 '! \( 700 -le 1000 -a -n "1" -a "20" = "20" \)' t 0 '100 -eq 100' t 0 '100 -lt 200' t 1 '1000 -lt 200' t 0 '1000 -gt 200' t 0 '1000 -ge 200' t 0 '1000 -ge 1000' t 1 '2 -ne 2' t 0 '0 -eq 0' t 1 '-5 -eq 5' t 0 '\( 0 -eq 0 \)' t 1 '1 -eq 0 -o a = a -a 1 -eq 0 -o a = aa' t 1 '"" -o ""' t 1 '"" -a ""' t 1 '"a" -a ""' t 0 '"a" -a ! ""' t 1 '""' t 0 '! ""' +t 0 '!' +t 0 '\(' +t 0 '\)' + +t 1 '\( = \)' +t 0 '\( != \)' +t 0 '\( ! \)' +t 0 '\( \( \)' +t 0 '\( \) \)' +t 0 '! = !' +t 1 '! != !' +t 1 '-n = \)' +t 0 '! != \)' +t 1 '! = a' +t 0 '! != -n' +t 0 '! -c /etc/passwd' + +t 0 '! \( = \)' +t 1 '! \( != \)' +t 1 '! = = =' +t 0 '! = = \)' +t 0 '! "" -o ""' +t 1 '! "x" -o ""' +t 1 '! "" -o "x"' +t 1 '! "x" -o "x"' +t 0 '\( -f /etc/passwd \)' +t 1 '\( ! = \)' +t 0 '\( ! "" \)' +t 1 '\( ! -e \)' + +t 0 '0 -eq 0 -a -d /' +t 0 '-s = "" -o "" = ""' +t 0 '"" = "" -o -s = ""' +t 1 '-s = "" -o -s = ""' +t 0 '-z x -o x = "#" -o x = x' +t 1 '-z y -o y = "#" -o y = x' +t 0 '0 -ne 0 -o ! -f /' +t 0 '1 -ne 0 -o ! -f /etc/passwd' +t 1 '0 -ne 0 -o ! -f /etc/passwd' + echo "" echo "Syntax errors: $ERROR Failed: $FAILED" Index: head/bin/test/test.c =================================================================== --- head/bin/test/test.c (revision 192861) +++ head/bin/test/test.c (revision 192862) @@ -1,548 +1,598 @@ /* $NetBSD: test.c,v 1.21 1999/04/05 09:48:38 kleink Exp $ */ /*- * test(1); version 7-like -- author Erik Baalbergen * modified by Eric Gisin to be used as built-in. * modified by Arnold Robbins to add SVR3 compatibility * (-x -c -b -p -u -g -k) plus Korn's -L -nt -ot -ef and new -S (socket). * modified by J.T. Conklin for NetBSD. * * This program is in the Public Domain. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #include #include #ifdef SHELL #define main testcmd #include "bltin/bltin.h" #else #include static void error(const char *, ...) __dead2 __printf0like(1, 2); static void error(const char *msg, ...) { va_list ap; va_start(ap, msg); verrx(2, msg, ap); /*NOTREACHED*/ va_end(ap); } #endif /* test(1) accepts the following grammar: oexpr ::= aexpr | aexpr "-o" oexpr ; aexpr ::= nexpr | nexpr "-a" aexpr ; nexpr ::= primary | "!" primary primary ::= unary-operator operand | operand binary-operator operand | operand | "(" oexpr ")" ; unary-operator ::= "-r"|"-w"|"-x"|"-f"|"-d"|"-c"|"-b"|"-p"| "-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"|"-L"|"-S"; binary-operator ::= "="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"| "-nt"|"-ot"|"-ef"; operand ::= */ enum token { EOI, FILRD, FILWR, FILEX, FILEXIST, FILREG, FILDIR, FILCDEV, FILBDEV, FILFIFO, FILSOCK, FILSYM, FILGZ, FILTT, FILSUID, FILSGID, FILSTCK, FILNT, FILOT, FILEQ, FILUID, FILGID, STREZ, STRNZ, STREQ, STRNE, STRLT, STRGT, INTEQ, INTNE, INTGE, INTGT, INTLE, INTLT, UNOT, BAND, BOR, LPAREN, RPAREN, OPERAND }; enum token_types { UNOP, BINOP, BUNOP, BBINOP, PAREN }; struct t_op { const char *op_text; short op_num, op_type; } const ops [] = { {"-r", FILRD, UNOP}, {"-w", FILWR, UNOP}, {"-x", FILEX, UNOP}, {"-e", FILEXIST,UNOP}, {"-f", FILREG, UNOP}, {"-d", FILDIR, UNOP}, {"-c", FILCDEV,UNOP}, {"-b", FILBDEV,UNOP}, {"-p", FILFIFO,UNOP}, {"-u", FILSUID,UNOP}, {"-g", FILSGID,UNOP}, {"-k", FILSTCK,UNOP}, {"-s", FILGZ, UNOP}, {"-t", FILTT, UNOP}, {"-z", STREZ, UNOP}, {"-n", STRNZ, UNOP}, {"-h", FILSYM, UNOP}, /* for backwards compat */ {"-O", FILUID, UNOP}, {"-G", FILGID, UNOP}, {"-L", FILSYM, UNOP}, {"-S", FILSOCK,UNOP}, {"=", STREQ, BINOP}, {"!=", STRNE, BINOP}, {"<", STRLT, BINOP}, {">", STRGT, BINOP}, {"-eq", INTEQ, BINOP}, {"-ne", INTNE, BINOP}, {"-ge", INTGE, BINOP}, {"-gt", INTGT, BINOP}, {"-le", INTLE, BINOP}, {"-lt", INTLT, BINOP}, {"-nt", FILNT, BINOP}, {"-ot", FILOT, BINOP}, {"-ef", FILEQ, BINOP}, {"!", UNOT, BUNOP}, {"-a", BAND, BBINOP}, {"-o", BOR, BBINOP}, {"(", LPAREN, PAREN}, {")", RPAREN, PAREN}, {0, 0, 0} }; struct t_op const *t_wp_op; int nargc; char **t_wp; +int parenlevel; static int aexpr(enum token); static int binop(void); static int equalf(const char *, const char *); static int filstat(char *, enum token); static int getn(const char *); static intmax_t getq(const char *); static int intcmp(const char *, const char *); -static int isoperand(void); +static int isunopoperand(void); +static int islparenoperand(void); +static int isrparenoperand(void); static int newerf(const char *, const char *); static int nexpr(enum token); static int oexpr(enum token); static int olderf(const char *, const char *); static int primary(enum token); static void syntax(const char *, const char *); static enum token t_lex(char *); int main(int argc, char **argv) { int res; char *p; if ((p = rindex(argv[0], '/')) == NULL) p = argv[0]; else p++; if (strcmp(p, "[") == 0) { if (strcmp(argv[--argc], "]") != 0) error("missing ]"); argv[argc] = NULL; } /* no expression => false */ if (--argc <= 0) return 1; #ifndef SHELL (void)setlocale(LC_CTYPE, ""); #endif nargc = argc; t_wp = &argv[1]; - res = !oexpr(t_lex(*t_wp)); + parenlevel = 0; + if (nargc == 4 && strcmp(*t_wp, "!") == 0) { + /* Things like ! "" -o x do not fit in the normal grammar. */ + --nargc; + ++t_wp; + res = oexpr(t_lex(*t_wp)); + } else + res = !oexpr(t_lex(*t_wp)); if (--nargc > 0) syntax(*t_wp, "unexpected operator"); return res; } static void syntax(const char *op, const char *msg) { if (op && *op) error("%s: %s", op, msg); else error("%s", msg); } static int oexpr(enum token n) { int res; res = aexpr(n); if (t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL) == BOR) return oexpr(t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL)) || res; t_wp--; nargc++; return res; } static int aexpr(enum token n) { int res; res = nexpr(n); if (t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL) == BAND) return aexpr(t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL)) && res; t_wp--; nargc++; return res; } static int nexpr(enum token n) { if (n == UNOT) return !nexpr(t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL)); return primary(n); } static int primary(enum token n) { enum token nn; int res; if (n == EOI) return 0; /* missing expression */ if (n == LPAREN) { + parenlevel++; if ((nn = t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL)) == - RPAREN) + RPAREN) { + parenlevel--; return 0; /* missing expression */ + } res = oexpr(nn); if (t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL) != RPAREN) syntax(NULL, "closing paren expected"); + parenlevel--; return res; } if (t_wp_op && t_wp_op->op_type == UNOP) { /* unary expression */ if (--nargc == 0) syntax(t_wp_op->op_text, "argument expected"); switch (n) { case STREZ: return strlen(*++t_wp) == 0; case STRNZ: return strlen(*++t_wp) != 0; case FILTT: return isatty(getn(*++t_wp)); default: return filstat(*++t_wp, n); } } if (t_lex(nargc > 0 ? t_wp[1] : NULL), t_wp_op && t_wp_op->op_type == BINOP) { return binop(); } return strlen(*t_wp) > 0; } static int binop(void) { const char *opnd1, *opnd2; struct t_op const *op; opnd1 = *t_wp; (void) t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL); op = t_wp_op; if ((opnd2 = nargc > 0 ? (--nargc, *++t_wp) : NULL) == NULL) syntax(op->op_text, "argument expected"); switch (op->op_num) { case STREQ: return strcmp(opnd1, opnd2) == 0; case STRNE: return strcmp(opnd1, opnd2) != 0; case STRLT: return strcmp(opnd1, opnd2) < 0; case STRGT: return strcmp(opnd1, opnd2) > 0; case INTEQ: return intcmp(opnd1, opnd2) == 0; case INTNE: return intcmp(opnd1, opnd2) != 0; case INTGE: return intcmp(opnd1, opnd2) >= 0; case INTGT: return intcmp(opnd1, opnd2) > 0; case INTLE: return intcmp(opnd1, opnd2) <= 0; case INTLT: return intcmp(opnd1, opnd2) < 0; case FILNT: return newerf (opnd1, opnd2); case FILOT: return olderf (opnd1, opnd2); case FILEQ: return equalf (opnd1, opnd2); default: abort(); /* NOTREACHED */ } } static int filstat(char *nm, enum token mode) { struct stat s; if (mode == FILSYM ? lstat(nm, &s) : stat(nm, &s)) return 0; switch (mode) { case FILRD: return (eaccess(nm, R_OK) == 0); case FILWR: return (eaccess(nm, W_OK) == 0); case FILEX: /* XXX work around eaccess(2) false positives for superuser */ if (eaccess(nm, X_OK) != 0) return 0; if (S_ISDIR(s.st_mode) || geteuid() != 0) return 1; return (s.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) != 0; case FILEXIST: return (eaccess(nm, F_OK) == 0); case FILREG: return S_ISREG(s.st_mode); case FILDIR: return S_ISDIR(s.st_mode); case FILCDEV: return S_ISCHR(s.st_mode); case FILBDEV: return S_ISBLK(s.st_mode); case FILFIFO: return S_ISFIFO(s.st_mode); case FILSOCK: return S_ISSOCK(s.st_mode); case FILSYM: return S_ISLNK(s.st_mode); case FILSUID: return (s.st_mode & S_ISUID) != 0; case FILSGID: return (s.st_mode & S_ISGID) != 0; case FILSTCK: return (s.st_mode & S_ISVTX) != 0; case FILGZ: return s.st_size > (off_t)0; case FILUID: return s.st_uid == geteuid(); case FILGID: return s.st_gid == getegid(); default: return 1; } } static enum token t_lex(char *s) { struct t_op const *op = ops; if (s == 0) { t_wp_op = NULL; return EOI; } while (op->op_text) { if (strcmp(s, op->op_text) == 0) { - if ((op->op_type == UNOP && isoperand()) || - (op->op_num == LPAREN && nargc == 1)) + if (((op->op_type == UNOP || op->op_type == BUNOP) + && isunopoperand()) || + (op->op_num == LPAREN && islparenoperand()) || + (op->op_num == RPAREN && isrparenoperand())) break; t_wp_op = op; return op->op_num; } op++; } t_wp_op = NULL; return OPERAND; } static int -isoperand(void) +isunopoperand(void) { struct t_op const *op = ops; char *s; char *t; if (nargc == 1) return 1; - if (nargc == 2) - return 0; s = *(t_wp + 1); + if (nargc == 2) + return parenlevel == 1 && strcmp(s, ")") == 0; t = *(t_wp + 2); while (op->op_text) { if (strcmp(s, op->op_text) == 0) return op->op_type == BINOP && - (t[0] != ')' || t[1] != '\0'); + (parenlevel == 0 || t[0] != ')' || t[1] != '\0'); op++; } + return 0; +} + +static int +islparenoperand(void) +{ + struct t_op const *op = ops; + char *s; + + if (nargc == 1) + return 1; + s = *(t_wp + 1); + if (nargc == 2) + return parenlevel == 1 && strcmp(s, ")") == 0; + if (nargc != 3) + return 0; + while (op->op_text) { + if (strcmp(s, op->op_text) == 0) + return op->op_type == BINOP; + op++; + } + return 0; +} + +static int +isrparenoperand(void) +{ + char *s; + + if (nargc == 1) + return 0; + s = *(t_wp + 1); + if (nargc == 2) + return parenlevel == 1 && strcmp(s, ")") == 0; return 0; } /* atoi with error detection */ static int getn(const char *s) { char *p; long r; errno = 0; r = strtol(s, &p, 10); if (s == p) error("%s: bad number", s); if (errno != 0) error((errno == EINVAL) ? "%s: bad number" : "%s: out of range", s); while (isspace((unsigned char)*p)) p++; if (*p) error("%s: bad number", s); return (int) r; } /* atoi with error detection and 64 bit range */ static intmax_t getq(const char *s) { char *p; intmax_t r; errno = 0; r = strtoimax(s, &p, 10); if (s == p) error("%s: bad number", s); if (errno != 0) error((errno == EINVAL) ? "%s: bad number" : "%s: out of range", s); while (isspace((unsigned char)*p)) p++; if (*p) error("%s: bad number", s); return r; } static int intcmp (const char *s1, const char *s2) { intmax_t q1, q2; q1 = getq(s1); q2 = getq(s2); if (q1 > q2) return 1; if (q1 < q2) return -1; return 0; } static int newerf (const char *f1, const char *f2) { struct stat b1, b2; if (stat(f1, &b1) != 0 || stat(f2, &b2) != 0) return 0; if (b1.st_mtimespec.tv_sec > b2.st_mtimespec.tv_sec) return 1; if (b1.st_mtimespec.tv_sec < b2.st_mtimespec.tv_sec) return 0; return (b1.st_mtimespec.tv_nsec > b2.st_mtimespec.tv_nsec); } static int olderf (const char *f1, const char *f2) { return (newerf(f2, f1)); } static int equalf (const char *f1, const char *f2) { struct stat b1, b2; return (stat (f1, &b1) == 0 && stat (f2, &b2) == 0 && b1.st_dev == b2.st_dev && b1.st_ino == b2.st_ino); }