X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=coreutils%2Ftest.c;h=7b8b10cd9736eb58ee676c5647835df805c18e82;hb=d1ed3e68b8080161642cc106099c0a17ac7892e6;hp=270ca21a938faec8e81382fdf1f30b1a6c2ef791;hpb=77ad97f199f1bf05e9a7609bbdd239dab825b258;p=oweals%2Fbusybox.git diff --git a/coreutils/test.c b/coreutils/test.c index 270ca21a9..7b8b10cd9 100644 --- a/coreutils/test.c +++ b/coreutils/test.c @@ -12,28 +12,64 @@ * modified by Herbert Xu to be used as built-in in ash. * modified by Erik Andersen to be used * in busybox. - * modified by Bernhard Fischer to be useable (i.e. a bit less bloaty). + * modified by Bernhard Reutner-Fischer to be useable (i.e. a bit less bloaty). * - * Licensed under GPLv2 or later, see file LICENSE in this tarball for details. + * Licensed under GPLv2 or later, see file LICENSE in this source tree. * * Original copyright notice states: * "This program is in the Public Domain." */ +//kbuild:lib-$(CONFIG_TEST) += test.o test_ptr_hack.o +//kbuild:lib-$(CONFIG_ASH) += test.o test_ptr_hack.o +//kbuild:lib-$(CONFIG_HUSH) += test.o test_ptr_hack.o + +//config:config TEST +//config: bool "test" +//config: default y +//config: help +//config: test is used to check file types and compare values, +//config: returning an appropriate exit code. The bash shell +//config: has test built in, ash can build it in optionally. +//config: +//config:config FEATURE_TEST_64 +//config: bool "Extend test to 64 bit" +//config: default y +//config: depends on TEST || ASH_BUILTIN_TEST || HUSH +//config: help +//config: Enable 64-bit support in test. + +/* "test --help" is special-cased to ignore --help */ +//usage:#define test_trivial_usage NOUSAGE_STR +//usage:#define test_full_usage "" +//usage: +//usage:#define test_example_usage +//usage: "$ test 1 -eq 2\n" +//usage: "$ echo $?\n" +//usage: "1\n" +//usage: "$ test 1 -eq 1\n" +//usage: "$ echo $?\n" +//usage: "0\n" +//usage: "$ [ -d /etc ]\n" +//usage: "$ echo $?\n" +//usage: "0\n" +//usage: "$ [ -d /junk ]\n" +//usage: "$ echo $?\n" +//usage: "1\n" + #include "libbb.h" #include /* This is a NOFORK applet. Be very careful! */ /* test_main() is called from shells, and we need to be extra careful here. - * This is true regardless of PREFER_APPLETS and STANDALONE_SHELL + * This is true regardless of PREFER_APPLETS and SH_STANDALONE * state. */ - /* test(1) accepts the following grammar: - oexpr ::= aexpr | aexpr "-o" oexpr ; - aexpr ::= nexpr | nexpr "-a" aexpr ; - nexpr ::= primary | "!" primary + oexpr ::= aexpr | aexpr "-o" oexpr ; + aexpr ::= nexpr | nexpr "-a" aexpr ; + nexpr ::= primary | "!" primary primary ::= unary-operator operand | operand binary-operator operand | operand @@ -47,41 +83,97 @@ operand ::= */ +/* TODO: handle [[ expr ]] bashism bash-compatibly. + * [[ ]] is meant to be a "better [ ]", with less weird syntax + * and without the risk of variables and quoted strings misinterpreted + * as operators. + * This will require support from shells - we need to know quote status + * of each parameter (see below). + * + * Word splitting and pathname expansion should NOT be performed: + * # a="a b"; [[ $a = "a b" ]] && echo YES + * YES + * # [[ /bin/m* ]] && echo YES + * YES + * + * =~ should do regexp match + * = and == should do pattern match against right side: + * # [[ *a* == bab ]] && echo YES + * # [[ bab == *a* ]] && echo YES + * YES + * != does the negated == (i.e., also with pattern matching). + * Pattern matching is quotation-sensitive: + * # [[ bab == "b"a* ]] && echo YES + * YES + * # [[ bab == b"a*" ]] && echo YES + * + * Conditional operators such as -f must be unquoted literals to be recognized: + * # [[ -e /bin ]] && echo YES + * YES + * # [[ '-e' /bin ]] && echo YES + * bash: conditional binary operator expected... + * # A='-e'; [[ $A /bin ]] && echo YES + * bash: conditional binary operator expected... + * + * || and && should work as -o and -a work in [ ] + * -a and -o aren't recognized (&& and || are to be used instead) + * ( and ) do not need to be quoted unlike in [ ]: + * # [[ ( abc ) && '' ]] && echo YES + * # [[ ( abc ) || '' ]] && echo YES + * YES + * # [[ ( abc ) -o '' ]] && echo YES + * bash: syntax error in conditional expression... + * + * Apart from the above, [[ expr ]] should work as [ expr ] + */ + +#define TEST_DEBUG 0 + enum token { EOI, - FILRD, + + FILRD, /* file access */ FILWR, FILEX, + FILEXIST, - FILREG, + + FILREG, /* file type */ FILDIR, FILCDEV, FILBDEV, FILFIFO, FILSOCK, + FILSYM, FILGZ, FILTT, - FILSUID, + + FILSUID, /* file bit */ FILSGID, FILSTCK, - FILNT, + + FILNT, /* file ops */ FILOT, FILEQ, + FILUID, FILGID, - STREZ, + + STREZ, /* str ops */ STRNZ, STREQ, STRNE, STRLT, STRGT, - INTEQ, + + INTEQ, /* int ops */ INTNE, INTGE, INTGT, INTLE, INTLT, + UNOT, BAND, BOR, @@ -95,7 +187,80 @@ enum token { #define is_file_access(a) (((unsigned char)((a) - FILRD)) <= 2) #define is_file_type(a) (((unsigned char)((a) - FILREG)) <= 5) #define is_file_bit(a) (((unsigned char)((a) - FILSUID)) <= 2) -enum token_types { + +#if TEST_DEBUG +int depth; +#define nest_msg(...) do { \ + depth++; \ + fprintf(stderr, "%*s", depth*2, ""); \ + fprintf(stderr, __VA_ARGS__); \ +} while (0) +#define unnest_msg(...) do { \ + fprintf(stderr, "%*s", depth*2, ""); \ + fprintf(stderr, __VA_ARGS__); \ + depth--; \ +} while (0) +#define dbg_msg(...) do { \ + fprintf(stderr, "%*s", depth*2, ""); \ + fprintf(stderr, __VA_ARGS__); \ +} while (0) +#define unnest_msg_and_return(expr, ...) do { \ + number_t __res = (expr); \ + fprintf(stderr, "%*s", depth*2, ""); \ + fprintf(stderr, __VA_ARGS__, res); \ + depth--; \ + return __res; \ +} while (0) +static const char *const TOKSTR[] = { + "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" +}; +#else +#define nest_msg(...) ((void)0) +#define unnest_msg(...) ((void)0) +#define dbg_msg(...) ((void)0) +#define unnest_msg_and_return(expr, ...) return expr +#endif + +enum { UNOP, BINOP, BUNOP, @@ -103,65 +268,112 @@ enum token_types { PAREN }; -static const struct t_op { - char op_text[4]; +struct operator_t { unsigned char op_num, op_type; -} 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 }, - { "==" , 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 }, }; +static const struct operator_t ops_table[] = { + { /* "-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 }, + { /* "==" */ 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 }, +}; +/* Please keep these two tables in sync */ +static const char ops_texts[] ALIGN1 = + "-r" "\0" + "-w" "\0" + "-x" "\0" + "-e" "\0" + "-f" "\0" + "-d" "\0" + "-c" "\0" + "-b" "\0" + "-p" "\0" + "-u" "\0" + "-g" "\0" + "-k" "\0" + "-s" "\0" + "-t" "\0" + "-z" "\0" + "-n" "\0" + "-h" "\0" + + "-O" "\0" + "-G" "\0" + "-L" "\0" + "-S" "\0" + "=" "\0" + "==" "\0" + "!=" "\0" + "<" "\0" + ">" "\0" + "-eq" "\0" + "-ne" "\0" + "-ge" "\0" + "-gt" "\0" + "-le" "\0" + "-lt" "\0" + "-nt" "\0" + "-ot" "\0" + "-ef" "\0" + "!" "\0" + "-a" "\0" + "-o" "\0" + "(" "\0" + ")" "\0" +; + #if ENABLE_FEATURE_TEST_64 -typedef int64_t arith_t; +typedef int64_t number_t; #else -typedef int arith_t; +typedef int number_t; #endif /* We try to minimize both static and stack usage. */ struct test_statics { - char **t_wp; - const struct t_op *t_wp_op; + char **args; + /* set only by check_operator(), either to bogus struct + * or points to matching operator_t struct. Never NULL. */ + const struct operator_t *last_operator; gid_t *group_array; int ngroups; jmp_buf leaving; @@ -171,8 +383,8 @@ struct test_statics { extern struct test_statics *const test_ptr_to_statics; #define S (*test_ptr_to_statics) -#define t_wp (S.t_wp ) -#define t_wp_op (S.t_wp_op ) +#define args (S.args ) +#define last_operator (S.last_operator) #define group_array (S.group_array ) #define ngroups (S.ngroups ) #define leaving (S.leaving ) @@ -185,9 +397,9 @@ extern struct test_statics *const test_ptr_to_statics; free(test_ptr_to_statics); \ } while (0) -static arith_t primary(enum token n); +static number_t primary(enum token n); -static void syntax(const char *op, const char *msg) ATTRIBUTE_NORETURN; +static void syntax(const char *op, const char *msg) NORETURN; static void syntax(const char *op, const char *msg) { if (op && *op) { @@ -200,7 +412,7 @@ static void syntax(const char *op, const char *msg) /* atoi with error detection */ //XXX: FIXME: duplicate of existing libbb function? -static arith_t getn(const char *s) +static number_t getn(const char *s) { char *p; #if ENABLE_FEATURE_TEST_64 @@ -219,7 +431,7 @@ static arith_t getn(const char *s) if (errno != 0) syntax(s, "out of range"); - if (*(skip_whitespace(p))) + if (p == s || *(skip_whitespace(p)) != '\0') syntax(s, "bad number"); return r; @@ -253,41 +465,38 @@ static int equalf(const char *f1, const char *f2) */ -static enum token t_lex(char *s) +static enum token check_operator(const char *s) { - const struct t_op *op; - - t_wp_op = NULL; - if (s == NULL) { + static const struct operator_t no_op = { + .op_num = -1, + .op_type = -1 + }; + int n; + + last_operator = &no_op; + if (s == NULL) return EOI; - } - - op = ops; - do { - if (strcmp(s, op->op_text) == 0) { - t_wp_op = op; - return op->op_num; - } - op++; - } while (op < ops + ARRAY_SIZE(ops)); - - return OPERAND; + n = index_in_strings(ops_texts, s); + if (n < 0) + return OPERAND; + last_operator = &ops_table[n]; + return ops_table[n].op_num; } static int binop(void) { const char *opnd1, *opnd2; - struct t_op const *op; - arith_t val1, val2; + const struct operator_t *op; + number_t val1, val2; - opnd1 = *t_wp; - (void) t_lex(*++t_wp); - op = t_wp_op; + opnd1 = *args; + check_operator(*++args); + op = last_operator; - opnd2 = *++t_wp; + opnd2 = *++args; if (opnd2 == NULL) - syntax(op->op_text, "argument expected"); + syntax(args[-1], "argument expected"); if (is_int_op(op->op_num)) { val1 = getn(opnd1); @@ -302,8 +511,8 @@ static int binop(void) return val1 > val2; if (op->op_num == INTLE) return val1 <= val2; - if (op->op_num == INTLT) - return val1 < val2; + /*if (op->op_num == INTLT)*/ + return val1 < val2; } if (is_str_op(op->op_num)) { val1 = strcmp(opnd1, opnd2); @@ -313,8 +522,8 @@ static int binop(void) return val1 != 0; if (op->op_num == STRLT) return val1 < 0; - if (op->op_num == STRGT) - return val1 > 0; + /*if (op->op_num == STRGT)*/ + return val1 > 0; } /* We are sure that these three are by now the only binops we didn't check * yet, so we do not check if the class is correct: @@ -329,25 +538,29 @@ static int binop(void) return b1.st_mtime > b2.st_mtime; if (op->op_num == FILOT) return b1.st_mtime < b2.st_mtime; - if (op->op_num == FILEQ) - return b1.st_dev == b2.st_dev && b1.st_ino == b2.st_ino; + /*if (op->op_num == FILEQ)*/ + return b1.st_dev == b2.st_dev && b1.st_ino == b2.st_ino; } - return 1; /* NOTREACHED */ + /*return 1; - NOTREACHED */ } static void initialize_group_array(void) { - ngroups = getgroups(0, NULL); - if (ngroups > 0) { + int n; + + /* getgroups may be expensive, try to use it only once */ + ngroups = 32; + do { /* FIXME: ash tries so hard to not die on OOM, * and we spoil it with just one xrealloc here */ /* We realloc, because test_main can be entered repeatedly by shell. * Testcase (ash): 'while true; do test -x some_file; done' * and watch top. (some_file must have owner != you) */ - group_array = xrealloc(group_array, ngroups * sizeof(gid_t)); - getgroups(ngroups, group_array); - } + n = ngroups; + group_array = xrealloc(group_array, n * sizeof(gid_t)); + ngroups = getgroups(n, group_array); + } while (ngroups > n); } @@ -392,7 +605,7 @@ static int test_eaccess(char *path, int mode) return 0; /* Root can execute any file that has any one of the execute - bits set. */ + * bits set. */ if (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) return 0; } @@ -482,72 +695,125 @@ static int filstat(char *nm, enum token mode) } -static arith_t nexpr(enum token n) +static number_t nexpr(enum token n) { - if (n == UNOT) - return !nexpr(t_lex(*++t_wp)); - return primary(n); + number_t res; + + nest_msg(">nexpr(%s)\n", TOKSTR[n]); + if (n == UNOT) { + n = check_operator(*++args); + if (n == EOI) { + /* special case: [ ! ], [ a -a ! ] are valid */ + /* IOW, "! ARG" may miss ARG */ + args--; + unnest_msg("aexpr(%s)\n", TOKSTR[n]); res = nexpr(n); - if (t_lex(*++t_wp) == BAND) - return aexpr(t_lex(*++t_wp)) && res; - t_wp--; + dbg_msg("aexpr: nexpr:%lld, next args:%s(%p)\n", res, args[1], &args[1]); + if (check_operator(*++args) == BAND) { + dbg_msg("aexpr: arg is AND, next args:%s(%p)\n", args[1], &args[1]); + res = aexpr(check_operator(*++args)) && res; + unnest_msg("oexpr(%s)\n", TOKSTR[n]); res = aexpr(n); - if (t_lex(*++t_wp) == BOR) { - return oexpr(t_lex(*++t_wp)) || res; + dbg_msg("oexpr: aexpr:%lld, next args:%s(%p)\n", res, args[1], &args[1]); + if (check_operator(*++args) == BOR) { + dbg_msg("oexpr: next arg is OR, next args:%s(%p)\n", args[1], &args[1]); + res = oexpr(check_operator(*++args)) || res; + unnest_msg("primary(%s)\n", TOKSTR[n]); if (n == EOI) { syntax(NULL, "argument expected"); } if (n == LPAREN) { - res = oexpr(t_lex(*++t_wp)); - if (t_lex(*++t_wp) != RPAREN) + res = oexpr(check_operator(*++args)); + if (check_operator(*++args) != RPAREN) syntax(NULL, "closing paren expected"); + unnest_msg("op_type == UNOP) { + + /* coreutils 6.9 checks "is args[1] binop and args[2] exist?" first, + * do the same */ + args0_op = last_operator; + /* last_operator = operator at args[1] */ + if (check_operator(args[1]) != EOI) { /* if args[1] != NULL */ + if (args[2]) { + // coreutils also does this: + // if (args[3] && args[0]="-l" && args[2] is BINOP) + // return binop(1 /* prepended by -l */); + if (last_operator->op_type == BINOP) + unnest_msg_and_return(binop(), "op_type == UNOP) { /* unary expression */ - if (*++t_wp == NULL) - syntax(t_wp_op->op_text, "argument expected"); + if (args[1] == NULL) +// syntax(args0_op->op_text, "argument expected"); + goto check_emptiness; + args++; if (n == STREZ) - return t_wp[0][0] == '\0'; + unnest_msg_and_return(args[0][0] == '\0', "op_type == BINOP) { - return binop(); + /*check_operator(args[1]); - already done */ + if (last_operator->op_type == BINOP) { + /* args[2] is known to be NULL, isn't it bound to fail? */ + unnest_msg_and_return(binop(), "op_type == BINOP) { - /* "test [!] arg1 arg2" */ - t_wp = &argv[0]; - res = (binop() == 0); - goto ret; + /* Implement special cases from POSIX.2, section 4.62.4. + * Testcase: "test '(' = '('" + * The general parser would misinterpret '(' as group start. + */ + if (1) { + int negate = 0; + again: + if (!argv[0]) { + /* "test" */ + res = 1; + goto ret_special; + } + if (!argv[1]) { + /* "test [!] arg" */ + res = (argv[0][0] == '\0'); + goto ret_special; + } + if (argv[2] && !argv[3]) { + check_operator(argv[1]); + if (last_operator->op_type == BINOP) { + /* "test [!] arg1 arg2" */ + args = argv; + res = (binop() == 0); + ret_special: + /* If there was leading "!" op... */ + res ^= negate; + goto ret; + } + } + if (LONE_CHAR(argv[0], '!')) { + argv++; + negate ^= 1; + goto again; } } - /* Some complex expression. Undo '!' removal */ - if (negate) { - negate = 0; - //argc++; - argv--; - } - t_wp = &argv[0]; - res = !oexpr(t_lex(*t_wp)); + res = !oexpr(check_operator(*args)); - if (*t_wp != NULL && *++t_wp != NULL) { - bb_error_msg("%s: unknown operand", *t_wp); + if (*args != NULL && *++args != NULL) { + /* Examples: + * test 3 -lt 5 6 + * test -t 1 2 + */ + bb_error_msg("%s: unknown operand", *args); res = 2; } ret: DEINIT_S(); - return negate ? !res : res; + return res; }