src/test.c

   1 /* GNU test program (ksb and mjb) */
   2
   3 /* Modified to run with the GNU shell by bfox. */
   4
   5 /* Copyright (C) 1987-2005 Free Software Foundation, Inc.
   6
   7    This file is part of GNU Bash, the Bourne Again SHell.
   8
   9    Bash is free software; you can redistribute it and/or modify it under
  10    the terms of the GNU General Public License as published by the Free
  11    Software Foundation; either version 2, or (at your option) any later
  12    version.
  13
  14    Bash is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17    for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software Foundation,
  21    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  22
  23 /* Define TEST_STANDALONE to get the /bin/test version.  Otherwise, you get
  24    the shell builtin version. */
  25
  26 #include <config.h>
  27 #include <stdio.h>
  28 #include <sys/types.h>
  29
  30 #define TEST_STANDALONE 1
  31
  32 #ifndef LBRACKET
  33 # define LBRACKET 0
  34 #endif
  35
  36 /* The official name of this program (e.g., no `g' prefix).  */
  37 #if LBRACKET
  38 # define PROGRAM_NAME "["
  39 #else
  40 # define PROGRAM_NAME "test"
  41 #endif
  42
  43 #include "system.h"
  44 #include "error.h"
  45 #include "euidaccess.h"
  46 #include "quote.h"
  47
  48 #ifndef _POSIX_VERSION
  49 # include <sys/param.h>
  50 #endif /* _POSIX_VERSION */
  51 #define whitespace(c) (((c) == ' ') || ((c) == '\t'))
  52 #define digit(c)  ((c) >= '0' && (c) <= '9')
  53 #define digit_value(c) ((c) - '0')
  54
  55 char *program_name;
  56
  57 #if !defined (_POSIX_VERSION)
  58 # include <sys/file.h>
  59 #endif /* !_POSIX_VERSION */
  60
  61 extern gid_t getegid ();
  62 extern uid_t geteuid ();
  63
  64 /* Exit status for syntax errors, etc.  */
  65 enum { TEST_TRUE, TEST_FALSE, TEST_FAILURE };
  66
  67 #if defined (TEST_STANDALONE)
  68 # define test_exit(val) exit (val)
  69 #else
  70    static jmp_buf test_exit_buf;
  71    static int test_error_return = 0;
  72 # define test_exit(val) test_error_return = val, longjmp (test_exit_buf, 1)
  73 #endif /* !TEST_STANDALONE */
  74
  75 static int pos;         /* The offset of the current argument in ARGV. */
  76 static int argc;        /* The number of arguments present in ARGV. */
  77 static char **argv;     /* The argument list. */
  78
  79 static bool test_unop (char const *s);
  80 static bool unary_operator (void);
  81 static bool binary_operator (bool);
  82 static bool two_arguments (void);
  83 static bool three_arguments (void);
  84 static bool posixtest (int);
  85
  86 static bool expr (void);
  87 static bool term (void);
  88 static bool and (void);
  89 static bool or (void);
  90
  91 static void test_syntax_error (char const *format, char const *arg)
  92      ATTRIBUTE_NORETURN;
  93 static void beyond (void) ATTRIBUTE_NORETURN;
  94
  95 static void
  96 test_syntax_error (char const *format, char const *arg)
  97 {
  98   fprintf (stderr, "%s: ", argv[0]);
  99   fprintf (stderr, format, arg);
 100   fflush (stderr);
 101   test_exit (TEST_FAILURE);
 102 }
 103
 104 /* Increment our position in the argument list.  Check that we're not
 105    past the end of the argument list.  This check is supressed if the
 106    argument is false.  */
 107
 108 static inline void
 109 advance (bool f)
 110 {
 111   ++pos;
 112
 113   if (f && pos >= argc)
 114     beyond ();
 115 }
 116
 117 static inline void
 118 unary_advance (void)
 119 {
 120   advance (true);
 121   ++pos;
 122 }
 123
 124 /*
 125  * beyond - call when we're beyond the end of the argument list (an
 126  *      error condition)
 127  */
 128 static void
 129 beyond (void)
 130 {
 131   test_syntax_error (_("missing argument after %s"), quote (argv[argc - 1]));
 132 }
 133
 134 /* Syntax error for when an integer argument was expected, but
 135    something else was found. */
 136 static void
 137 integer_expected_error (char const *pch)
 138 {
 139   test_syntax_error (_("%s: integer expression expected\n"), pch);
 140 }
 141
 142 /* Return true if the characters pointed to by STRING constitute a
 143    valid number.  Stuff the converted number into RESULT if RESULT is
 144    not null.  */
 145 static bool
 146 is_int (char const *string, intmax_t *result)
 147 {
 148   int sign;
 149   intmax_t value;
 150   char const *orig_string;
 151
 152   sign = 1;
 153   value = 0;
 154
 155   if (result)
 156     *result = 0;
 157
 158   /* Skip leading whitespace characters. */
 159   while (whitespace (*string))
 160     string++;
 161
 162   if (!*string)
 163     return false;
 164
 165   /* Save a pointer to the start, for diagnostics.  */
 166   orig_string = string;
 167
 168   /* We allow leading `-' or `+'. */
 169   if (*string == '-' || *string == '+')
 170     {
 171       if (!digit (string[1]))
 172         return false;
 173
 174       if (*string == '-')
 175         sign = -1;
 176
 177       string++;
 178     }
 179
 180   while (digit (*string))
 181     {
 182       if (result)
 183         {
 184           intmax_t new_v = 10 * value + sign * (*string - '0');
 185           if (0 < sign
 186               ? (INTMAX_MAX / 10 < value || new_v < 0)
 187               : (value < INTMAX_MIN / 10 || 0 < new_v))
 188             test_syntax_error ((0 < sign
 189                                 ? _("integer is too large: %s\n")
 190                                 : _("integer is too small: %s\n")),
 191                                orig_string);
 192           value = new_v;
 193         }
 194       string++;
 195     }
 196
 197   /* Skip trailing whitespace, if any. */
 198   while (whitespace (*string))
 199     string++;
 200
 201   /* Error if not at end of string. */
 202   if (*string)
 203     return false;
 204
 205   if (result)
 206     *result = value;
 207
 208   return true;
 209 }
 210
 211 /* Find the modification time of FILE, and stuff it into *AGE.
 212    Return true if successful.  */
 213 static bool
 214 age_of (char const *filename, time_t *age)
 215 {
 216   struct stat finfo;
 217   bool ok = (stat (filename, &finfo) == 0);
 218   if (ok)
 219     *age = finfo.st_mtime;
 220   return ok;
 221 }
 222
 223 /* Return true if S is one of the test command's binary operators.  */
 224 static bool
 225 binop (char const *s)
 226 {
 227   return ((STREQ (s,   "=")) || (STREQ (s,  "!=")) || (STREQ (s, "-nt")) ||
 228           (STREQ (s, "-ot")) || (STREQ (s, "-ef")) || (STREQ (s, "-eq")) ||
 229           (STREQ (s, "-ne")) || (STREQ (s, "-lt")) || (STREQ (s, "-le")) ||
 230           (STREQ (s, "-gt")) || (STREQ (s, "-ge")));
 231 }
 232
 233 /*
 234  * term - parse a term and return 1 or 0 depending on whether the term
 235  *      evaluates to true or false, respectively.
 236  *
 237  * term ::=
 238  *      '-'('h'|'d'|'f'|'r'|'s'|'w'|'c'|'b'|'p'|'u'|'g'|'k') filename
 239  *      '-'('L'|'x') filename
 240  *      '-t' int
 241  *      '-'('z'|'n') string
 242  *      string
 243  *      string ('!='|'=') string
 244  *      <int> '-'(eq|ne|le|lt|ge|gt) <int>
 245  *      file '-'(nt|ot|ef) file
 246  *      '(' <expr> ')'
 247  * int ::=
 248  *      '-l' string
 249  *      positive and negative integers
 250  */
 251 static bool
 252 term (void)
 253 {
 254   bool value;
 255   bool negated = false;
 256
 257   /* Deal with leading `not's.  */
 258   while (pos < argc && argv[pos][0] == '!' && argv[pos][1] == '\0')
 259     {
 260       advance (true);
 261       negated = !negated;
 262     }
 263
 264   if (pos >= argc)
 265     beyond ();
 266
 267   /* A paren-bracketed argument. */
 268   if (argv[pos][0] == '(' && argv[pos][1] == '\0')
 269     {
 270       int nargs;
 271
 272       advance (true);
 273
 274       for (nargs = 1;
 275            pos + nargs < argc && ! STREQ (argv[pos + nargs], ")");
 276            nargs++)
 277         if (nargs == 4)
 278           {
 279             nargs = argc - pos;
 280             break;
 281           }
 282
 283       value = posixtest (nargs);
 284       if (argv[pos] == 0)
 285         test_syntax_error (_("')' expected\n"), NULL);
 286       else
 287         if (argv[pos][0] != ')' || argv[pos][1])
 288           test_syntax_error (_("')' expected, found %s\n"), argv[pos]);
 289       advance (false);
 290     }
 291
 292   /* Are there enough arguments left that this could be dyadic?  */
 293   else if (4 <= argc - pos && STREQ (argv[pos], "-l") && binop (argv[pos + 2]))
 294     value = binary_operator (true);
 295   else if (3 <= argc - pos && binop (argv[pos + 1]))
 296     value = binary_operator (false);
 297
 298   /* It might be a switch type argument.  */
 299   else if (argv[pos][0] == '-' && argv[pos][1] && argv[pos][2] == '\0')
 300     {
 301       if (test_unop (argv[pos]))
 302         value = unary_operator ();
 303       else
 304         test_syntax_error (_("%s: unary operator expected\n"), argv[pos]);
 305     }
 306   else
 307     {
 308       value = (argv[pos][0] != '\0');
 309       advance (false);
 310     }
 311
 312   return negated ^ value;
 313 }
 314
 315 static bool
 316 binary_operator (bool l_is_l)
 317 {
 318   int op;
 319   struct stat stat_buf, stat_spare;
 320   intmax_t l, r;
 321   /* Is the right integer expression of the form '-l string'? */
 322   bool r_is_l;
 323
 324   if (l_is_l)
 325     advance (false);
 326   op = pos + 1;
 327
 328   if ((op < argc - 2) && STREQ (argv[op + 1], "-l"))
 329     {
 330       r_is_l = true;
 331       advance (false);
 332     }
 333   else
 334     r_is_l = false;
 335
 336   if (argv[op][0] == '-')
 337     {
 338       /* check for eq, nt, and stuff */
 339       switch (argv[op][1])
 340         {
 341         default:
 342           break;
 343
 344         case 'l':
 345           if (argv[op][2] == 't' && !argv[op][3])
 346             {
 347               /* lt */
 348               if (l_is_l)
 349                 l = strlen (argv[op - 1]);
 350               else
 351                 {
 352                   if (!is_int (argv[op - 1], &l))
 353                     integer_expected_error (_("before -lt"));
 354                 }
 355
 356               if (r_is_l)
 357                 r = strlen (argv[op + 2]);
 358               else
 359                 {
 360                   if (!is_int (argv[op + 1], &r))
 361                     integer_expected_error (_("after -lt"));
 362                 }
 363               pos += 3;
 364               return l < r;
 365             }
 366
 367           if (argv[op][2] == 'e' && !argv[op][3])
 368             {
 369               /* le */
 370               if (l_is_l)
 371                 l = strlen (argv[op - 1]);
 372               else
 373                 {
 374                   if (!is_int (argv[op - 1], &l))
 375                     integer_expected_error (_("before -le"));
 376                 }
 377               if (r_is_l)
 378                 r = strlen (argv[op + 2]);
 379               else
 380                 {
 381                   if (!is_int (argv[op + 1], &r))
 382                     integer_expected_error (_("after -le"));
 383                 }
 384               pos += 3;
 385               return l <= r;
 386             }
 387           break;
 388
 389         case 'g':
 390           if (argv[op][2] == 't' && !argv[op][3])
 391             {
 392               /* gt integer greater than */
 393               if (l_is_l)
 394                 l = strlen (argv[op - 1]);
 395               else
 396                 {
 397                   if (!is_int (argv[op - 1], &l))
 398                     integer_expected_error (_("before -gt"));
 399                 }
 400               if (r_is_l)
 401                 r = strlen (argv[op + 2]);
 402               else
 403                 {
 404                   if (!is_int (argv[op + 1], &r))
 405                     integer_expected_error (_("after -gt"));
 406                 }
 407               pos += 3;
 408               return l > r;
 409             }
 410
 411           if (argv[op][2] == 'e' && !argv[op][3])
 412             {
 413               /* ge - integer greater than or equal to */
 414               if (l_is_l)
 415                 l = strlen (argv[op - 1]);
 416               else
 417                 {
 418                   if (!is_int (argv[op - 1], &l))
 419                     integer_expected_error (_("before -ge"));
 420                 }
 421               if (r_is_l)
 422                 r = strlen (argv[op + 2]);
 423               else
 424                 {
 425                   if (!is_int (argv[op + 1], &r))
 426                     integer_expected_error (_("after -ge"));
 427                 }
 428               pos += 3;
 429               return l >= r;
 430             }
 431           break;
 432
 433         case 'n':
 434           if (argv[op][2] == 't' && !argv[op][3])
 435             {
 436               /* nt - newer than */
 437               time_t lt, rt;
 438               bool le, re;
 439               pos += 3;
 440               if (l_is_l | r_is_l)
 441                 test_syntax_error (_("-nt does not accept -l\n"), NULL);
 442               le = age_of (argv[op - 1], &lt);
 443               re = age_of (argv[op + 1], &rt);
 444               return le > re || (le && lt > rt);
 445             }
 446
 447           if (argv[op][2] == 'e' && !argv[op][3])
 448             {
 449               /* ne - integer not equal */
 450               if (l_is_l)
 451                 l = strlen (argv[op - 1]);
 452               else
 453                 {
 454                   if (!is_int (argv[op - 1], &l))
 455                     integer_expected_error (_("before -ne"));
 456                 }
 457               if (r_is_l)
 458                 r = strlen (argv[op + 2]);
 459               else
 460                 {
 461                   if (!is_int (argv[op + 1], &r))
 462                     integer_expected_error (_("after -ne"));
 463                 }
 464               pos += 3;
 465               return l != r;
 466             }
 467           break;
 468
 469         case 'e':
 470           if (argv[op][2] == 'q' && !argv[op][3])
 471             {
 472               /* eq - integer equal */
 473               if (l_is_l)
 474                 l = strlen (argv[op - 1]);
 475               else
 476                 {
 477                   if (!is_int (argv[op - 1], &l))
 478                     integer_expected_error (_("before -eq"));
 479                 }
 480               if (r_is_l)
 481                 r = strlen (argv[op + 2]);
 482               else
 483                 {
 484                   if (!is_int (argv[op + 1], &r))
 485                     integer_expected_error (_("after -eq"));
 486                 }
 487               pos += 3;
 488               return l == r;
 489             }
 490
 491           if (argv[op][2] == 'f' && !argv[op][3])
 492             {
 493               /* ef - hard link? */
 494               pos += 3;
 495               if (l_is_l | r_is_l)
 496                 test_syntax_error (_("-ef does not accept -l\n"), NULL);
 497               return (stat (argv[op - 1], &stat_buf) == 0
 498                       && stat (argv[op + 1], &stat_spare) == 0
 499                       && stat_buf.st_dev == stat_spare.st_dev
 500                       && stat_buf.st_ino == stat_spare.st_ino);
 501             }
 502           break;
 503
 504         case 'o':
 505           if ('t' == argv[op][2] && '\000' == argv[op][3])
 506             {
 507               /* ot - older than */
 508               time_t lt, rt;
 509               bool le, re;
 510               pos += 3;
 511               if (l_is_l | r_is_l)
 512                 test_syntax_error (_("-ot does not accept -l\n"), NULL);
 513               le = age_of (argv[op - 1], &lt);
 514               re = age_of (argv[op + 1], &rt);
 515               return le < re || (re && lt < rt);
 516             }
 517           break;
 518         }
 519
 520       /* FIXME: is this dead code? */
 521       test_syntax_error (_("unknown binary operator\n"), argv[op]);
 522     }
 523
 524   if (argv[op][0] == '=' && !argv[op][1])
 525     {
 526       bool value = STREQ (argv[pos], argv[pos + 2]);
 527       pos += 3;
 528       return value;
 529     }
 530
 531   if (STREQ (argv[op], "!="))
 532     {
 533       bool value = !STREQ (argv[pos], argv[pos + 2]);
 534       pos += 3;
 535       return value;
 536     }
 537
 538   /* Not reached.  */
 539   abort ();
 540 }
 541
 542 static bool
 543 unary_operator (void)
 544 {
 545   struct stat stat_buf;
 546
 547   switch (argv[pos][1])
 548     {
 549     default:
 550       return false;
 551
 552       /* All of the following unary operators use unary_advance (), which
 553          checks to make sure that there is an argument, and then advances
 554          pos right past it.  This means that pos - 1 is the location of the
 555          argument. */
 556
 557     case 'a':                   /* file exists in the file system? */
 558     case 'e':
 559       unary_advance ();
 560       return stat (argv[pos - 1], &stat_buf) == 0;
 561
 562     case 'r':                   /* file is readable? */
 563       unary_advance ();
 564       return euidaccess (argv[pos - 1], R_OK) == 0;
 565
 566     case 'w':                   /* File is writable? */
 567       unary_advance ();
 568       return euidaccess (argv[pos - 1], W_OK) == 0;
 569
 570     case 'x':                   /* File is executable? */
 571       unary_advance ();
 572       return euidaccess (argv[pos - 1], X_OK) == 0;
 573
 574     case 'O':                   /* File is owned by you? */
 575       unary_advance ();
 576       return (stat (argv[pos - 1], &stat_buf) == 0
 577               && (geteuid () == stat_buf.st_uid));
 578
 579     case 'G':                   /* File is owned by your group? */
 580       unary_advance ();
 581       return (stat (argv[pos - 1], &stat_buf) == 0
 582               && (getegid () == stat_buf.st_gid));
 583
 584     case 'f':                   /* File is a file? */
 585       unary_advance ();
 586       /* Under POSIX, -f is true if the given file exists
 587          and is a regular file. */
 588       return (stat (argv[pos - 1], &stat_buf) == 0
 589               && S_ISREG (stat_buf.st_mode));
 590
 591     case 'd':                   /* File is a directory? */
 592       unary_advance ();
 593       return (stat (argv[pos - 1], &stat_buf) == 0
 594               && S_ISDIR (stat_buf.st_mode));
 595
 596     case 's':                   /* File has something in it? */
 597       unary_advance ();
 598       return (stat (argv[pos - 1], &stat_buf) == 0
 599               && 0 < stat_buf.st_size);
 600
 601     case 'S':                   /* File is a socket? */
 602       unary_advance ();
 603       return (stat (argv[pos - 1], &stat_buf) == 0
 604               && S_ISSOCK (stat_buf.st_mode));
 605
 606     case 'c':                   /* File is character special? */
 607       unary_advance ();
 608       return (stat (argv[pos - 1], &stat_buf) == 0
 609               && S_ISCHR (stat_buf.st_mode));
 610
 611     case 'b':                   /* File is block special? */
 612       unary_advance ();
 613       return (stat (argv[pos - 1], &stat_buf) == 0
 614               && S_ISBLK (stat_buf.st_mode));
 615
 616     case 'p':                   /* File is a named pipe? */
 617       unary_advance ();
 618       return (stat (argv[pos - 1], &stat_buf) == 0
 619               && S_ISFIFO (stat_buf.st_mode));
 620
 621     case 'L':                   /* Same as -h  */
 622       /*FALLTHROUGH*/
 623
 624     case 'h':                   /* File is a symbolic link? */
 625       unary_advance ();
 626       return (lstat (argv[pos - 1], &stat_buf) == 0
 627               && S_ISLNK (stat_buf.st_mode));
 628
 629     case 'u':                   /* File is setuid? */
 630       unary_advance ();
 631       return (stat (argv[pos - 1], &stat_buf) == 0
 632               && (stat_buf.st_mode & S_ISUID));
 633
 634     case 'g':                   /* File is setgid? */
 635       unary_advance ();
 636       return (stat (argv[pos - 1], &stat_buf) == 0
 637               && (stat_buf.st_mode & S_ISGID));
 638
 639     case 'k':                   /* File has sticky bit set? */
 640       unary_advance ();
 641       return (stat (argv[pos - 1], &stat_buf) == 0
 642               && (stat_buf.st_mode & S_ISVTX));
 643
 644     case 't':                   /* File (fd) is a terminal? */
 645       {
 646         intmax_t fd;
 647         unary_advance ();
 648         if (!is_int (argv[pos - 1], &fd))
 649           integer_expected_error (_("after -t"));
 650         return INT_MIN <= fd && fd <= INT_MAX && isatty (fd);
 651       }
 652
 653     case 'n':                   /* True if arg has some length. */
 654       unary_advance ();
 655       return argv[pos - 1][0] != 0;
 656
 657     case 'z':                   /* True if arg has no length. */
 658       unary_advance ();
 659       return argv[pos - 1][0] == '\0';
 660     }
 661 }
 662
 663 /*
 664  * and:
 665  *      term
 666  *      term '-a' and
 667  */
 668 static bool
 669 and (void)
 670 {
 671   bool value = true;
 672
 673   for (;;)
 674     {
 675       value &= term ();
 676       if (! (pos < argc && STREQ (argv[pos], "-a")))
 677         return value;
 678       advance (false);
 679     }
 680 }
 681
 682 /*
 683  * or:
 684  *      and
 685  *      and '-o' or
 686  */
 687 static bool
 688 or (void)
 689 {
 690   bool value = false;
 691
 692   for (;;)
 693     {
 694       value |= and ();
 695       if (! (pos < argc && STREQ (argv[pos], "-o")))
 696         return value;
 697       advance (false);
 698     }
 699 }
 700
 701 /*
 702  * expr:
 703  *      or
 704  */
 705 static bool
 706 expr (void)
 707 {
 708   if (pos >= argc)
 709     beyond ();
 710
 711   return or ();         /* Same with this. */
 712 }
 713
 714 /* Return true if OP is one of the test command's unary operators. */
 715 static bool
 716 test_unop (char const *op)
 717 {
 718   if (op[0] != '-')
 719     return false;
 720
 721   switch (op[1])
 722     {
 723     case 'a': case 'b': case 'c': case 'd': case 'e':
 724     case 'f': case 'g': case 'h': case 'k': case 'n':
 725     case 'o': case 'p': case 'r': case 's': case 't':
 726     case 'u': case 'w': case 'x': case 'z':
 727     case 'G': case 'L': case 'O': case 'S': case 'N':
 728       return true;
 729     }
 730
 731   return false;
 732 }
 733
 734 static bool
 735 one_argument (void)
 736 {
 737   return argv[pos++][0] != '\0';
 738 }
 739
 740 static bool
 741 two_arguments (void)
 742 {
 743   bool value;
 744
 745   if (STREQ (argv[pos], "!"))
 746     {
 747       advance (false);
 748       value = ! one_argument ();
 749     }
 750   else if (argv[pos][0] == '-'
 751            && argv[pos][1] != '\0'
 752            && argv[pos][2] == '\0')
 753     {
 754       if (test_unop (argv[pos]))
 755         value = unary_operator ();
 756       else
 757         test_syntax_error (_("%s: unary operator expected\n"), argv[pos]);
 758     }
 759   else
 760     beyond ();
 761   return (value);
 762 }
 763
 764 static bool
 765 three_arguments (void)
 766 {
 767   bool value;
 768
 769   if (binop (argv[pos + 1]))
 770     value = binary_operator (false);
 771   else if (STREQ (argv[pos], "!"))
 772     {
 773       advance (true);
 774       value = !two_arguments ();
 775     }
 776   else if (STREQ (argv[pos], "(") && STREQ (argv[pos + 2], ")"))
 777     {
 778       advance (false);
 779       value = one_argument ();
 780       advance (false);
 781     }
 782   else if (STREQ (argv[pos + 1], "-a") || STREQ (argv[pos + 1], "-o"))
 783     value = expr ();
 784   else
 785     test_syntax_error (_("%s: binary operator expected\n"), argv[pos+1]);
 786   return (value);
 787 }
 788
 789 /* This is an implementation of a Posix.2 proposal by David Korn. */
 790 static bool
 791 posixtest (int nargs)
 792 {
 793   bool value;
 794
 795   switch (nargs)
 796     {
 797       case 1:
 798         value = one_argument ();
 799         break;
 800
 801       case 2:
 802         value = two_arguments ();
 803         break;
 804
 805       case 3:
 806         value = three_arguments ();
 807         break;
 808
 809       case 4:
 810         if (STREQ (argv[pos], "!"))
 811           {
 812             advance (true);
 813             value = !three_arguments ();
 814             break;
 815           }
 816         if (STREQ (argv[pos], "(") && STREQ (argv[pos + 3], ")"))
 817           {
 818             advance (false);
 819             value = two_arguments ();
 820             advance (false);
 821             break;
 822           }
 823         /* FALLTHROUGH */
 824       case 5:
 825       default:
 826         if (nargs <= 0)
 827           abort ();
 828         value = expr ();
 829     }
 830
 831   return (value);
 832 }
 833
 834 #if defined (TEST_STANDALONE)
 835 # include "long-options.h"
 836
 837 void
 838 usage (int status)
 839 {
 840   if (status != EXIT_SUCCESS)
 841     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 842              program_name);
 843   else
 844     {
 845       fputs (_("\
 846 Usage: test EXPRESSION\n\
 847   or:  test\n\
 848   or:  [ EXPRESSION ]\n\
 849   or:  [ ]\n\
 850   or:  [ OPTION\n\
 851 "), stdout);
 852       fputs (_("\
 853 Exit with the status determined by EXPRESSION.\n\
 854 \n\
 855 "), stdout);
 856       fputs (HELP_OPTION_DESCRIPTION, stdout);
 857       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 858       fputs (_("\
 859 \n\
 860 An omitted EXPRESSION defaults to false.  Otherwise,\n\
 861 EXPRESSION is true or false and sets exit status.  It is one of:\n\
 862 "), stdout);
 863       fputs (_("\
 864 \n\
 865   ( EXPRESSION )               EXPRESSION is true\n\
 866   ! EXPRESSION                 EXPRESSION is false\n\
 867   EXPRESSION1 -a EXPRESSION2   both EXPRESSION1 and EXPRESSION2 are true\n\
 868   EXPRESSION1 -o EXPRESSION2   either EXPRESSION1 or EXPRESSION2 is true\n\
 869 "), stdout);
 870       fputs (_("\
 871 \n\
 872   -n STRING            the length of STRING is nonzero\n\
 873   STRING               equivalent to -n STRING\n\
 874   -z STRING            the length of STRING is zero\n\
 875   STRING1 = STRING2    the strings are equal\n\
 876   STRING1 != STRING2   the strings are not equal\n\
 877 "), stdout);
 878       fputs (_("\
 879 \n\
 880   INTEGER1 -eq INTEGER2   INTEGER1 is equal to INTEGER2\n\
 881   INTEGER1 -ge INTEGER2   INTEGER1 is greater than or equal to INTEGER2\n\
 882   INTEGER1 -gt INTEGER2   INTEGER1 is greater than INTEGER2\n\
 883   INTEGER1 -le INTEGER2   INTEGER1 is less than or equal to INTEGER2\n\
 884   INTEGER1 -lt INTEGER2   INTEGER1 is less than INTEGER2\n\
 885   INTEGER1 -ne INTEGER2   INTEGER1 is not equal to INTEGER2\n\
 886 "), stdout);
 887       fputs (_("\
 888 \n\
 889   FILE1 -ef FILE2   FILE1 and FILE2 have the same device and inode numbers\n\
 890   FILE1 -nt FILE2   FILE1 is newer (modification date) than FILE2\n\
 891   FILE1 -ot FILE2   FILE1 is older than FILE2\n\
 892 "), stdout);
 893       fputs (_("\
 894 \n\
 895   -b FILE     FILE exists and is block special\n\
 896   -c FILE     FILE exists and is character special\n\
 897   -d FILE     FILE exists and is a directory\n\
 898   -e FILE     FILE exists\n\
 899 "), stdout);
 900       fputs (_("\
 901   -f FILE     FILE exists and is a regular file\n\
 902   -g FILE     FILE exists and is set-group-ID\n\
 903   -G FILE     FILE exists and is owned by the effective group ID\n\
 904   -h FILE     FILE exists and is a symbolic link (same as -L)\n\
 905   -k FILE     FILE exists and has its sticky bit set\n\
 906 "), stdout);
 907       fputs (_("\
 908   -L FILE     FILE exists and is a symbolic link (same as -h)\n\
 909   -O FILE     FILE exists and is owned by the effective user ID\n\
 910   -p FILE     FILE exists and is a named pipe\n\
 911   -r FILE     FILE exists and read permission is granted\n\
 912   -s FILE     FILE exists and has a size greater than zero\n\
 913 "), stdout);
 914       fputs (_("\
 915   -S FILE     FILE exists and is a socket\n\
 916   -t FD       file descriptor FD is opened on a terminal\n\
 917   -u FILE     FILE exists and its set-user-ID bit is set\n\
 918   -w FILE     FILE exists and write permission is granted\n\
 919   -x FILE     FILE exists and execute (or search) permission is granted\n\
 920 "), stdout);
 921       fputs (_("\
 922 \n\
 923 Except for -h and -L, all FILE-related tests dereference symbolic links.\n\
 924 Beware that parentheses need to be escaped (e.g., by backslashes) for shells.\n\
 925 INTEGER may also be -l STRING, which evaluates to the length of STRING.\n\
 926 "), stdout);
 927       printf (USAGE_BUILTIN_WARNING, _("test and/or ["));
 928       printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
 929     }
 930   exit (status);
 931 }
 932 #endif /* TEST_STANDALONE */
 933
 934 #if !defined (TEST_STANDALONE)
 935 # define main test_command
 936 #endif
 937
 938 #define AUTHORS "Kevin Braunsdorf", "Matthew Bradburn"
 939
 940 /*
 941  * [:
 942  *      '[' expr ']'
 943  * test:
 944  *      test expr
 945  */
 946 int
 947 main (int margc, char **margv)
 948 {
 949   bool value;
 950
 951 #if !defined (TEST_STANDALONE)
 952   int code;
 953
 954   code = setjmp (test_exit_buf);
 955
 956   if (code)
 957     return (test_error_return);
 958 #else /* TEST_STANDALONE */
 959   initialize_main (&margc, &margv);
 960   program_name = margv[0];
 961   setlocale (LC_ALL, "");
 962   bindtextdomain (PACKAGE, LOCALEDIR);
 963   textdomain (PACKAGE);
 964
 965   initialize_exit_failure (TEST_FAILURE);
 966   atexit (close_stdout);
 967 #endif /* TEST_STANDALONE */
 968
 969   argv = margv;
 970
 971   if (LBRACKET)
 972     {
 973       /* Recognize --help or --version, but only when invoked in the
 974          "[" form, and when the last argument is not "]".  POSIX
 975          allows "[ --help" and "[ --version" to have the usual GNU
 976          behavior, but it requires "test --help" and "test --version"
 977          to exit silently with status 1.  */
 978       if (margc < 2 || !STREQ (margv[margc - 1], "]"))
 979         {
 980           parse_long_options (margc, margv, PROGRAM_NAME, GNU_PACKAGE, VERSION,
 981                               usage, AUTHORS, (char const *) NULL);
 982           test_syntax_error (_("missing `]'\n"), NULL);
 983         }
 984
 985       --margc;
 986     }
 987
 988   argc = margc;
 989   pos = 1;
 990
 991   if (pos >= argc)
 992     test_exit (TEST_FALSE);
 993
 994   value = posixtest (argc - 1);
 995
 996   if (pos != argc)
 997     test_syntax_error (_("extra argument %s"), quote (argv[pos]));
 998
 999   test_exit (value ? TEST_TRUE : TEST_FALSE);
1000 }