bc: convert to "G trick" - this returns bc to zero bss increase

[oweals/busybox.git] / coreutils / test.c

diff --git a/coreutils/test.c b/coreutils/test.c
index d8ac42e228391226f38e4992d93cefb5b53b3273..ddb66ddcec1f17aba1c43207d7aa1fb868a2708f 100644 (file)
--- a/coreutils/test.c
+++ b/coreutils/test.c
@@ -76,7 +76,6 @@
 //usage:       "1\n"
 
 #include "libbb.h"
-#include <setjmp.h>
 
 /* This is a NOFORK applet. Be very careful! */
 
@@ -314,6 +313,9 @@ static const struct operator_t ops_table[] = {
        { /* "-L" */ FILSYM  , UNOP   },
        { /* "-S" */ FILSOCK , UNOP   },
        { /* "="  */ STREQ   , BINOP  },
+       /* "==" is bashism, http://pubs.opengroup.org/onlinepubs/9699919799/utilities/test.html
+        * lists only "=" as comparison operator.
+        */
        { /* "==" */ STREQ   , BINOP  },
        { /* "!=" */ STRNE   , BINOP  },
        { /* "<"  */ STRLT   , BINOP  },
@@ -358,6 +360,7 @@ static const char ops_texts[] ALIGN1 =
        "-L"  "\0"
        "-S"  "\0"
        "="   "\0"
+       /* "==" is bashism */
        "=="  "\0"
        "!="  "\0"
        "<"   "\0"
@@ -879,18 +882,48 @@ int test_main(int argc, char **argv)
                        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 <binary_op> arg2" */
-                               args = argv;
-                               res = (binop() == 0);
+               if (argv[2]) {
+                       if (!argv[3]) {
+                               /*
+                                * http://pubs.opengroup.org/onlinepubs/009695399/utilities/test.html
+                                * """ 3 arguments:
+                                * If $2 is a binary primary, perform the binary test of $1 and $3.
+                                * """
+                                */
+                               check_operator(argv[1]);
+                               if (last_operator->op_type == BINOP) {
+                                       /* "test [!] arg1 <binary_op> arg2" */
+                                       args = argv;
+                                       res = (binop() == 0);
  ret_special:
-                               /* If there was leading "!" op... */
-                               res ^= negate;
-                               goto ret;
+                                       /* If there was leading "!" op... */
+                                       res ^= negate;
+                                       goto ret;
+                               }
+                               /* """If $1 is '(' and $3 is ')', perform the unary test of $2."""
+                                * Looks like this works without additional coding.
+                                */
+                               goto check_negate;
+                       }
+                       /* argv[3] exists (at least 4 args), is it exactly 4 args? */
+                       if (!argv[4]) {
+                               /*
+                                * """ 4 arguments:
+                                * If $1 is '!', negate the three-argument test of $2, $3, and $4.
+                                * If $1 is '(' and $4 is ')', perform the two-argument test of $2 and $3.
+                                * """
+                                * Example why code below is necessary: test '(' ! -e ')'
+                                */
+                               if (LONE_CHAR(argv[0], '(')
+                                && LONE_CHAR(argv[3], ')')
+                               ) {
+                                       /* "test [!] ( x y )" */
+                                       argv[3] = NULL;
+                                       argv++;
+                               }
                        }
                }
+ check_negate:
                if (LONE_CHAR(argv[0], '!')) {
                        argv++;
                        negate ^= 1;