gcc/cppexp.c

   1 /* Parse C expressions for CCCP.
   2    Copyright (C) 1987, 1992, 1994, 1995, 1997, 1998 Free Software Foundation.
   3
   4 This program is free software; you can redistribute it and/or modify it
   5 under the terms of the GNU General Public License as published by the
   6 Free Software Foundation; either version 2, or (at your option) any
   7 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, write to the Free Software
  16 Foundation, 59 Temple Place - Suite 330,
  17 Boston, MA 02111-1307, USA.
  18
  19  In other words, you are welcome to use, share and improve this program.
  20  You are forbidden to forbid anyone else to use, share and improve
  21  what you give them.   Help stamp out software-hoarding!
  22
  23 Written by Per Bothner 1994.  */
  24
  25 /* Parse a C expression from text in a string  */
  26
  27 #include "config.h"
  28 #include "system.h"
  29 #include "cpplib.h"
  30
  31 #ifdef MULTIBYTE_CHARS
  32 #include <locale.h>
  33 #endif
  34
  35 #ifndef CHAR_TYPE_SIZE
  36 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  37 #endif
  38
  39 #ifndef INT_TYPE_SIZE
  40 #define INT_TYPE_SIZE BITS_PER_WORD
  41 #endif
  42
  43 #ifndef LONG_TYPE_SIZE
  44 #define LONG_TYPE_SIZE BITS_PER_WORD
  45 #endif
  46
  47 #ifndef WCHAR_TYPE_SIZE
  48 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
  49 #endif
  50
  51 #ifndef MAX_CHAR_TYPE_SIZE
  52 #define MAX_CHAR_TYPE_SIZE CHAR_TYPE_SIZE
  53 #endif
  54
  55 #ifndef MAX_INT_TYPE_SIZE
  56 #define MAX_INT_TYPE_SIZE INT_TYPE_SIZE
  57 #endif
  58
  59 #ifndef MAX_LONG_TYPE_SIZE
  60 #define MAX_LONG_TYPE_SIZE LONG_TYPE_SIZE
  61 #endif
  62
  63 #ifndef MAX_WCHAR_TYPE_SIZE
  64 #define MAX_WCHAR_TYPE_SIZE WCHAR_TYPE_SIZE
  65 #endif
  66
  67 #define MAX_CHAR_TYPE_MASK (MAX_CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT \
  68                             ? (~ (~ (HOST_WIDE_INT) 0 << MAX_CHAR_TYPE_SIZE)) \
  69                             : ~ (HOST_WIDE_INT) 0)
  70
  71 #define MAX_WCHAR_TYPE_MASK (MAX_WCHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT \
  72                              ? ~ (~ (HOST_WIDE_INT) 0 << MAX_WCHAR_TYPE_SIZE) \
  73                              : ~ (HOST_WIDE_INT) 0)
  74
  75 /* Yield nonzero if adding two numbers with A's and B's signs can yield a
  76    number with SUM's sign, where A, B, and SUM are all C integers.  */
  77 #define possible_sum_sign(a, b, sum) ((((a) ^ (b)) | ~ ((a) ^ (sum))) < 0)
  78
  79 static void integer_overflow PARAMS ((cpp_reader *));
  80 static long left_shift PARAMS ((cpp_reader *, long, int, unsigned long));
  81 static long right_shift PARAMS ((cpp_reader *, long, int, unsigned long));
  82
  83 #define ERROR 299
  84 #define OROR 300
  85 #define ANDAND 301
  86 #define EQUAL 302
  87 #define NOTEQUAL 303
  88 #define LEQ 304
  89 #define GEQ 305
  90 #define LSH 306
  91 #define RSH 307
  92 #define NAME 308
  93 #define INT 309
  94 #define CHAR 310
  95
  96 #define LEFT_OPERAND_REQUIRED 1
  97 #define RIGHT_OPERAND_REQUIRED 2
  98 #define HAVE_VALUE 4
  99 /* SKIP_OPERAND is set for '&&' '||' '?' and ':' when the
 100    following operand should be short-circuited instead of evaluated.  */
 101 #define SKIP_OPERAND 8
 102 /*#define UNSIGNEDP 16*/
 103
 104 #ifndef CHAR_BIT
 105 #define CHAR_BIT 8
 106 #endif
 107
 108 #ifndef HOST_BITS_PER_WIDE_INT
 109 #define HOST_BITS_PER_WIDE_INT (CHAR_BIT * sizeof (HOST_WIDE_INT))
 110 #endif
 111
 112 struct operation {
 113     short op;
 114     char rprio; /* Priority of op (relative to it right operand).  */
 115     char flags;
 116     char unsignedp;    /* true if value should be treated as unsigned */
 117     HOST_WIDE_INT value;        /* The value logically "right" of op.  */
 118 };
 119
 120 /* Parse and convert an integer for #if.  Accepts decimal, hex, or octal
 121    with or without size suffixes.  */
 122
 123 static struct operation
 124 parse_number (pfile, start, end)
 125      cpp_reader *pfile;
 126      U_CHAR *start;
 127      U_CHAR *end;
 128 {
 129   struct operation op;
 130   U_CHAR *p = start;
 131   int c;
 132   unsigned HOST_WIDE_INT n = 0, nd, MAX_over_base;
 133   int base = 10;
 134   int overflow = 0;
 135   int digit, largest_digit = 0;
 136   int spec_long = 0;
 137
 138   op.unsignedp = 0;
 139
 140   if (p[0] == '0')
 141     {
 142       if (end - start >= 3 && (p[1] == 'x' || p[1] == 'X'))
 143         {
 144           p += 2;
 145           base = 16;
 146         }
 147       else
 148         {
 149           p += 1;
 150           base = 8;
 151         }
 152     }
 153
 154   /* Some buggy compilers (e.g. MPW C) seem to need both casts.  */
 155   MAX_over_base = (((unsigned HOST_WIDE_INT) -1)
 156                    / ((unsigned HOST_WIDE_INT) base));
 157
 158   while (p < end)
 159     {
 160       c = *p++;
 161
 162       if (c >= '0' && c <= '9')
 163         digit = c - '0';
 164       else if (base == 16 && c >= 'a' && c <= 'f') /* FIXME: assumes ASCII */
 165         digit = c - 'a' + 10;
 166       else if (base == 16 && c >= 'A' && c <= 'F')
 167         digit = c - 'A' + 10;
 168       else if (c == '.')
 169         {
 170           /* It's a float since it contains a point.  */
 171           cpp_error (pfile,
 172                 "floating point numbers are not allowed in #if expressions");
 173           goto error;
 174         }
 175       else
 176         {
 177           /* `l' means long, and `u' means unsigned.  */
 178           for (;;)
 179             {
 180               if (c == 'l' || c == 'L')
 181                   spec_long++;
 182               else if (c == 'u' || c == 'U')
 183                   op.unsignedp++;
 184               else
 185                 {
 186                   /* Decrement p here so that the error for an invalid number
 187                      will be generated below in the case where this is the
 188                      last character in the buffer.  */
 189                   p--;
 190                   break;
 191                 }
 192               if (p == end)
 193                 break;
 194               c = *p++;
 195             }
 196           /* Don't look for any more digits after the suffixes.  */
 197           break;
 198         }
 199
 200       if (largest_digit < digit)
 201         largest_digit = digit;
 202       nd = n * base + digit;
 203       overflow |= MAX_over_base < n || nd < n;
 204       n = nd;
 205     }
 206
 207   if (p != end)
 208     {
 209       cpp_error (pfile, "invalid number in #if expression");
 210       goto error;
 211     }
 212   else if (spec_long > (CPP_OPTIONS (pfile)->c89 ? 1 : 2))
 213     {
 214       cpp_error (pfile, "too many `l' suffixes in integer constant");
 215       goto error;
 216     }
 217   else if (op.unsignedp > 1)
 218     {
 219       cpp_error (pfile, "too many `u' suffixes in integer constant");
 220       goto error;
 221     }
 222
 223   if (base <= largest_digit)
 224     cpp_pedwarn (pfile, "integer constant contains digits beyond the radix");
 225
 226   if (overflow)
 227     cpp_pedwarn (pfile, "integer constant out of range");
 228
 229   /* If too big to be signed, consider it unsigned.  */
 230   else if ((HOST_WIDE_INT) n < 0 && ! op.unsignedp)
 231     {
 232       if (base == 10)
 233         cpp_warning (pfile,
 234                      "integer constant is so large that it is unsigned");
 235       op.unsignedp = 1;
 236     }
 237
 238   op.value = n;
 239   op.op = INT;
 240   return op;
 241
 242  error:
 243   op.op = ERROR;
 244   return op;
 245 }
 246
 247 /* Parse and convert a character constant for #if.  Understands backslash
 248    escapes (\n, \031) and multibyte characters (if so configured).  */
 249 static struct operation
 250 parse_charconst (pfile, start, end)
 251      cpp_reader *pfile;
 252      U_CHAR *start;
 253      U_CHAR *end;
 254 {
 255   struct operation op;
 256   HOST_WIDE_INT result = 0;
 257   int num_chars = 0;
 258   int num_bits;
 259   unsigned int width = MAX_CHAR_TYPE_SIZE, mask = MAX_CHAR_TYPE_MASK;
 260   int max_chars;
 261   U_CHAR *ptr = start;
 262
 263   /* FIXME: Should use reentrant multibyte functions.  */
 264 #ifdef MULTIBYTE_CHARS
 265   wchar_t c;
 266   (void) mbtowc (NULL_PTR, NULL_PTR, 0);
 267 #else
 268   int c;
 269 #endif
 270
 271   if (*ptr == 'L')
 272     {
 273       ++ptr;
 274       width = MAX_WCHAR_TYPE_SIZE, mask = MAX_WCHAR_TYPE_MASK;
 275     }
 276   max_chars = MAX_LONG_TYPE_SIZE / width;
 277
 278   ++ptr;  /* skip initial quote */
 279
 280   while (ptr < end)
 281     {
 282 #ifndef MULTIBYTE_CHARS
 283       c = *ptr++;
 284 #else
 285       ptr += mbtowc (&c, ptr, end - ptr);
 286 #endif
 287       if (c == '\'' || c == '\0')
 288         break;
 289       else if (c == '\\')
 290         {
 291           /* Hopefully valid assumption: if mbtowc returns a backslash,
 292              we are in initial shift state.  No valid escape-sequence
 293              character can take us out of initial shift state or begin
 294              an unshifted multibyte char, so cpp_parse_escape doesn't
 295              need to know about multibyte chars.  */
 296
 297           c = cpp_parse_escape (pfile, (char **) &ptr, mask);
 298           if (width < HOST_BITS_PER_INT
 299               && (unsigned int) c >= (unsigned int)(1 << width))
 300             cpp_pedwarn (pfile, "escape sequence out of range for character");
 301         }
 302
 303       /* Merge character into result; ignore excess chars.  */
 304       if (++num_chars <= max_chars)
 305         {
 306           if (width < HOST_BITS_PER_INT)
 307             result = (result << width) | (c & ((1 << width) - 1));
 308           else
 309             result = c;
 310         }
 311     }
 312
 313   if (num_chars == 0)
 314     {
 315       cpp_error (pfile, "empty character constant");
 316       goto error;
 317     }
 318   else if (c != '\'')
 319     {
 320       /* cpp_get_token has already emitted an error if !traditional. */
 321       if (! CPP_TRADITIONAL (pfile))
 322         cpp_error (pfile, "malformatted character constant");
 323       goto error;
 324     }
 325   else if (num_chars > max_chars)
 326     {
 327       cpp_error (pfile, "character constant too long");
 328       goto error;
 329     }
 330   else if (num_chars != 1 && ! CPP_TRADITIONAL (pfile))
 331     cpp_warning (pfile, "multi-character character constant");
 332
 333   /* If char type is signed, sign-extend the constant.  */
 334   num_bits = num_chars * width;
 335
 336   if (cpp_lookup (pfile, (U_CHAR *)"__CHAR_UNSIGNED__",
 337                   sizeof ("__CHAR_UNSIGNED__")-1, -1)
 338       || ((result >> (num_bits - 1)) & 1) == 0)
 339     op.value = result & ((unsigned long) ~0
 340                          >> (HOST_BITS_PER_LONG - num_bits));
 341   else
 342     op.value = result | ~((unsigned long) ~0
 343                           >> (HOST_BITS_PER_LONG - num_bits));
 344
 345   /* This is always a signed type.  */
 346   op.unsignedp = 0;
 347   op.op = CHAR;
 348   return op;
 349
 350  error:
 351   op.op = ERROR;
 352   return op;
 353 }
 354
 355
 356 struct token {
 357   char *operator;
 358   int token;
 359 };
 360
 361 static struct token tokentab2[] = {
 362   {"&&", ANDAND},
 363   {"||", OROR},
 364   {"<<", LSH},
 365   {">>", RSH},
 366   {"==", EQUAL},
 367   {"!=", NOTEQUAL},
 368   {"<=", LEQ},
 369   {">=", GEQ},
 370   {"++", ERROR},
 371   {"--", ERROR},
 372   {NULL, ERROR}
 373 };
 374
 375 /* Read one token.  */
 376
 377 struct operation
 378 cpp_lex (pfile, skip_evaluation)
 379      cpp_reader *pfile;
 380      int skip_evaluation;
 381 {
 382   U_CHAR c;
 383   struct token *toktab;
 384   enum cpp_token token;
 385   struct operation op;
 386   U_CHAR *tok_start, *tok_end;
 387   int old_written;
 388
 389  retry:
 390
 391   old_written = CPP_WRITTEN (pfile);
 392   cpp_skip_hspace (pfile);
 393   c = CPP_BUF_PEEK (CPP_BUFFER (pfile));
 394   if (c == '#')
 395     {
 396       op.op = INT;
 397       op.value = cpp_read_check_assertion (pfile);
 398       return op;
 399     }
 400
 401   if (c == '\n')
 402     {
 403       op.op = 0;
 404       return op;
 405     }
 406
 407   token = cpp_get_token (pfile);
 408   tok_start = pfile->token_buffer + old_written;
 409   tok_end = CPP_PWRITTEN (pfile);
 410   pfile->limit = tok_start;
 411   switch (token)
 412   {
 413     case CPP_EOF: /* Should not happen ...  */
 414     case CPP_VSPACE:
 415       op.op = 0;
 416       return op;
 417     case CPP_POP:
 418       if (CPP_BUFFER (pfile)->fname != NULL)
 419         {
 420           op.op = 0;
 421           return op;
 422         }
 423       cpp_pop_buffer (pfile);
 424       goto retry;
 425     case CPP_HSPACE:
 426     case CPP_COMMENT:
 427       goto retry;
 428     case CPP_NUMBER:
 429       return parse_number (pfile, tok_start, tok_end);
 430     case CPP_STRING:
 431       cpp_error (pfile, "string constants not allowed in #if expressions");
 432       op.op = ERROR;
 433       return op;
 434     case CPP_CHAR:
 435       return parse_charconst (pfile, tok_start, tok_end);
 436
 437     case CPP_NAME:
 438       if (CPP_WARN_UNDEF (pfile) && !skip_evaluation)
 439         cpp_warning (pfile, "`%.*s' is not defined",
 440                      (int) (tok_end - tok_start), tok_start);
 441       op.op = INT;
 442       op.unsignedp = 0;
 443       op.value = 0;
 444       return op;
 445
 446     case CPP_OTHER:
 447       /* See if it is a special token of length 2.  */
 448       if (tok_start + 2 == tok_end)
 449         {
 450           for (toktab = tokentab2; toktab->operator != NULL; toktab++)
 451             if (tok_start[0] == toktab->operator[0]
 452                 && tok_start[1] == toktab->operator[1])
 453                 break;
 454           if (toktab->token == ERROR)
 455             {
 456               char *buf = (char *) alloca (40);
 457               sprintf (buf, "`%s' not allowed in operand of `#if'", tok_start);
 458               cpp_error (pfile, buf);
 459             }
 460           op.op = toktab->token;
 461           return op;
 462         }
 463       /* fall through */
 464     default:
 465       op.op = *tok_start;
 466       return op;
 467   }
 468 }
 469
 470
 471 /* Parse a C escape sequence.  STRING_PTR points to a variable
 472    containing a pointer to the string to parse.  That pointer
 473    is updated past the characters we use.  The value of the
 474    escape sequence is returned.
 475
 476    A negative value means the sequence \ newline was seen,
 477    which is supposed to be equivalent to nothing at all.
 478
 479    If \ is followed by a null character, we return a negative
 480    value and leave the string pointer pointing at the null character.
 481
 482    If \ is followed by 000, we return 0 and leave the string pointer
 483    after the zeros.  A value of 0 does not mean end of string.  */
 484
 485 HOST_WIDE_INT
 486 cpp_parse_escape (pfile, string_ptr, result_mask)
 487      cpp_reader *pfile;
 488      char **string_ptr;
 489      HOST_WIDE_INT result_mask;
 490 {
 491   register int c = *(*string_ptr)++;
 492   switch (c)
 493     {
 494     case 'a':
 495       return TARGET_BELL;
 496     case 'b':
 497       return TARGET_BS;
 498     case 'e':
 499     case 'E':
 500       if (CPP_OPTIONS (pfile)->pedantic)
 501         cpp_pedwarn (pfile, "non-ANSI-standard escape sequence, `\\%c'", c);
 502       return 033;
 503     case 'f':
 504       return TARGET_FF;
 505     case 'n':
 506       return TARGET_NEWLINE;
 507     case 'r':
 508       return TARGET_CR;
 509     case 't':
 510       return TARGET_TAB;
 511     case 'v':
 512       return TARGET_VT;
 513     case '\n':
 514       return -2;
 515     case 0:
 516       (*string_ptr)--;
 517       return 0;
 518
 519     case '0':
 520     case '1':
 521     case '2':
 522     case '3':
 523     case '4':
 524     case '5':
 525     case '6':
 526     case '7':
 527       {
 528         register HOST_WIDE_INT i = c - '0';
 529         register int count = 0;
 530         while (++count < 3)
 531           {
 532             c = *(*string_ptr)++;
 533             if (c >= '0' && c <= '7')
 534               i = (i << 3) + c - '0';
 535             else
 536               {
 537                 (*string_ptr)--;
 538                 break;
 539               }
 540           }
 541         if (i != (i & result_mask))
 542           {
 543             i &= result_mask;
 544             cpp_pedwarn (pfile, "octal escape sequence out of range");
 545           }
 546         return i;
 547       }
 548     case 'x':
 549       {
 550         register unsigned HOST_WIDE_INT i = 0, overflow = 0;
 551         register int digits_found = 0, digit;
 552         for (;;)
 553           {
 554             c = *(*string_ptr)++;
 555             if (c >= '0' && c <= '9')
 556               digit = c - '0';
 557             else if (c >= 'a' && c <= 'f')
 558               digit = c - 'a' + 10;
 559             else if (c >= 'A' && c <= 'F')
 560               digit = c - 'A' + 10;
 561             else
 562               {
 563                 (*string_ptr)--;
 564                 break;
 565               }
 566             overflow |= i ^ (i << 4 >> 4);
 567             i = (i << 4) + digit;
 568             digits_found = 1;
 569           }
 570         if (!digits_found)
 571           cpp_error (pfile, "\\x used with no following hex digits");
 572         if (overflow | (i != (i & result_mask)))
 573           {
 574             i &= result_mask;
 575             cpp_pedwarn (pfile, "hex escape sequence out of range");
 576           }
 577         return i;
 578       }
 579     default:
 580       return c;
 581     }
 582 }
 583
 584 static void
 585 integer_overflow (pfile)
 586      cpp_reader *pfile;
 587 {
 588   if (CPP_PEDANTIC (pfile))
 589     cpp_pedwarn (pfile, "integer overflow in preprocessor expression");
 590 }
 591
 592 static long
 593 left_shift (pfile, a, unsignedp, b)
 594      cpp_reader *pfile;
 595      long a;
 596      int unsignedp;
 597      unsigned long b;
 598 {
 599   if (b >= HOST_BITS_PER_LONG)
 600     {
 601       if (! unsignedp && a != 0)
 602         integer_overflow (pfile);
 603       return 0;
 604     }
 605   else if (unsignedp)
 606     return (unsigned long) a << b;
 607   else
 608     {
 609       long l = a << b;
 610       if (l >> b != a)
 611         integer_overflow (pfile);
 612       return l;
 613     }
 614 }
 615
 616 static long
 617 right_shift (pfile, a, unsignedp, b)
 618      cpp_reader *pfile ATTRIBUTE_UNUSED;
 619      long a;
 620      int unsignedp;
 621      unsigned long b;
 622 {
 623   if (b >= HOST_BITS_PER_LONG)
 624     return unsignedp ? 0 : a >> (HOST_BITS_PER_LONG - 1);
 625   else if (unsignedp)
 626     return (unsigned long) a >> b;
 627   else
 628     return a >> b;
 629 }
 630 \f
 631 /* These priorities are all even, so we can handle associatively.  */
 632 #define PAREN_INNER_PRIO 0
 633 #define COMMA_PRIO 4
 634 #define COND_PRIO (COMMA_PRIO+2)
 635 #define OROR_PRIO (COND_PRIO+2)
 636 #define ANDAND_PRIO (OROR_PRIO+2)
 637 #define OR_PRIO (ANDAND_PRIO+2)
 638 #define XOR_PRIO (OR_PRIO+2)
 639 #define AND_PRIO (XOR_PRIO+2)
 640 #define EQUAL_PRIO (AND_PRIO+2)
 641 #define LESS_PRIO (EQUAL_PRIO+2)
 642 #define SHIFT_PRIO (LESS_PRIO+2)
 643 #define PLUS_PRIO (SHIFT_PRIO+2)
 644 #define MUL_PRIO (PLUS_PRIO+2)
 645 #define UNARY_PRIO (MUL_PRIO+2)
 646 #define PAREN_OUTER_PRIO (UNARY_PRIO+2)
 647
 648 #define COMPARE(OP) \
 649   top->unsignedp = 0;\
 650   top->value = (unsigned1 || unsigned2) \
 651   ? (unsigned long) v1 OP (unsigned long) v2 : (v1 OP v2)
 652
 653 /* Parse and evaluate a C expression, reading from PFILE.
 654    Returns the value of the expression.  */
 655
 656 HOST_WIDE_INT
 657 cpp_parse_expr (pfile)
 658      cpp_reader *pfile;
 659 {
 660   /* The implementation is an operator precedence parser,
 661      i.e. a bottom-up parser, using a stack for not-yet-reduced tokens.
 662
 663      The stack base is 'stack', and the current stack pointer is 'top'.
 664      There is a stack element for each operator (only),
 665      and the most recently pushed operator is 'top->op'.
 666      An operand (value) is stored in the 'value' field of the stack
 667      element of the operator that precedes it.
 668      In that case the 'flags' field has the HAVE_VALUE flag set.  */
 669
 670 #define INIT_STACK_SIZE 20
 671   struct operation init_stack[INIT_STACK_SIZE];
 672   struct operation *stack = init_stack;
 673   struct operation *limit = stack + INIT_STACK_SIZE;
 674   register struct operation *top = stack;
 675   int lprio, rprio;
 676   int skip_evaluation = 0;
 677
 678   top->rprio = 0;
 679   top->flags = 0;
 680   for (;;)
 681     {
 682       struct operation op;
 683       char flags = 0;
 684
 685       /* Read a token */
 686       op =  cpp_lex (pfile, skip_evaluation);
 687
 688       /* See if the token is an operand, in which case go to set_value.
 689          If the token is an operator, figure out its left and right
 690          priorities, and then goto maybe_reduce.  */
 691
 692       switch (op.op)
 693         {
 694         case NAME:
 695           abort ();
 696         case INT:  case CHAR:
 697           top->value = op.value;
 698           top->unsignedp = op.unsignedp;
 699           goto set_value;
 700         case 0:
 701           lprio = 0;  goto maybe_reduce;
 702         case '+':  case '-':
 703           /* Is this correct if unary ? FIXME */
 704           flags = RIGHT_OPERAND_REQUIRED;
 705           lprio = PLUS_PRIO;  rprio = lprio + 1;  goto maybe_reduce;
 706         case '!':  case '~':
 707           flags = RIGHT_OPERAND_REQUIRED;
 708           rprio = UNARY_PRIO;  lprio = rprio + 1;  goto maybe_reduce;
 709         case '*':  case '/':  case '%':
 710           lprio = MUL_PRIO;  goto binop;
 711         case '<':  case '>':  case LEQ:  case GEQ:
 712           lprio = LESS_PRIO;  goto binop;
 713         case EQUAL:  case NOTEQUAL:
 714           lprio = EQUAL_PRIO;  goto binop;
 715         case LSH:  case RSH:
 716           lprio = SHIFT_PRIO;  goto binop;
 717         case '&':  lprio = AND_PRIO;  goto binop;
 718         case '^':  lprio = XOR_PRIO;  goto binop;
 719         case '|':  lprio = OR_PRIO;  goto binop;
 720         case ANDAND:  lprio = ANDAND_PRIO;  goto binop;
 721         case OROR:  lprio = OROR_PRIO;  goto binop;
 722         case ',':
 723           lprio = COMMA_PRIO;  goto binop;
 724         case '(':
 725           lprio = PAREN_OUTER_PRIO;  rprio = PAREN_INNER_PRIO;
 726           goto maybe_reduce;
 727         case ')':
 728           lprio = PAREN_INNER_PRIO;  rprio = PAREN_OUTER_PRIO;
 729           goto maybe_reduce;
 730         case ':':
 731           lprio = COND_PRIO;  rprio = COND_PRIO;
 732           goto maybe_reduce;
 733         case '?':
 734           lprio = COND_PRIO + 1;  rprio = COND_PRIO;
 735           goto maybe_reduce;
 736         case ERROR:
 737           goto syntax_error;
 738         binop:
 739           flags = LEFT_OPERAND_REQUIRED|RIGHT_OPERAND_REQUIRED;
 740           rprio = lprio + 1;
 741           goto maybe_reduce;
 742         default:
 743           cpp_error (pfile, "invalid character in #if");
 744           goto syntax_error;
 745         }
 746
 747     set_value:
 748       /* Push a value onto the stack.  */
 749       if (top->flags & HAVE_VALUE)
 750         {
 751           cpp_error (pfile, "syntax error in #if");
 752           goto syntax_error;
 753         }
 754       top->flags |= HAVE_VALUE;
 755       continue;
 756
 757     maybe_reduce:
 758       /* Push an operator, and check if we can reduce now.  */
 759       while (top->rprio > lprio)
 760         {
 761           long v1 = top[-1].value, v2 = top[0].value;
 762           int unsigned1 = top[-1].unsignedp, unsigned2 = top[0].unsignedp;
 763           top--;
 764           if ((top[1].flags & LEFT_OPERAND_REQUIRED)
 765               && ! (top[0].flags & HAVE_VALUE))
 766             {
 767               cpp_error (pfile, "syntax error - missing left operand");
 768               goto syntax_error;
 769             }
 770           if ((top[1].flags & RIGHT_OPERAND_REQUIRED)
 771               && ! (top[1].flags & HAVE_VALUE))
 772             {
 773               cpp_error (pfile, "syntax error - missing right operand");
 774               goto syntax_error;
 775             }
 776           /* top[0].value = (top[1].op)(v1, v2);*/
 777           switch (top[1].op)
 778             {
 779             case '+':
 780               if (!(top->flags & HAVE_VALUE))
 781                 { /* Unary '+' */
 782                   top->value = v2;
 783                   top->unsignedp = unsigned2;
 784                   top->flags |= HAVE_VALUE;
 785                 }
 786               else
 787                 {
 788                   top->value = v1 + v2;
 789                   top->unsignedp = unsigned1 || unsigned2;
 790                   if (! top->unsignedp && ! skip_evaluation
 791                       && ! possible_sum_sign (v1, v2, top->value))
 792                     integer_overflow (pfile);
 793                 }
 794               break;
 795             case '-':
 796               if (!(top->flags & HAVE_VALUE))
 797                 { /* Unary '-' */
 798                   top->value = - v2;
 799                   if (!skip_evaluation && (top->value & v2) < 0 && !unsigned2)
 800                     integer_overflow (pfile);
 801                   top->unsignedp = unsigned2;
 802                   top->flags |= HAVE_VALUE;
 803                 }
 804               else
 805                 { /* Binary '-' */
 806                   top->value = v1 - v2;
 807                   top->unsignedp = unsigned1 || unsigned2;
 808                   if (! top->unsignedp && ! skip_evaluation
 809                       && ! possible_sum_sign (top->value, v2, v1))
 810                     integer_overflow (pfile);
 811                 }
 812               break;
 813             case '*':
 814               top->unsignedp = unsigned1 || unsigned2;
 815               if (top->unsignedp)
 816                 top->value = (unsigned long) v1 * v2;
 817               else if (!skip_evaluation)
 818                 {
 819                   top->value = v1 * v2;
 820                   if (v1
 821                       && (top->value / v1 != v2
 822                           || (top->value & v1 & v2) < 0))
 823                     integer_overflow (pfile);
 824                 }
 825               break;
 826             case '/':
 827               if (skip_evaluation)
 828                 break;
 829               if (v2 == 0)
 830                 {
 831                   cpp_error (pfile, "division by zero in #if");
 832                   v2 = 1;
 833                 }
 834               top->unsignedp = unsigned1 || unsigned2;
 835               if (top->unsignedp)
 836                 top->value = (unsigned long) v1 / v2;
 837               else
 838                 {
 839                   top->value = v1 / v2;
 840                   if ((top->value & v1 & v2) < 0)
 841                     integer_overflow (pfile);
 842                 }
 843               break;
 844             case '%':
 845               if (skip_evaluation)
 846                 break;
 847               if (v2 == 0)
 848                 {
 849                   cpp_error (pfile, "division by zero in #if");
 850                   v2 = 1;
 851                 }
 852               top->unsignedp = unsigned1 || unsigned2;
 853               if (top->unsignedp)
 854                 top->value = (unsigned long) v1 % v2;
 855               else
 856                 top->value = v1 % v2;
 857               break;
 858             case '!':
 859               if (top->flags & HAVE_VALUE)
 860                 {
 861                   cpp_error (pfile, "syntax error");
 862                   goto syntax_error;
 863                 }
 864               top->value = ! v2;
 865               top->unsignedp = 0;
 866               top->flags |= HAVE_VALUE;
 867               break;
 868             case '~':
 869               if (top->flags & HAVE_VALUE)
 870                 {
 871                   cpp_error (pfile, "syntax error");
 872                   goto syntax_error;
 873                 }
 874               top->value = ~ v2;
 875               top->unsignedp = unsigned2;
 876               top->flags |= HAVE_VALUE;
 877               break;
 878             case '<':  COMPARE(<);  break;
 879             case '>':  COMPARE(>);  break;
 880             case LEQ:  COMPARE(<=); break;
 881             case GEQ:  COMPARE(>=); break;
 882             case EQUAL:
 883               top->value = (v1 == v2);
 884               top->unsignedp = 0;
 885               break;
 886             case NOTEQUAL:
 887               top->value = (v1 != v2);
 888               top->unsignedp = 0;
 889               break;
 890             case LSH:
 891               if (skip_evaluation)
 892                 break;
 893               top->unsignedp = unsigned1;
 894               if (v2 < 0 && ! unsigned2)
 895                 top->value = right_shift (pfile, v1, unsigned1, -v2);
 896               else
 897                 top->value = left_shift (pfile, v1, unsigned1, v2);
 898               break;
 899             case RSH:
 900               if (skip_evaluation)
 901                 break;
 902               top->unsignedp = unsigned1;
 903               if (v2 < 0 && ! unsigned2)
 904                 top->value = left_shift (pfile, v1, unsigned1, -v2);
 905               else
 906                 top->value = right_shift (pfile, v1, unsigned1, v2);
 907               break;
 908 #define LOGICAL(OP) \
 909               top->value = v1 OP v2;\
 910               top->unsignedp = unsigned1 || unsigned2;
 911             case '&':  LOGICAL(&); break;
 912             case '^':  LOGICAL(^);  break;
 913             case '|':  LOGICAL(|);  break;
 914             case ANDAND:
 915               top->value = v1 && v2;  top->unsignedp = 0;
 916               if (!v1) skip_evaluation--;
 917               break;
 918             case OROR:
 919               top->value = v1 || v2;  top->unsignedp = 0;
 920               if (v1) skip_evaluation--;
 921               break;
 922             case ',':
 923               if (CPP_PEDANTIC (pfile))
 924                 cpp_pedwarn (pfile, "comma operator in operand of `#if'");
 925               top->value = v2;
 926               top->unsignedp = unsigned2;
 927               break;
 928             case '(':  case '?':
 929               cpp_error (pfile, "syntax error in #if");
 930               goto syntax_error;
 931             case ':':
 932               if (top[0].op != '?')
 933                 {
 934                   cpp_error (pfile,
 935                              "syntax error ':' without preceding '?'");
 936                   goto syntax_error;
 937                 }
 938               else if (! (top[1].flags & HAVE_VALUE)
 939                        || !(top[-1].flags & HAVE_VALUE)
 940                        || !(top[0].flags & HAVE_VALUE))
 941                 {
 942                   cpp_error (pfile, "bad syntax for ?: operator");
 943                   goto syntax_error;
 944                 }
 945               else
 946                 {
 947                   top--;
 948                   if (top->value) skip_evaluation--;
 949                   top->value = top->value ? v1 : v2;
 950                   top->unsignedp = unsigned1 || unsigned2;
 951                 }
 952               break;
 953             case ')':
 954               if ((top[1].flags & HAVE_VALUE)
 955                   || ! (top[0].flags & HAVE_VALUE)
 956                   || top[0].op != '('
 957                   || (top[-1].flags & HAVE_VALUE))
 958                 {
 959                   cpp_error (pfile, "mismatched parentheses in #if");
 960                   goto syntax_error;
 961                 }
 962               else
 963                 {
 964                   top--;
 965                   top->value = v1;
 966                   top->unsignedp = unsigned1;
 967                   top->flags |= HAVE_VALUE;
 968                 }
 969               break;
 970             default:
 971               fprintf (stderr,
 972                        top[1].op >= ' ' && top[1].op <= '~'
 973                        ? "unimplemented operator '%c'\n"
 974                        : "unimplemented operator '\\%03o'\n",
 975                        top[1].op);
 976             }
 977         }
 978       if (op.op == 0)
 979         {
 980           if (top != stack)
 981             cpp_error (pfile, "internal error in #if expression");
 982           if (stack != init_stack)
 983             free (stack);
 984           return top->value;
 985         }
 986       top++;
 987
 988       /* Check for and handle stack overflow.  */
 989       if (top == limit)
 990         {
 991           struct operation *new_stack;
 992           int old_size = (char *) limit - (char *) stack;
 993           int new_size = 2 * old_size;
 994           if (stack != init_stack)
 995             new_stack = (struct operation *) xrealloc (stack, new_size);
 996           else
 997             {
 998               new_stack = (struct operation *) xmalloc (new_size);
 999               bcopy ((char *) stack, (char *) new_stack, old_size);
1000             }
1001           stack = new_stack;
1002           top = (struct operation *) ((char *) new_stack + old_size);
1003           limit = (struct operation *) ((char *) new_stack + new_size);
1004         }
1005
1006       top->flags = flags;
1007       top->rprio = rprio;
1008       top->op = op.op;
1009       if ((op.op == OROR && top[-1].value)
1010           || (op.op == ANDAND && !top[-1].value)
1011           || (op.op == '?' && !top[-1].value))
1012         {
1013           skip_evaluation++;
1014         }
1015       else if (op.op == ':')
1016         {
1017           if (top[-2].value) /* Was condition true? */
1018             skip_evaluation++;
1019           else
1020             skip_evaluation--;
1021         }
1022     }
1023  syntax_error:
1024   if (stack != init_stack)
1025     free (stack);
1026   skip_rest_of_line (pfile);
1027   return 0;
1028 }