src/expr.c

   1 /* expr -- evaluate expressions.
   2    Copyright (C) 1986-2023 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 /* Author: Mike Parker.
  18    Modified for arbitrary-precision calculation by James Youngman.
  19
  20    This program evaluates expressions.  Each token (operator, operand,
  21    parenthesis) of the expression must be a separate argument.  The
  22    parser used is a reasonably general one, though any incarnation of
  23    it is language-specific.  It is especially nice for expressions.
  24
  25    No parse tree is needed; a new node is evaluated immediately.
  26    One function can handle multiple operators all of equal precedence,
  27    provided they all associate ((x op x) op x).
  28
  29    Define EVAL_TRACE to print an evaluation trace.  */
  30
  31 #include <config.h>
  32 #include <stdio.h>
  33 #include <sys/types.h>
  34 #include "system.h"
  35
  36 #include <gmp.h>
  37 #include <regex.h>
  38 #include "long-options.h"
  39 #include "mbuiter.h"
  40 #include "strnumcmp.h"
  41 #include "xstrtol.h"
  42
  43 /* Various parts of this code assume size_t fits into unsigned long
  44    int, the widest unsigned type that GMP supports.  */
  45 static_assert (SIZE_MAX <= ULONG_MAX);
  46
  47 /* The official name of this program (e.g., no 'g' prefix).  */
  48 #define PROGRAM_NAME "expr"
  49
  50 #define AUTHORS \
  51   proper_name ("Mike Parker"), \
  52   proper_name ("James Youngman"), \
  53   proper_name ("Paul Eggert")
  54
  55 /* Exit statuses.  */
  56 enum
  57   {
  58     /* Invalid expression: e.g., its form does not conform to the
  59        grammar for expressions.  Our grammar is an extension of the
  60        POSIX grammar.  */
  61     EXPR_INVALID = 2,
  62
  63     /* An internal error occurred, e.g., arithmetic overflow, storage
  64        exhaustion.  */
  65     EXPR_FAILURE
  66   };
  67
  68 /* The kinds of value we can have.  */
  69 enum valtype
  70 {
  71   integer,
  72   string
  73 };
  74 typedef enum valtype TYPE;
  75
  76 /* A value is.... */
  77 struct valinfo
  78 {
  79   TYPE type;                    /* Which kind. */
  80   union
  81   {                             /* The value itself. */
  82     mpz_t i;
  83     char *s;
  84   } u;
  85 };
  86 typedef struct valinfo VALUE;
  87
  88 /* The arguments given to the program, minus the program name.  */
  89 static char **args;
  90
  91 static VALUE *eval (bool);
  92 static bool nomoreargs (void);
  93 static bool null (VALUE *v);
  94 static void printv (VALUE *v);
  95
  96
  97 /*
  98    Find the first occurrence in the character string STRING of any character
  99    in the character string ACCEPT.
 100
 101    Copied from gnulib's mbscspn, with two differences:
 102    1. Returns 1-based position of first found character, or zero if not found.
 103    2. Returned value is the logical character index, NOT byte offset.
 104
 105    Examples:
 106      mbs_logical_cspn ('hello','a')  => 0
 107      mbs_logical_cspn ('hello','h')  => 1
 108      mbs_logical_cspn ('hello','oe') => 1
 109      mbs_logical_cspn ('hello','lo') => 3
 110
 111    In UTF-8 \xCE\xB1 is a single character (greek alpha):
 112      mbs_logical_cspn ('\xCE\xB1bc','\xCE\xB1') => 1
 113      mbs_logical_cspn ('\xCE\xB1bc','c') => 3 */
 114 static size_t
 115 mbs_logical_cspn (char const *s, char const *accept)
 116 {
 117   size_t idx = 0;
 118
 119   if (accept[0] == '\0')
 120     return 0;
 121
 122   /* General case.  */
 123   if (MB_CUR_MAX > 1)
 124     {
 125       mbui_iterator_t iter;
 126
 127       for (mbui_init (iter, s); mbui_avail (iter); mbui_advance (iter))
 128         {
 129           ++idx;
 130           if (mb_len (mbui_cur (iter)) == 1)
 131             {
 132               if (mbschr (accept, *mbui_cur_ptr (iter)))
 133                 return idx;
 134             }
 135           else
 136             {
 137               mbui_iterator_t aiter;
 138
 139               for (mbui_init (aiter, accept);
 140                    mbui_avail (aiter);
 141                    mbui_advance (aiter))
 142                 if (mb_equal (mbui_cur (aiter), mbui_cur (iter)))
 143                   return idx;
 144             }
 145         }
 146
 147       /* not found */
 148       return 0;
 149     }
 150   else
 151     {
 152       /* single-byte locale,
 153          convert returned byte offset to 1-based index or zero if not found. */
 154       size_t i = strcspn (s, accept);
 155       return (s[i] ? i + 1 : 0);
 156     }
 157 }
 158
 159 /* Extract the substring of S, from logical character
 160    position POS and LEN characters.
 161    first character position is 1.
 162    POS and LEN refer to logical characters, not octets.
 163
 164    Upon exit, sets v->s to the new string.
 165    The new string might be empty if POS/LEN are invalid. */
 166 static char *
 167 mbs_logical_substr (char const *s, size_t pos, size_t len)
 168 {
 169   char *v, *vlim;
 170
 171   size_t blen = strlen (s); /* byte length */
 172   size_t llen = (MB_CUR_MAX > 1) ? mbslen (s) : blen; /* logical length */
 173
 174   if (llen < pos || pos == 0 || len == 0 || len == SIZE_MAX)
 175     return xstrdup ("");
 176
 177   /* characters to copy */
 178   size_t vlen = MIN (len, llen - pos + 1);
 179
 180   if (MB_CUR_MAX == 1)
 181     {
 182       /* Single-byte case */
 183       v = xmalloc (vlen + 1);
 184       vlim = mempcpy (v, s + pos - 1, vlen);
 185     }
 186   else
 187     {
 188       /* Multibyte case */
 189
 190       /* FIXME: this is wasteful. Some memory can be saved by counting
 191          how many bytes the matching characters occupy. */
 192       vlim = v = xmalloc (blen + 1);
 193
 194       mbui_iterator_t iter;
 195       size_t idx=1;
 196       for (mbui_init (iter, s);
 197            mbui_avail (iter) && vlen > 0;
 198            mbui_advance (iter), ++idx)
 199         {
 200           /* Skip until we reach the starting position */
 201           if (idx < pos)
 202             continue;
 203
 204           /* Copy one character */
 205           --vlen;
 206           vlim = mempcpy (vlim, mbui_cur_ptr (iter), mb_len (mbui_cur (iter)));
 207         }
 208     }
 209   *vlim = '\0';
 210   return v;
 211 }
 212
 213 /* Return the number of logical characters (possibly multibyte)
 214    that are in string S in the first OFS octets.
 215
 216    Example in UTF-8:
 217    "\xE2\x9D\xA7" is "U+2767 ROTATED FLORAL HEART BULLET".
 218    In the string below, there are only two characters
 219    up to the first 4 bytes (The U+2767 which occupies 3 bytes and 'x'):
 220       mbs_count_to_offset ("\xE2\x9D\xA7xyz", 4) => 2  */
 221 static size_t
 222 mbs_offset_to_chars (char const *s, size_t ofs)
 223 {
 224   mbui_iterator_t iter;
 225   size_t c = 0;
 226   for (mbui_init (iter, s); mbui_avail (iter); mbui_advance (iter))
 227     {
 228       ptrdiff_t d = mbui_cur_ptr (iter) - s;
 229       if (d >= ofs)
 230         break;
 231       ++c;
 232     }
 233   return c;
 234 }
 235
 236
 237
 238 void
 239 usage (int status)
 240 {
 241   if (status != EXIT_SUCCESS)
 242     emit_try_help ();
 243   else
 244     {
 245       printf (_("\
 246 Usage: %s EXPRESSION\n\
 247   or:  %s OPTION\n\
 248 "),
 249               program_name, program_name);
 250       putchar ('\n');
 251       fputs (HELP_OPTION_DESCRIPTION, stdout);
 252       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 253       fputs (_("\
 254 \n\
 255 Print the value of EXPRESSION to standard output.  A blank line below\n\
 256 separates increasing precedence groups.  EXPRESSION may be:\n\
 257 \n\
 258   ARG1 | ARG2       ARG1 if it is neither null nor 0, otherwise ARG2\n\
 259 \n\
 260   ARG1 & ARG2       ARG1 if neither argument is null or 0, otherwise 0\n\
 261 "), stdout);
 262       fputs (_("\
 263 \n\
 264   ARG1 < ARG2       ARG1 is less than ARG2\n\
 265   ARG1 <= ARG2      ARG1 is less than or equal to ARG2\n\
 266   ARG1 = ARG2       ARG1 is equal to ARG2\n\
 267   ARG1 != ARG2      ARG1 is unequal to ARG2\n\
 268   ARG1 >= ARG2      ARG1 is greater than or equal to ARG2\n\
 269   ARG1 > ARG2       ARG1 is greater than ARG2\n\
 270 "), stdout);
 271       fputs (_("\
 272 \n\
 273   ARG1 + ARG2       arithmetic sum of ARG1 and ARG2\n\
 274   ARG1 - ARG2       arithmetic difference of ARG1 and ARG2\n\
 275 "), stdout);
 276       /* Tell xgettext that the "% A" below is not a printf-style
 277          format string:  xgettext:no-c-format */
 278       fputs (_("\
 279 \n\
 280   ARG1 * ARG2       arithmetic product of ARG1 and ARG2\n\
 281   ARG1 / ARG2       arithmetic quotient of ARG1 divided by ARG2\n\
 282   ARG1 % ARG2       arithmetic remainder of ARG1 divided by ARG2\n\
 283 "), stdout);
 284       fputs (_("\
 285 \n\
 286   STRING : REGEXP   anchored pattern match of REGEXP in STRING\n\
 287 \n\
 288   match STRING REGEXP        same as STRING : REGEXP\n\
 289   substr STRING POS LENGTH   substring of STRING, POS counted from 1\n\
 290   index STRING CHARS         index in STRING where any CHARS is found, or 0\n\
 291   length STRING              length of STRING\n\
 292 "), stdout);
 293       fputs (_("\
 294   + TOKEN                    interpret TOKEN as a string, even if it is a\n\
 295                                keyword like 'match' or an operator like '/'\n\
 296 \n\
 297   ( EXPRESSION )             value of EXPRESSION\n\
 298 "), stdout);
 299       fputs (_("\
 300 \n\
 301 Beware that many operators need to be escaped or quoted for shells.\n\
 302 Comparisons are arithmetic if both ARGs are numbers, else lexicographical.\n\
 303 Pattern matches return the string matched between \\( and \\) or null; if\n\
 304 \\( and \\) are not used, they return the number of characters matched or 0.\n\
 305 "), stdout);
 306       fputs (_("\
 307 \n\
 308 Exit status is 0 if EXPRESSION is neither null nor 0, 1 if EXPRESSION is null\n\
 309 or 0, 2 if EXPRESSION is syntactically invalid, and 3 if an error occurred.\n\
 310 "), stdout);
 311       emit_ancillary_info (PROGRAM_NAME);
 312     }
 313   exit (status);
 314 }
 315
 316
 317 int
 318 main (int argc, char **argv)
 319 {
 320   VALUE *v;
 321
 322   initialize_main (&argc, &argv);
 323   set_program_name (argv[0]);
 324   setlocale (LC_ALL, "");
 325   bindtextdomain (PACKAGE, LOCALEDIR);
 326   textdomain (PACKAGE);
 327
 328   initialize_exit_failure (EXPR_FAILURE);
 329   atexit (close_stdout);
 330
 331   parse_long_options (argc, argv, PROGRAM_NAME, PACKAGE_NAME, VERSION,
 332                       usage, AUTHORS, (char const *) nullptr);
 333
 334   /* The above handles --help and --version.
 335      Since there is no other invocation of getopt, handle '--' here.  */
 336   if (1 < argc && STREQ (argv[1], "--"))
 337     {
 338       --argc;
 339       ++argv;
 340     }
 341
 342   if (argc <= 1)
 343     {
 344       error (0, 0, _("missing operand"));
 345       usage (EXPR_INVALID);
 346     }
 347
 348   args = argv + 1;
 349
 350   v = eval (true);
 351   if (!nomoreargs ())
 352     error (EXPR_INVALID, 0, _("syntax error: unexpected argument %s"),
 353            quotearg_n_style (0, locale_quoting_style, *args));
 354
 355   printv (v);
 356
 357   main_exit (null (v));
 358 }
 359
 360 /* Return a VALUE for I.  */
 361
 362 static VALUE *
 363 int_value (unsigned long int i)
 364 {
 365   VALUE *v = xmalloc (sizeof *v);
 366   v->type = integer;
 367   mpz_init_set_ui (v->u.i, i);
 368   return v;
 369 }
 370
 371 /* Return a VALUE for S.  */
 372
 373 static VALUE *
 374 str_value (char const *s)
 375 {
 376   VALUE *v = xmalloc (sizeof *v);
 377   v->type = string;
 378   v->u.s = xstrdup (s);
 379   return v;
 380 }
 381
 382 /* Free VALUE V, including structure components.  */
 383
 384 static void
 385 freev (VALUE *v)
 386 {
 387   if (v->type == string)
 388     free (v->u.s);
 389   else
 390     mpz_clear (v->u.i);
 391   free (v);
 392 }
 393
 394 /* Print VALUE V.  */
 395
 396 static void
 397 printv (VALUE *v)
 398 {
 399   switch (v->type)
 400     {
 401     case integer:
 402       mpz_out_str (stdout, 10, v->u.i);
 403       putchar ('\n');
 404       break;
 405     case string:
 406       puts (v->u.s);
 407       break;
 408     default:
 409       unreachable ();
 410     }
 411 }
 412
 413 /* Return true if V is a null-string or zero-number.  */
 414
 415 ATTRIBUTE_PURE
 416 static bool
 417 null (VALUE *v)
 418 {
 419   switch (v->type)
 420     {
 421     case integer:
 422       return mpz_sgn (v->u.i) == 0;
 423     case string:
 424       {
 425         char const *cp = v->u.s;
 426         if (*cp == '\0')
 427           return true;
 428
 429         cp += (*cp == '-');
 430
 431         do
 432           {
 433             if (*cp != '0')
 434               return false;
 435           }
 436         while (*++cp);
 437
 438         return true;
 439       }
 440     default:
 441       unreachable ();
 442     }
 443 }
 444
 445 /* Return true if CP takes the form of an integer.  */
 446
 447 ATTRIBUTE_PURE
 448 static bool
 449 looks_like_integer (char const *cp)
 450 {
 451   cp += (*cp == '-');
 452
 453   do
 454     if (! ISDIGIT (*cp))
 455       return false;
 456   while (*++cp);
 457
 458   return true;
 459 }
 460
 461 /* Coerce V to a string value (can't fail).  */
 462
 463 static void
 464 tostring (VALUE *v)
 465 {
 466   switch (v->type)
 467     {
 468     case integer:
 469       {
 470         char *s = mpz_get_str (nullptr, 10, v->u.i);
 471         mpz_clear (v->u.i);
 472         v->u.s = s;
 473         v->type = string;
 474       }
 475       break;
 476     case string:
 477       break;
 478     default:
 479       unreachable ();
 480     }
 481 }
 482
 483 /* Coerce V to an integer value.  Return true on success, false on failure.  */
 484
 485 static bool
 486 toarith (VALUE *v)
 487 {
 488   switch (v->type)
 489     {
 490     case integer:
 491       return true;
 492     case string:
 493       {
 494         char *s = v->u.s;
 495
 496         if (! looks_like_integer (s))
 497           return false;
 498         if (mpz_init_set_str (v->u.i, s, 10) != 0)
 499           error (EXPR_FAILURE, ERANGE, "%s", (s));
 500         free (s);
 501         v->type = integer;
 502         return true;
 503       }
 504     default:
 505       unreachable ();
 506     }
 507 }
 508
 509 /* Extract a size_t value from an integer value I.
 510    If the value is negative, return SIZE_MAX.
 511    If the value is too large, return SIZE_MAX - 1.  */
 512 static size_t
 513 getsize (mpz_t i)
 514 {
 515   if (mpz_sgn (i) < 0)
 516     return SIZE_MAX;
 517   if (mpz_fits_ulong_p (i))
 518     {
 519       unsigned long int ul = mpz_get_ui (i);
 520       if (ul < SIZE_MAX)
 521         return ul;
 522     }
 523   return SIZE_MAX - 1;
 524 }
 525
 526 /* Return true and advance if the next token matches STR exactly.
 527    STR must not be null.  */
 528
 529 static bool
 530 nextarg (char const *str)
 531 {
 532   if (*args == nullptr)
 533     return false;
 534   else
 535     {
 536       bool r = STREQ (*args, str);
 537       args += r;
 538       return r;
 539     }
 540 }
 541
 542 /* Return true if there no more tokens.  */
 543
 544 static bool
 545 nomoreargs (void)
 546 {
 547   return *args == 0;
 548 }
 549
 550 /* Report missing operand.
 551    There is an implicit assumption that there was a previous argument,
 552    and (args-1) is valid. */
 553 static void
 554 require_more_args (void)
 555 {
 556   if (nomoreargs ())
 557     error (EXPR_INVALID, 0, _("syntax error: missing argument after %s"),
 558            quotearg_n_style (0, locale_quoting_style, *(args - 1)));
 559 }
 560
 561
 562 #ifdef EVAL_TRACE
 563 /* Print evaluation trace and args remaining.  */
 564
 565 static void
 566 trace (fxn)
 567      char *fxn;
 568 {
 569   char **a;
 570
 571   printf ("%s:", fxn);
 572   for (a = args; *a; a++)
 573     printf (" %s", *a);
 574   putchar ('\n');
 575 }
 576 #endif
 577
 578 /* Do the : operator.
 579    SV is the VALUE for the lhs (the string),
 580    PV is the VALUE for the rhs (the pattern).  */
 581
 582 static VALUE *
 583 docolon (VALUE *sv, VALUE *pv)
 584 {
 585   VALUE *v;
 586   char const *errmsg;
 587   struct re_pattern_buffer re_buffer;
 588   char fastmap[UCHAR_MAX + 1];
 589   struct re_registers re_regs;
 590   regoff_t matchlen;
 591
 592   tostring (sv);
 593   tostring (pv);
 594
 595   re_regs.num_regs = 0;
 596   re_regs.start = nullptr;
 597   re_regs.end = nullptr;
 598
 599   re_buffer.buffer = nullptr;
 600   re_buffer.allocated = 0;
 601   re_buffer.fastmap = fastmap;
 602   re_buffer.translate = nullptr;
 603   re_syntax_options =
 604     RE_SYNTAX_POSIX_BASIC & ~RE_CONTEXT_INVALID_DUP & ~RE_NO_EMPTY_RANGES;
 605   errmsg = re_compile_pattern (pv->u.s, strlen (pv->u.s), &re_buffer);
 606   if (errmsg)
 607     error (EXPR_INVALID, 0, "%s", (errmsg));
 608   re_buffer.newline_anchor = 0;
 609
 610   matchlen = re_match (&re_buffer, sv->u.s, strlen (sv->u.s), 0, &re_regs);
 611   if (0 <= matchlen)
 612     {
 613       /* Were \(...\) used? */
 614       if (re_buffer.re_nsub > 0)
 615         {
 616           if (re_regs.end[1] < 0)
 617             v = str_value ("");
 618           else
 619             {
 620               sv->u.s[re_regs.end[1]] = '\0';
 621               v = str_value (sv->u.s + re_regs.start[1]);
 622             }
 623         }
 624       else
 625         {
 626           /* In multibyte locales, convert the matched offset (=number of bytes)
 627              to the number of matched characters. */
 628           size_t i = (MB_CUR_MAX == 1
 629                       ? matchlen
 630                       : mbs_offset_to_chars (sv->u.s, matchlen));
 631           v = int_value (i);
 632         }
 633     }
 634   else if (matchlen == -1)
 635     {
 636       /* Match failed -- return the right kind of null.  */
 637       if (re_buffer.re_nsub > 0)
 638         v = str_value ("");
 639       else
 640         v = int_value (0);
 641     }
 642   else
 643     error (EXPR_FAILURE,
 644            matchlen == -2 ? errno : EOVERFLOW,
 645            _("error in regular expression matcher"));
 646
 647   if (0 < re_regs.num_regs)
 648     {
 649       free (re_regs.start);
 650       free (re_regs.end);
 651     }
 652   re_buffer.fastmap = nullptr;
 653   regfree (&re_buffer);
 654   return v;
 655 }
 656
 657 /* Handle bare operands and ( expr ) syntax.  */
 658
 659 static VALUE *
 660 eval7 (bool evaluate)
 661 {
 662   VALUE *v;
 663
 664 #ifdef EVAL_TRACE
 665   trace ("eval7");
 666 #endif
 667   require_more_args ();
 668
 669   if (nextarg ("("))
 670     {
 671       v = eval (evaluate);
 672       if (nomoreargs ())
 673         error (EXPR_INVALID, 0, _("syntax error: expecting ')' after %s"),
 674                quotearg_n_style (0, locale_quoting_style, *(args - 1)));
 675       if (!nextarg (")"))
 676         error (EXPR_INVALID, 0, _("syntax error: expecting ')' instead of %s"),
 677                quotearg_n_style (0, locale_quoting_style, *args));
 678       return v;
 679     }
 680
 681   if (nextarg (")"))
 682     error (EXPR_INVALID, 0, _("syntax error: unexpected ')'"));
 683
 684   return str_value (*args++);
 685 }
 686
 687 /* Handle match, substr, index, and length keywords, and quoting "+".  */
 688
 689 static VALUE *
 690 eval6 (bool evaluate)
 691 {
 692   VALUE *l;
 693   VALUE *r;
 694   VALUE *v;
 695   VALUE *i1;
 696   VALUE *i2;
 697
 698 #ifdef EVAL_TRACE
 699   trace ("eval6");
 700 #endif
 701   if (nextarg ("+"))
 702     {
 703       require_more_args ();
 704       return str_value (*args++);
 705     }
 706   else if (nextarg ("length"))
 707     {
 708       r = eval6 (evaluate);
 709       tostring (r);
 710       v = int_value (mbslen (r->u.s));
 711       freev (r);
 712       return v;
 713     }
 714   else if (nextarg ("match"))
 715     {
 716       l = eval6 (evaluate);
 717       r = eval6 (evaluate);
 718       if (evaluate)
 719         {
 720           v = docolon (l, r);
 721           freev (l);
 722         }
 723       else
 724         v = l;
 725       freev (r);
 726       return v;
 727     }
 728   else if (nextarg ("index"))
 729     {
 730       size_t pos;
 731
 732       l = eval6 (evaluate);
 733       r = eval6 (evaluate);
 734       tostring (l);
 735       tostring (r);
 736       pos = mbs_logical_cspn (l->u.s, r->u.s);
 737       v = int_value (pos);
 738       freev (l);
 739       freev (r);
 740       return v;
 741     }
 742   else if (nextarg ("substr"))
 743     {
 744       l = eval6 (evaluate);
 745       i1 = eval6 (evaluate);
 746       i2 = eval6 (evaluate);
 747       tostring (l);
 748
 749       if (!toarith (i1) || !toarith (i2))
 750         v = str_value ("");
 751       else
 752         {
 753           size_t pos = getsize (i1->u.i);
 754           size_t len = getsize (i2->u.i);
 755
 756           char *s = mbs_logical_substr (l->u.s, pos, len);
 757           v = str_value (s);
 758           free (s);
 759         }
 760       freev (l);
 761       freev (i1);
 762       freev (i2);
 763       return v;
 764     }
 765   else
 766     return eval7 (evaluate);
 767 }
 768
 769 /* Handle : operator (pattern matching).
 770    Calls docolon to do the real work.  */
 771
 772 static VALUE *
 773 eval5 (bool evaluate)
 774 {
 775   VALUE *l;
 776   VALUE *r;
 777   VALUE *v;
 778
 779 #ifdef EVAL_TRACE
 780   trace ("eval5");
 781 #endif
 782   l = eval6 (evaluate);
 783   while (true)
 784     {
 785       if (nextarg (":"))
 786         {
 787           r = eval6 (evaluate);
 788           if (evaluate)
 789             {
 790               v = docolon (l, r);
 791               freev (l);
 792               l = v;
 793             }
 794           freev (r);
 795         }
 796       else
 797         return l;
 798     }
 799 }
 800
 801 /* Handle *, /, % operators.  */
 802
 803 static VALUE *
 804 eval4 (bool evaluate)
 805 {
 806   VALUE *l;
 807   VALUE *r;
 808   enum { multiply, divide, mod } fxn;
 809
 810 #ifdef EVAL_TRACE
 811   trace ("eval4");
 812 #endif
 813   l = eval5 (evaluate);
 814   while (true)
 815     {
 816       if (nextarg ("*"))
 817         fxn = multiply;
 818       else if (nextarg ("/"))
 819         fxn = divide;
 820       else if (nextarg ("%"))
 821         fxn = mod;
 822       else
 823         return l;
 824       r = eval5 (evaluate);
 825       if (evaluate)
 826         {
 827           if (!toarith (l) || !toarith (r))
 828             error (EXPR_INVALID, 0, _("non-integer argument"));
 829           if (fxn != multiply && mpz_sgn (r->u.i) == 0)
 830             error (EXPR_INVALID, 0, _("division by zero"));
 831           ((fxn == multiply ? mpz_mul
 832             : fxn == divide ? mpz_tdiv_q
 833             : mpz_tdiv_r)
 834            (l->u.i, l->u.i, r->u.i));
 835         }
 836       freev (r);
 837     }
 838 }
 839
 840 /* Handle +, - operators.  */
 841
 842 static VALUE *
 843 eval3 (bool evaluate)
 844 {
 845   VALUE *l;
 846   VALUE *r;
 847   enum { plus, minus } fxn;
 848
 849 #ifdef EVAL_TRACE
 850   trace ("eval3");
 851 #endif
 852   l = eval4 (evaluate);
 853   while (true)
 854     {
 855       if (nextarg ("+"))
 856         fxn = plus;
 857       else if (nextarg ("-"))
 858         fxn = minus;
 859       else
 860         return l;
 861       r = eval4 (evaluate);
 862       if (evaluate)
 863         {
 864           if (!toarith (l) || !toarith (r))
 865             error (EXPR_INVALID, 0, _("non-integer argument"));
 866           (fxn == plus ? mpz_add : mpz_sub) (l->u.i, l->u.i, r->u.i);
 867         }
 868       freev (r);
 869     }
 870 }
 871
 872 /* Handle comparisons.  */
 873
 874 static VALUE *
 875 eval2 (bool evaluate)
 876 {
 877   VALUE *l;
 878
 879 #ifdef EVAL_TRACE
 880   trace ("eval2");
 881 #endif
 882   l = eval3 (evaluate);
 883   while (true)
 884     {
 885       VALUE *r;
 886       enum
 887         {
 888           less_than, less_equal, equal, not_equal, greater_equal, greater_than
 889         } fxn;
 890       bool val = false;
 891
 892       if (nextarg ("<"))
 893         fxn = less_than;
 894       else if (nextarg ("<="))
 895         fxn = less_equal;
 896       else if (nextarg ("=") || nextarg ("=="))
 897         fxn = equal;
 898       else if (nextarg ("!="))
 899         fxn = not_equal;
 900       else if (nextarg (">="))
 901         fxn = greater_equal;
 902       else if (nextarg (">"))
 903         fxn = greater_than;
 904       else
 905         return l;
 906       r = eval3 (evaluate);
 907
 908       if (evaluate)
 909         {
 910           int cmp;
 911           tostring (l);
 912           tostring (r);
 913
 914           if (looks_like_integer (l->u.s) && looks_like_integer (r->u.s))
 915             cmp = strintcmp (l->u.s, r->u.s);
 916           else
 917             {
 918               errno = 0;
 919               cmp = strcoll (l->u.s, r->u.s);
 920
 921               if (errno)
 922                 {
 923                   error (0, errno, _("string comparison failed"));
 924                   error (0, 0, _("set LC_ALL='C' to work around the problem"));
 925                   error (EXPR_INVALID, 0,
 926                          _("the strings compared were %s and %s"),
 927                          quotearg_n_style (0, locale_quoting_style, l->u.s),
 928                          quotearg_n_style (1, locale_quoting_style, r->u.s));
 929                 }
 930             }
 931
 932           switch (fxn)
 933             {
 934             case less_than:     val = (cmp <  0); break;
 935             case less_equal:    val = (cmp <= 0); break;
 936             case equal:         val = (cmp == 0); break;
 937             case not_equal:     val = (cmp != 0); break;
 938             case greater_equal: val = (cmp >= 0); break;
 939             case greater_than:  val = (cmp >  0); break;
 940             default: unreachable ();
 941             }
 942         }
 943
 944       freev (l);
 945       freev (r);
 946       l = int_value (val);
 947     }
 948 }
 949
 950 /* Handle &.  */
 951
 952 static VALUE *
 953 eval1 (bool evaluate)
 954 {
 955   VALUE *l;
 956   VALUE *r;
 957
 958 #ifdef EVAL_TRACE
 959   trace ("eval1");
 960 #endif
 961   l = eval2 (evaluate);
 962   while (true)
 963     {
 964       if (nextarg ("&"))
 965         {
 966           r = eval2 (evaluate && !null (l));
 967           if (null (l) || null (r))
 968             {
 969               freev (l);
 970               freev (r);
 971               l = int_value (0);
 972             }
 973           else
 974             freev (r);
 975         }
 976       else
 977         return l;
 978     }
 979 }
 980
 981 /* Handle |.  */
 982
 983 static VALUE *
 984 eval (bool evaluate)
 985 {
 986   VALUE *l;
 987   VALUE *r;
 988
 989 #ifdef EVAL_TRACE
 990   trace ("eval");
 991 #endif
 992   l = eval1 (evaluate);
 993   while (true)
 994     {
 995       if (nextarg ("|"))
 996         {
 997           r = eval1 (evaluate && null (l));
 998           if (null (l))
 999             {
1000               freev (l);
1001               l = r;
1002               if (null (l))
1003                 {
1004                   freev (l);
1005                   l = int_value (0);
1006                 }
1007             }
1008           else
1009             freev (r);
1010         }
1011       else
1012         return l;
1013     }
1014 }