X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=coreutils%2Ftest.c;h=7b8b10cd9736eb58ee676c5647835df805c18e82;hb=d1ed3e68b8080161642cc106099c0a17ac7892e6;hp=cfaf4ca5dbb4ce9cba9f0b2aac319aa84c232b0d;hpb=16635cc2e052897ce7c2d4989acd0b706c3ac3dd;p=oweals%2Fbusybox.git diff --git a/coreutils/test.c b/coreutils/test.c index cfaf4ca5d..7b8b10cd9 100644 --- a/coreutils/test.c +++ b/coreutils/test.c @@ -14,26 +14,62 @@ * in busybox. * 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,6 +83,50 @@ 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 { @@ -180,7 +260,7 @@ static const char *const TOKSTR[] = { #define unnest_msg_and_return(expr, ...) return expr #endif -enum token_types { +enum { UNOP, BINOP, BUNOP, @@ -189,53 +269,96 @@ enum token_types { }; struct operator_t { - char op_text[4]; unsigned char op_num, op_type; }; -static const struct operator_t 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 @@ -308,7 +431,7 @@ static number_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; @@ -342,29 +465,22 @@ static int equalf(const char *f1, const char *f2) */ -static enum token check_operator(char *s) +static enum token check_operator(const char *s) { static const struct operator_t no_op = { .op_num = -1, .op_type = -1 }; - const struct operator_t *op; + int n; last_operator = &no_op; - if (s == NULL) { + if (s == NULL) return EOI; - } - - op = ops; - do { - if (strcmp(s, op->op_text) == 0) { - last_operator = 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; } @@ -380,7 +496,7 @@ static int binop(void) 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); @@ -489,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; } @@ -585,7 +701,15 @@ static number_t nexpr(enum token n) nest_msg(">nexpr(%s)\n", TOKSTR[n]); if (n == UNOT) { - res = !nexpr(check_operator(*++args)); + 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); - dbg_msg("aexpr: nexpr:%lld, next args:%s\n", res, args[1]); + 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\n", args[1]); + 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); - dbg_msg("oexpr: aexpr:%lld, next args:%s\n", res, args[1]); + 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\n", args[1]); + dbg_msg("oexpr: next arg is OR, next args:%s(%p)\n", args[1], &args[1]); res = oexpr(check_operator(*++args)) || res; unnest_msg("op_type == BINOP) { - /* "test [!] arg1 arg2" */ - args = &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--; - } -#endif - args = &argv[0]; res = !oexpr(check_operator(*args)); if (*args != NULL && *++args != NULL) { - /* TODO: example when this happens? */ + /* 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; }