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-1999 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 /* #define TEST_STANDALONE */
  26
  27 #include <config.h>
  28 #include <stdio.h>
  29 #include <sys/types.h>
  30
  31 /* The official name of this program (e.g., no `g' prefix).  */
  32 #define PROGRAM_NAME "test"
  33
  34 #define TEST_STANDALONE 1
  35
  36 #if !defined (TEST_STANDALONE)
  37 # include "shell.h"
  38 # include "posixstat.h"
  39 # include "filecntl.h"
  40 #else /* TEST_STANDALONE */
  41 # include "system.h"
  42 # include "group-member.h"
  43 # include "error.h"
  44 # if !defined (S_IXUGO)
  45 #  define S_IXUGO 0111
  46 # endif /* S_IXUGO */
  47 # if defined (_POSIX_VERSION)
  48 #  include <limits.h>
  49 # else /* !_POSIX_VERSION */
  50 #  include <sys/param.h>
  51 # endif /* _POSIX_VERSION */
  52 # define whitespace(c) (((c) == ' ') || ((c) == '\t'))
  53 # define digit(c)  ((c) >= '0' && (c) <= '9')
  54 # define digit_value(c) ((c) - '0')
  55 char *program_name;
  56 #endif /* TEST_STANDALONE */
  57
  58 #if !defined (_POSIX_VERSION)
  59 # include <sys/file.h>
  60 #endif /* !_POSIX_VERSION */
  61
  62 #include <errno.h>
  63 #ifndef errno
  64 extern int errno;
  65 #endif
  66
  67 #undef STREQ
  68 #define STREQ(a, b) ((a)[0] == (b)[0] && strcmp (a, b) == 0)
  69
  70 #if !defined (member)
  71 # define member(c, s) ((c) ? (strchr ((s), (c)) ? 1 : 0) : 0)
  72 #endif /* !member */
  73
  74 extern gid_t getegid ();
  75 extern uid_t geteuid ();
  76
  77 #if !defined (R_OK)
  78 # define R_OK 4
  79 # define W_OK 2
  80 # define X_OK 1
  81 # define F_OK 0
  82 #endif /* R_OK */
  83
  84 /* This name is used solely when printing --version information.  */
  85 #define PROGRAM_NAME "test"
  86
  87 /* The following few defines control the truth and false output of each stage.
  88    TRUE and FALSE are what we use to compute the final output value.
  89    SHELL_BOOLEAN is the form which returns truth or falseness in shell terms.
  90    TRUTH_OR is how to do logical or with TRUE and FALSE.
  91    TRUTH_AND is how to do logical and with TRUE and FALSE..
  92    Default is TRUE = 1, FALSE = 0, TRUTH_OR = a | b, TRUTH_AND = a & b,
  93     SHELL_BOOLEAN = (!value). */
  94 #define TRUE 1
  95 #define FALSE 0
  96 #define SHELL_BOOLEAN(value) (!(value))
  97 #define TRUTH_OR(a, b) ((a) | (b))
  98 #define TRUTH_AND(a, b) ((a) & (b))
  99
 100 #if defined (TEST_STANDALONE)
 101 # define test_exit(val) exit (val)
 102 #else
 103    static jmp_buf test_exit_buf;
 104    static int test_error_return = 0;
 105 # define test_exit(val) test_error_return = val, longjmp (test_exit_buf, 1)
 106 #endif /* !TEST_STANDALONE */
 107
 108 static int pos;         /* The offset of the current argument in ARGV. */
 109 static int argc;        /* The number of arguments present in ARGV. */
 110 static char **argv;     /* The argument list. */
 111
 112 static int unop PARAMS ((int op));
 113 static int binop PARAMS ((char *s));
 114 static int unary_operator PARAMS ((void));
 115 static int binary_operator PARAMS ((void));
 116 static int two_arguments PARAMS ((void));
 117 static int three_arguments PARAMS ((void));
 118 static int posixtest PARAMS ((void));
 119
 120 static int expr PARAMS ((void));
 121 static int term PARAMS ((void));
 122 static int and PARAMS ((void));
 123 static int or PARAMS ((void));
 124
 125 #if __GNUC__ >= 2 && defined (__GNUC_MINOR__) \
 126     && __GNUC_MINOR__ >= 5 && !defined (__STRICT_ANSI__)
 127 # define NO_RETURN_ATTRIBUTE __attribute__ ((noreturn))
 128 #else
 129 # define NO_RETURN_ATTRIBUTE /* empty */
 130 #endif
 131
 132 static void test_syntax_error PARAMS ((char *format, char *arg)) NO_RETURN_ATTRIBUTE;
 133 static void beyond PARAMS ((void)) NO_RETURN_ATTRIBUTE;
 134
 135 static void
 136 test_syntax_error (char *format, char *arg)
 137 {
 138   fprintf (stderr, "%s: ", argv[0]);
 139   fprintf (stderr, format, arg);
 140   fflush (stderr);
 141   test_exit (SHELL_BOOLEAN (FALSE));
 142 }
 143
 144 /* A wrapper for stat () which disallows pathnames that are empty strings. */
 145 static int
 146 test_stat (char *path, struct stat *finfo)
 147 {
 148   if (*path == '\0')
 149     {
 150       errno = ENOENT;
 151       return (-1);
 152     }
 153   return (stat (path, finfo));
 154 }
 155
 156 /* Do the same thing access(2) does, but use the effective uid and gid,
 157    and don't make the mistake of telling root that any file is executable.
 158    But this loses when the containing filesystem is mounted e.g. read-only.  */
 159 static int
 160 eaccess (char *path, int mode)
 161 {
 162   struct stat st;
 163   static int euid = -1;
 164
 165   if (test_stat (path, &st) < 0)
 166     return (-1);
 167
 168   if (euid == -1)
 169     euid = geteuid ();
 170
 171   if (euid == 0)
 172     {
 173       /* Root can read or write any file. */
 174       if (mode != X_OK)
 175         return (0);
 176
 177       /* Root can execute any file that has any one of the execute
 178          bits set. */
 179       if (st.st_mode & S_IXUGO)
 180         return (0);
 181     }
 182
 183   if (st.st_uid == euid)        /* owner */
 184     mode <<= 6;
 185   else if (group_member (st.st_gid))
 186     mode <<= 3;
 187
 188   if (st.st_mode & mode)
 189     return (0);
 190
 191   return (-1);
 192 }
 193
 194 /* Increment our position in the argument list.  Check that we're not
 195    past the end of the argument list.  This check is supressed if the
 196    argument is FALSE.  Made a macro for efficiency. */
 197 #define advance(f)                                                      \
 198   do                                                                    \
 199     {                                                                   \
 200       ++pos;                                                            \
 201       if ((f) && pos >= argc)                                           \
 202         beyond ();                                                      \
 203     }                                                                   \
 204   while (0)
 205
 206 #if !defined (advance)
 207 static int
 208 advance (int f)
 209 {
 210   ++pos;
 211
 212   if (f && pos >= argc)
 213     beyond ();
 214 }
 215 #endif /* advance */
 216
 217 #define unary_advance()                                                 \
 218   do                                                                    \
 219     {                                                                   \
 220       advance (1);                                                      \
 221       ++pos;                                                            \
 222     }                                                                   \
 223   while (0)
 224
 225 /*
 226  * beyond - call when we're beyond the end of the argument list (an
 227  *      error condition)
 228  */
 229 static void
 230 beyond (void)
 231 {
 232   test_syntax_error (_("argument expected\n"), NULL);
 233 }
 234
 235 /* Syntax error for when an integer argument was expected, but
 236    something else was found. */
 237 static void
 238 integer_expected_error (char *pch)
 239 {
 240   test_syntax_error (_("integer expression expected %s\n"), pch);
 241 }
 242
 243 /* Return nonzero if the characters pointed to by STRING constitute a
 244    valid number.  Stuff the converted number into RESULT if RESULT is
 245    a non-null pointer to a long. */
 246 static int
 247 isint (register char *string, long int *result)
 248 {
 249   int sign;
 250   long value;
 251
 252   sign = 1;
 253   value = 0;
 254
 255   if (result)
 256     *result = 0;
 257
 258   /* Skip leading whitespace characters. */
 259   while (whitespace (*string))
 260     string++;
 261
 262   if (!*string)
 263     return (0);
 264
 265   /* We allow leading `-' or `+'. */
 266   if (*string == '-' || *string == '+')
 267     {
 268       if (!digit (string[1]))
 269         return (0);
 270
 271       if (*string == '-')
 272         sign = -1;
 273
 274       string++;
 275     }
 276
 277   while (digit (*string))
 278     {
 279       if (result)
 280         value = (value * 10) + digit_value (*string);
 281       string++;
 282     }
 283
 284   /* Skip trailing whitespace, if any. */
 285   while (whitespace (*string))
 286     string++;
 287
 288   /* Error if not at end of string. */
 289   if (*string)
 290     return (0);
 291
 292   if (result)
 293     {
 294       value *= sign;
 295       *result = value;
 296     }
 297
 298   return (1);
 299 }
 300
 301 /* Find the modification time of FILE, and stuff it into AGE, a pointer
 302    to a long.  Return nonzero if successful, else zero. */
 303 static int
 304 age_of (char *filename, long int *age)
 305 {
 306   struct stat finfo;
 307
 308   if (test_stat (filename, &finfo) < 0)
 309     return (0);
 310
 311   if (age)
 312     *age = finfo.st_mtime;
 313
 314   return (1);
 315 }
 316
 317 /*
 318  * term - parse a term and return 1 or 0 depending on whether the term
 319  *      evaluates to true or false, respectively.
 320  *
 321  * term ::=
 322  *      '-'('h'|'d'|'f'|'r'|'s'|'w'|'c'|'b'|'p'|'u'|'g'|'k') filename
 323  *      '-'('L'|'x') filename
 324  *      '-t' [ int ]
 325  *      '-'('z'|'n') string
 326  *      string
 327  *      string ('!='|'=') string
 328  *      <int> '-'(eq|ne|le|lt|ge|gt) <int>
 329  *      file '-'(nt|ot|ef) file
 330  *      '(' <expr> ')'
 331  * int ::=
 332  *      '-l' string
 333  *      positive and negative integers
 334  */
 335 static int
 336 term (void)
 337 {
 338   int value;
 339
 340   if (pos >= argc)
 341     beyond ();
 342
 343   /* Deal with leading "not"'s. */
 344   if ('!' == argv[pos][0] && '\000' == argv[pos][1])
 345     {
 346       value = FALSE;
 347       while (pos < argc && '!' == argv[pos][0] && '\000' == argv[pos][1])
 348         {
 349           advance (1);
 350           value ^= (TRUE);
 351         }
 352
 353       return (value ^ (term ()));
 354     }
 355
 356   /* A paren-bracketed argument. */
 357   if (argv[pos][0] == '(' && !argv[pos][1])
 358     {
 359       advance (1);
 360       value = expr ();
 361       if (!argv[pos])
 362         test_syntax_error (_("')' expected\n"), NULL);
 363       else
 364         if (argv[pos][0] != ')' || argv[pos][1])
 365           test_syntax_error (_("')' expected, found %s\n"), argv[pos]);
 366       advance (0);
 367       return (TRUE == (value));
 368     }
 369
 370   /* are there enough arguments left that this could be dyadic? */
 371   if (((pos + 3 <= argc) && binop (argv[pos + 1])) ||
 372       ((pos + 4 <= argc && STREQ (argv[pos], "-l") && binop (argv[pos + 2]))))
 373     value = binary_operator ();
 374
 375   /* Might be a switch type argument */
 376   else if ('-' == argv[pos][0] && argv[pos][1] && 0 == argv[pos][2])
 377     {
 378       if (unop (argv[pos][1]))
 379         value = unary_operator ();
 380       else
 381         test_syntax_error (_("%s: unary operator expected\n"), argv[pos]);
 382     }
 383   else
 384     {
 385       value = (argv[pos][0] != '\0');
 386       advance (0);
 387     }
 388
 389   return (value);
 390 }
 391
 392 static int
 393 binary_operator (void)
 394 {
 395   register int op;
 396   struct stat stat_buf, stat_spare;
 397   long int l, r, value;
 398   /* Are the left and right integer expressions of the form '-l string'? */
 399   int l_is_l, r_is_l;
 400
 401   if (strcmp (argv[pos], "-l") == 0)
 402     {
 403       l_is_l = 1;
 404       op = pos + 2;
 405
 406       /* Make sure that OP is still a valid binary operator. */
 407       if ((op >= argc - 1) || (binop (argv[op]) == 0))
 408         test_syntax_error (_("%s: binary operator expected\n"), argv[op]);
 409
 410       advance (0);
 411     }
 412   else
 413     {
 414       l_is_l = 0;
 415       op = pos + 1;
 416     }
 417
 418   if ((op < argc - 2) && (strcmp (argv[op + 1], "-l") == 0))
 419     {
 420       r_is_l = 1;
 421       advance (0);
 422     }
 423   else
 424     r_is_l = 0;
 425
 426   if (argv[op][0] == '-')
 427     {
 428       /* check for eq, nt, and stuff */
 429       switch (argv[op][1])
 430         {
 431         default:
 432           break;
 433
 434         case 'l':
 435           if (argv[op][2] == 't' && !argv[op][3])
 436             {
 437               /* lt */
 438               if (l_is_l)
 439                 l = strlen (argv[op - 1]);
 440               else
 441                 {
 442                   if (!isint (argv[op - 1], &l))
 443                     integer_expected_error (_("before -lt"));
 444                 }
 445
 446               if (r_is_l)
 447                 r = strlen (argv[op + 2]);
 448               else
 449                 {
 450                   if (!isint (argv[op + 1], &r))
 451                     integer_expected_error (_("after -lt"));
 452                 }
 453               pos += 3;
 454               return (TRUE == (l < r));
 455             }
 456
 457           if (argv[op][2] == 'e' && !argv[op][3])
 458             {
 459               /* le */
 460               if (l_is_l)
 461                 l = strlen (argv[op - 1]);
 462               else
 463                 {
 464                   if (!isint (argv[op - 1], &l))
 465                     integer_expected_error (_("before -le"));
 466                 }
 467               if (r_is_l)
 468                 r = strlen (argv[op + 2]);
 469               else
 470                 {
 471                   if (!isint (argv[op + 1], &r))
 472                     integer_expected_error (_("after -le"));
 473                 }
 474               pos += 3;
 475               return (TRUE == (l <= r));
 476             }
 477           break;
 478
 479         case 'g':
 480           if (argv[op][2] == 't' && !argv[op][3])
 481             {
 482               /* gt integer greater than */
 483               if (l_is_l)
 484                 l = strlen (argv[op - 1]);
 485               else
 486                 {
 487                   if (!isint (argv[op - 1], &l))
 488                     integer_expected_error (_("before -gt"));
 489                 }
 490               if (r_is_l)
 491                 r = strlen (argv[op + 2]);
 492               else
 493                 {
 494                   if (!isint (argv[op + 1], &r))
 495                     integer_expected_error (_("after -gt"));
 496                 }
 497               pos += 3;
 498               return (TRUE == (l > r));
 499             }
 500
 501           if (argv[op][2] == 'e' && !argv[op][3])
 502             {
 503               /* ge - integer greater than or equal to */
 504               if (l_is_l)
 505                 l = strlen (argv[op - 1]);
 506               else
 507                 {
 508                   if (!isint (argv[op - 1], &l))
 509                     integer_expected_error (_("before -ge"));
 510                 }
 511               if (r_is_l)
 512                 r = strlen (argv[op + 2]);
 513               else
 514                 {
 515                   if (!isint (argv[op + 1], &r))
 516                     integer_expected_error (_("after -ge"));
 517                 }
 518               pos += 3;
 519               return (TRUE == (l >= r));
 520             }
 521           break;
 522
 523         case 'n':
 524           if (argv[op][2] == 't' && !argv[op][3])
 525             {
 526               /* nt - newer than */
 527               pos += 3;
 528               if (l_is_l || r_is_l)
 529                 test_syntax_error (_("-nt does not accept -l\n"), NULL);
 530               if (age_of (argv[op - 1], &l) && age_of (argv[op + 1], &r))
 531                 return (TRUE == (l > r));
 532               else
 533                 return (FALSE);
 534             }
 535
 536           if (argv[op][2] == 'e' && !argv[op][3])
 537             {
 538               /* ne - integer not equal */
 539               if (l_is_l)
 540                 l = strlen (argv[op - 1]);
 541               else
 542                 {
 543                   if (!isint (argv[op - 1], &l))
 544                     integer_expected_error (_("before -ne"));
 545                 }
 546               if (r_is_l)
 547                 r = strlen (argv[op + 2]);
 548               else
 549                 {
 550                   if (!isint (argv[op + 1], &r))
 551                     integer_expected_error (_("after -ne"));
 552                 }
 553               pos += 3;
 554               return (TRUE == (l != r));
 555             }
 556           break;
 557
 558         case 'e':
 559           if (argv[op][2] == 'q' && !argv[op][3])
 560             {
 561               /* eq - integer equal */
 562               if (l_is_l)
 563                 l = strlen (argv[op - 1]);
 564               else
 565                 {
 566                   if (!isint (argv[op - 1], &l))
 567                     integer_expected_error (_("before -eq"));
 568                 }
 569               if (r_is_l)
 570                 r = strlen (argv[op + 2]);
 571               else
 572                 {
 573                   if (!isint (argv[op + 1], &r))
 574                     integer_expected_error (_("after -eq"));
 575                 }
 576               pos += 3;
 577               return (TRUE == (l == r));
 578             }
 579
 580           if (argv[op][2] == 'f' && !argv[op][3])
 581             {
 582               /* ef - hard link? */
 583               pos += 3;
 584               if (l_is_l || r_is_l)
 585                 test_syntax_error (_("-ef does not accept -l\n"), NULL);
 586               if (stat (argv[op - 1], &stat_buf) < 0)
 587                 return (FALSE);
 588               if (stat (argv[op + 1], &stat_spare) < 0)
 589                 return (FALSE);
 590               return (TRUE ==
 591                       (stat_buf.st_dev == stat_spare.st_dev &&
 592                        stat_buf.st_ino == stat_spare.st_ino));
 593             }
 594           break;
 595
 596         case 'o':
 597           if ('t' == argv[op][2] && '\000' == argv[op][3])
 598             {
 599               /* ot - older than */
 600               pos += 3;
 601               if (l_is_l || r_is_l)
 602                 test_syntax_error (_("-nt does not accept -l\n"), NULL);
 603               if (age_of (argv[op - 1], &l) && age_of (argv[op + 1], &r))
 604                 return (TRUE == (l < r));
 605               return (FALSE);
 606             }
 607           break;
 608         }
 609       test_syntax_error (_("unknown binary operator"), argv[op]);
 610     }
 611
 612   if (argv[op][0] == '=' && !argv[op][1])
 613     {
 614       value = (strcmp (argv[pos], argv[pos + 2]) == 0);
 615       pos += 3;
 616       return (TRUE == value);
 617     }
 618
 619   if (strcmp (argv[op], "!=") == 0)
 620     {
 621       value = (strcmp (argv[pos], argv[pos + 2]) != 0);
 622       pos += 3;
 623       return (TRUE == value);
 624     }
 625
 626   /* Not reached.  */
 627   abort ();
 628 }
 629
 630 static int
 631 unary_operator (void)
 632 {
 633   long fd, value;
 634   struct stat stat_buf;
 635
 636   switch (argv[pos][1])
 637     {
 638     default:
 639       return (FALSE);
 640
 641       /* All of the following unary operators use unary_advance (), which
 642          checks to make sure that there is an argument, and then advances
 643          pos right past it.  This means that pos - 1 is the location of the
 644          argument. */
 645
 646     case 'a':                   /* file exists in the file system? */
 647     case 'e':
 648       unary_advance ();
 649       value = -1 != test_stat (argv[pos - 1], &stat_buf);
 650       return (TRUE == value);
 651
 652     case 'r':                   /* file is readable? */
 653       unary_advance ();
 654       value = -1 != eaccess (argv[pos - 1], R_OK);
 655       return (TRUE == value);
 656
 657     case 'w':                   /* File is writable? */
 658       unary_advance ();
 659       value = -1 != eaccess (argv[pos - 1], W_OK);
 660       return (TRUE == value);
 661
 662     case 'x':                   /* File is executable? */
 663       unary_advance ();
 664       value = -1 != eaccess (argv[pos - 1], X_OK);
 665       return (TRUE == value);
 666
 667     case 'O':                   /* File is owned by you? */
 668       unary_advance ();
 669       if (test_stat (argv[pos - 1], &stat_buf) < 0)
 670         return (FALSE);
 671
 672       return (TRUE == (geteuid () == stat_buf.st_uid));
 673
 674     case 'G':                   /* File is owned by your group? */
 675       unary_advance ();
 676       if (test_stat (argv[pos - 1], &stat_buf) < 0)
 677         return (FALSE);
 678
 679       return (TRUE == (getegid () == stat_buf.st_gid));
 680
 681     case 'f':                   /* File is a file? */
 682       unary_advance ();
 683       if (test_stat (argv[pos - 1], &stat_buf) < 0)
 684         return (FALSE);
 685
 686       /* Under POSIX, -f is true if the given file exists
 687          and is a regular file. */
 688       return (TRUE == ((S_ISREG (stat_buf.st_mode)) ||
 689                        (0 == (stat_buf.st_mode & S_IFMT))));
 690
 691     case 'd':                   /* File is a directory? */
 692       unary_advance ();
 693       if (test_stat (argv[pos - 1], &stat_buf) < 0)
 694         return (FALSE);
 695
 696       return (TRUE == (S_ISDIR (stat_buf.st_mode)));
 697
 698     case 's':                   /* File has something in it? */
 699       unary_advance ();
 700       if (test_stat (argv[pos - 1], &stat_buf) < 0)
 701         return (FALSE);
 702
 703       return (TRUE == (stat_buf.st_size > (off_t) 0));
 704
 705     case 'S':                   /* File is a socket? */
 706 #if !defined (S_ISSOCK)
 707       return (FALSE);
 708 #else
 709       unary_advance ();
 710
 711       if (test_stat (argv[pos - 1], &stat_buf) < 0)
 712         return (FALSE);
 713
 714       return (TRUE == (S_ISSOCK (stat_buf.st_mode)));
 715 #endif                          /* S_ISSOCK */
 716
 717     case 'c':                   /* File is character special? */
 718       unary_advance ();
 719       if (test_stat (argv[pos - 1], &stat_buf) < 0)
 720         return (FALSE);
 721
 722       return (TRUE == (S_ISCHR (stat_buf.st_mode)));
 723
 724     case 'b':                   /* File is block special? */
 725       unary_advance ();
 726       if (test_stat (argv[pos - 1], &stat_buf) < 0)
 727         return (FALSE);
 728
 729       return (TRUE == (S_ISBLK (stat_buf.st_mode)));
 730
 731     case 'p':                   /* File is a named pipe? */
 732       unary_advance ();
 733 #ifndef S_ISFIFO
 734       return (FALSE);
 735 #else
 736       if (test_stat (argv[pos - 1], &stat_buf) < 0)
 737         return (FALSE);
 738       return (TRUE == (S_ISFIFO (stat_buf.st_mode)));
 739 #endif                          /* S_ISFIFO */
 740
 741     case 'L':                   /* Same as -h  */
 742       /*FALLTHROUGH*/
 743
 744     case 'h':                   /* File is a symbolic link? */
 745       unary_advance ();
 746 #ifndef S_ISLNK
 747       return (FALSE);
 748 #else
 749       /* An empty filename is not a valid pathname. */
 750       if ((argv[pos - 1][0] == '\0') ||
 751           (lstat (argv[pos - 1], &stat_buf) < 0))
 752         return (FALSE);
 753
 754       return (TRUE == (S_ISLNK (stat_buf.st_mode)));
 755 #endif                          /* S_IFLNK */
 756
 757     case 'u':                   /* File is setuid? */
 758       unary_advance ();
 759 #ifndef S_ISUID
 760       return (FALSE);
 761 #else
 762       if (test_stat (argv[pos - 1], &stat_buf) < 0)
 763         return (FALSE);
 764
 765       return (TRUE == (0 != (stat_buf.st_mode & S_ISUID)));
 766 #endif
 767
 768     case 'g':                   /* File is setgid? */
 769       unary_advance ();
 770 #ifndef S_ISGID
 771       return (FALSE);
 772 #else
 773       if (test_stat (argv[pos - 1], &stat_buf) < 0)
 774         return (FALSE);
 775
 776       return (TRUE == (0 != (stat_buf.st_mode & S_ISGID)));
 777 #endif
 778
 779     case 'k':                   /* File has sticky bit set? */
 780       unary_advance ();
 781       if (test_stat (argv[pos - 1], &stat_buf) < 0)
 782         return (FALSE);
 783 #ifndef S_ISVTX
 784       /* This is not Posix, and is not defined on some Posix systems. */
 785       return (FALSE);
 786 #else
 787       return (TRUE == (0 != (stat_buf.st_mode & S_ISVTX)));
 788 #endif
 789
 790     case 't':                   /* File (fd) is a terminal? */
 791       advance (0);
 792       if (pos < argc)
 793         {
 794           if (!isint (argv[pos], &fd))
 795             integer_expected_error (_("after -t"));
 796           advance (0);
 797         }
 798       else
 799         {
 800           fd = 1;
 801         }
 802       return (TRUE == (isatty ((int) fd)));
 803
 804     case 'n':                   /* True if arg has some length. */
 805       unary_advance ();
 806       return (TRUE == (argv[pos - 1][0] != 0));
 807
 808     case 'z':                   /* True if arg has no length. */
 809       unary_advance ();
 810       return (TRUE == (argv[pos - 1][0] == '\0'));
 811     }
 812 }
 813
 814 /*
 815  * and:
 816  *      term
 817  *      term '-a' and
 818  */
 819 static int
 820 and (void)
 821 {
 822   int value;
 823
 824   value = term ();
 825   while ((pos < argc) && strcmp (argv[pos], "-a") == 0)
 826     {
 827       advance (0);
 828       value = TRUTH_AND (value, and ());
 829     }
 830   return (TRUE == value);
 831 }
 832
 833 /*
 834  * or:
 835  *      and
 836  *      and '-o' or
 837  */
 838 static int
 839 or (void)
 840 {
 841   int value;
 842
 843   value = and ();
 844
 845   while ((pos < argc) && strcmp (argv[pos], "-o") == 0)
 846     {
 847       advance (0);
 848       value = TRUTH_OR (value, or ());
 849     }
 850
 851   return (TRUE == value);
 852 }
 853
 854 /*
 855  * expr:
 856  *      or
 857  */
 858 static int
 859 expr (void)
 860 {
 861   if (pos >= argc)
 862     beyond ();
 863
 864   return (FALSE ^ (or ()));             /* Same with this. */
 865 }
 866
 867 /* Return TRUE if S is one of the test command's binary operators. */
 868 static int
 869 binop (char *s)
 870 {
 871   return ((STREQ (s,   "=")) || (STREQ (s,  "!=")) || (STREQ (s, "-nt")) ||
 872           (STREQ (s, "-ot")) || (STREQ (s, "-ef")) || (STREQ (s, "-eq")) ||
 873           (STREQ (s, "-ne")) || (STREQ (s, "-lt")) || (STREQ (s, "-le")) ||
 874           (STREQ (s, "-gt")) || (STREQ (s, "-ge")));
 875 }
 876
 877 /* Return nonzero if OP is one of the test command's unary operators. */
 878 static int
 879 unop (int op)
 880 {
 881   return (member (op, "abcdefgkLhprsStuwxOGnz"));
 882 }
 883
 884 static int
 885 one_argument (const char *s)
 886 {
 887   if (STREQ (s, "-t"))
 888     return (TRUE == (isatty (1)));
 889
 890   return strlen (s) != 0;
 891 }
 892
 893 static int
 894 two_arguments (void)
 895 {
 896   int value;
 897
 898   if (STREQ (argv[pos], "!"))
 899     value = ! one_argument (argv[pos+1]);
 900   else if (argv[pos][0] == '-'
 901            && argv[pos][1] != '\0'
 902            && argv[pos][2] == '\0')
 903     {
 904       if (unop (argv[pos][1]))
 905         value = unary_operator ();
 906       else
 907         test_syntax_error (_("%s: unary operator expected\n"), argv[pos]);
 908     }
 909   else
 910     beyond ();
 911   return (value);
 912 }
 913
 914 static int
 915 three_arguments (void)
 916 {
 917   int value;
 918
 919   if (STREQ (argv[pos], "!"))
 920     {
 921       advance (1);
 922       value = !two_arguments ();
 923     }
 924   else if (binop (argv[pos+1]))
 925     {
 926       value = binary_operator ();
 927       pos = argc;
 928     }
 929   else if ((STREQ (argv[pos+1], "-a")) || (STREQ (argv[pos+1], "-o")) ||
 930            (argv[pos][0] == '('))
 931     value = expr ();
 932   else
 933     test_syntax_error (_("%s: binary operator expected\n"), argv[pos+1]);
 934   return (value);
 935 }
 936
 937 /* This is an implementation of a Posix.2 proposal by David Korn. */
 938 static int
 939 posixtest (void)
 940 {
 941   int value;
 942
 943   switch (argc - 1)     /* one extra passed in */
 944     {
 945       case 0:
 946         value = FALSE;
 947         pos = argc;
 948         break;
 949
 950       case 1:
 951         value = one_argument (argv[1]);
 952         pos = argc;
 953         break;
 954
 955       case 2:
 956         value = two_arguments ();
 957         pos = argc;
 958         break;
 959
 960       case 3:
 961         value = three_arguments ();
 962         break;
 963
 964       case 4:
 965         if (STREQ (argv[pos], "!"))
 966           {
 967             advance (1);
 968             value = !three_arguments ();
 969             break;
 970           }
 971         /* FALLTHROUGH */
 972       case 5:
 973       default:
 974         value = expr ();
 975     }
 976
 977   return (value);
 978 }
 979
 980 #if defined (TEST_STANDALONE)
 981 # include "long-options.h"
 982
 983 void
 984 usage (int status)
 985 {
 986   if (status != 0)
 987     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 988              program_name);
 989   else
 990     {
 991       printf (_("\
 992 Usage: %s EXPRESSION\n\
 993   or:  [ EXPRESSION ]\n\
 994   or:  %s OPTION\n\
 995 "),
 996               program_name, program_name);
 997       printf (_("\
 998 Exit with the status determined by EXPRESSION.\n\
 999 \n\
1000   --help      display this help and exit\n\
1001   --version   output version information and exit\n\
1002 \n\
1003 EXPRESSION is true or false and sets exit status.  It is one of:\n\
1004 "));
1005       printf (_("\
1006 \n\
1007   ( EXPRESSION )               EXPRESSION is true\n\
1008   ! EXPRESSION                 EXPRESSION is false\n\
1009   EXPRESSION1 -a EXPRESSION2   both EXPRESSION1 and EXPRESSION2 are true\n\
1010   EXPRESSION1 -o EXPRESSION2   either EXPRESSION1 or EXPRESSION2 is true\n\
1011 \n\
1012   [-n] STRING          the length of STRING is nonzero\n\
1013   -z STRING            the length of STRING is zero\n\
1014   STRING1 = STRING2    the strings are equal\n\
1015   STRING1 != STRING2   the strings are not equal\n\
1016 \n\
1017   INTEGER1 -eq INTEGER2   INTEGER1 is equal to INTEGER2\n\
1018   INTEGER1 -ge INTEGER2   INTEGER1 is greater than or equal to INTEGER2\n\
1019   INTEGER1 -gt INTEGER2   INTEGER1 is greater than INTEGER2\n\
1020   INTEGER1 -le INTEGER2   INTEGER1 is less than or equal to INTEGER2\n\
1021   INTEGER1 -lt INTEGER2   INTEGER1 is less than INTEGER2\n\
1022   INTEGER1 -ne INTEGER2   INTEGER1 is not equal to INTEGER2\n\
1023 "));
1024       printf (_("\
1025 \n\
1026   FILE1 -ef FILE2   FILE1 and FILE2 have the same device and inode numbers\n\
1027   FILE1 -nt FILE2   FILE1 is newer (modification date) than FILE2\n\
1028   FILE1 -ot FILE2   FILE1 is older than FILE2\n\
1029 \n\
1030   -b FILE     FILE exists and is block special\n\
1031   -c FILE     FILE exists and is character special\n\
1032   -d FILE     FILE exists and is a directory\n\
1033   -e FILE     FILE exists\n\
1034   -f FILE     FILE exists and is a regular file\n\
1035   -g FILE     FILE exists and is set-group-ID\n\
1036   -G FILE     FILE exists and is owned by the effective group ID\n\
1037   -k FILE     FILE exists and has its sticky bit set\n\
1038   -L FILE     FILE exists and is a symbolic link\n\
1039   -O FILE     FILE exists and is owned by the effective user ID\n\
1040   -p FILE     FILE exists and is a named pipe\n\
1041   -r FILE     FILE exists and is readable\n\
1042   -s FILE     FILE exists and has a size greater than zero\n\
1043   -S FILE     FILE exists and is a socket\n\
1044   -t [FD]     file descriptor FD (stdout by default) is opened on a terminal\n\
1045   -u FILE     FILE exists and its set-user-ID bit is set\n\
1046   -w FILE     FILE exists and is writable\n\
1047   -x FILE     FILE exists and is executable\n\
1048 "));
1049       printf (_("\
1050 \n\
1051 Beware that parentheses need to be escaped (e.g., by backslashes) for shells.\n\
1052 INTEGER may also be -l STRING, which evaluates to the length of STRING.\n\
1053 "));
1054       puts (_("\nReport bugs to <bug-sh-utils@gnu.org>."));
1055     }
1056   exit (status);
1057 }
1058 #endif /* TEST_STANDALONE */
1059
1060 #if !defined (TEST_STANDALONE)
1061 # define main test_command
1062 #endif
1063
1064 #define AUTHORS "FIXME: ksb and mjb"
1065
1066 /*
1067  * [:
1068  *      '[' expr ']'
1069  * test:
1070  *      test expr
1071  */
1072 int
1073 main (int margc, char **margv)
1074 {
1075   int value;
1076
1077 #if !defined (TEST_STANDALONE)
1078   int code;
1079
1080   code = setjmp (test_exit_buf);
1081
1082   if (code)
1083     return (test_error_return);
1084 #else /* TEST_STANDALONE */
1085   program_name = margv[0];
1086   setlocale (LC_ALL, "");
1087   bindtextdomain (PACKAGE, LOCALEDIR);
1088   textdomain (PACKAGE);
1089 #endif /* TEST_STANDALONE */
1090
1091   argv = margv;
1092
1093   if (margv[0] && strcmp (margv[0], "[") == 0)
1094     {
1095       /* Don't recognize --help or --version if POSIXLY_CORRECT is set.  */
1096       if (getenv ("POSIXLY_CORRECT") == NULL)
1097         parse_long_options (argc, argv, PROGRAM_NAME, GNU_PACKAGE, VERSION,
1098                             AUTHORS, usage);
1099
1100       --margc;
1101
1102       if (margc < 2)
1103         test_exit (SHELL_BOOLEAN (FALSE));
1104
1105       if (margv[margc] && strcmp (margv[margc], "]") != 0)
1106         test_syntax_error (_("missing `]'\n"), NULL);
1107     }
1108
1109   argc = margc;
1110   pos = 1;
1111
1112   if (pos >= argc)
1113     test_exit (SHELL_BOOLEAN (FALSE));
1114
1115   parse_long_options (argc, argv, PROGRAM_NAME, GNU_PACKAGE, VERSION,
1116                       AUTHORS, usage);
1117   value = posixtest ();
1118
1119   if (pos != argc)
1120     test_syntax_error (_("too many arguments\n"), NULL);
1121
1122   test_exit (SHELL_BOOLEAN (value));
1123 }