gcc/cppexp.c

   1 /* Parse C expressions for cpplib.
   2    Copyright (C) 1987, 92, 94, 95, 97, 98, 1999, 2000 Free Software Foundation.
   3    Contributed by Per Bothner, 1994.
   4
   5 This program is free software; you can redistribute it and/or modify it
   6 under the terms of the GNU General Public License as published by the
   7 Free Software Foundation; either version 2, or (at your option) any
   8 later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, 59 Temple Place - Suite 330,
  18 Boston, MA 02111-1307, USA.  */
  19
  20 /* Parse a C expression from text in a string  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "cpplib.h"
  25 #include "cpphash.h"
  26
  27 #ifndef CHAR_TYPE_SIZE
  28 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  29 #endif
  30
  31 #ifndef INT_TYPE_SIZE
  32 #define INT_TYPE_SIZE BITS_PER_WORD
  33 #endif
  34
  35 #ifndef LONG_TYPE_SIZE
  36 #define LONG_TYPE_SIZE BITS_PER_WORD
  37 #endif
  38
  39 #ifndef WCHAR_TYPE_SIZE
  40 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
  41 #endif
  42
  43 #ifndef MAX_CHAR_TYPE_SIZE
  44 #define MAX_CHAR_TYPE_SIZE CHAR_TYPE_SIZE
  45 #endif
  46
  47 #ifndef MAX_INT_TYPE_SIZE
  48 #define MAX_INT_TYPE_SIZE INT_TYPE_SIZE
  49 #endif
  50
  51 #ifndef MAX_LONG_TYPE_SIZE
  52 #define MAX_LONG_TYPE_SIZE LONG_TYPE_SIZE
  53 #endif
  54
  55 #ifndef MAX_WCHAR_TYPE_SIZE
  56 #define MAX_WCHAR_TYPE_SIZE WCHAR_TYPE_SIZE
  57 #endif
  58
  59 #define MAX_CHAR_TYPE_MASK (MAX_CHAR_TYPE_SIZE < HOST_BITS_PER_WIDEST_INT \
  60                     ? (~(~(HOST_WIDEST_INT) 0 << MAX_CHAR_TYPE_SIZE)) \
  61                     : ~ (HOST_WIDEST_INT) 0)
  62
  63 #define MAX_WCHAR_TYPE_MASK (MAX_WCHAR_TYPE_SIZE < HOST_BITS_PER_WIDEST_INT \
  64                              ? ~(~(HOST_WIDEST_INT) 0 << MAX_WCHAR_TYPE_SIZE) \
  65                              : ~ (HOST_WIDEST_INT) 0)
  66
  67 /* Yield nonzero if adding two numbers with A's and B's signs can yield a
  68    number with SUM's sign, where A, B, and SUM are all C integers.  */
  69 #define possible_sum_sign(a, b, sum) ((((a) ^ (b)) | ~ ((a) ^ (sum))) < 0)
  70
  71 static void integer_overflow PARAMS ((cpp_reader *));
  72 static HOST_WIDEST_INT left_shift PARAMS ((cpp_reader *, HOST_WIDEST_INT,
  73                                            unsigned int,
  74                                            unsigned HOST_WIDEST_INT));
  75 static HOST_WIDEST_INT right_shift PARAMS ((cpp_reader *, HOST_WIDEST_INT,
  76                                             unsigned int,
  77                                             unsigned HOST_WIDEST_INT));
  78 static struct op parse_number PARAMS ((cpp_reader *, const cpp_token *));
  79 static struct op parse_charconst PARAMS ((cpp_reader *, const cpp_token *));
  80 static struct op parse_defined PARAMS ((cpp_reader *));
  81 static struct op parse_assertion PARAMS ((cpp_reader *));
  82 static HOST_WIDEST_INT parse_escape PARAMS ((cpp_reader *, const U_CHAR **,
  83                                              const U_CHAR *, HOST_WIDEST_INT));
  84 static struct op lex PARAMS ((cpp_reader *, int));
  85
  86 struct op
  87 {
  88   enum cpp_ttype op;
  89   U_CHAR prio;         /* Priority of op.  */
  90   U_CHAR flags;
  91   U_CHAR unsignedp;    /* True if value should be treated as unsigned.  */
  92   HOST_WIDEST_INT value; /* The value logically "right" of op.  */
  93 };
  94
  95 /* There is no "error" token, but we can't get comments in #if, so we can
  96    abuse that token type.  */
  97 #define CPP_ERROR CPP_COMMENT
  98
  99 /* With -O2, gcc appears to produce nice code, moving the error
 100    message load and subsequent jump completely out of the main path.  */
 101 #define CPP_ICE(msgid) \
 102   do { cpp_ice (pfile, msgid); goto syntax_error; } while(0)
 103 #define SYNTAX_ERROR(msgid) \
 104   do { cpp_error (pfile, msgid); goto syntax_error; } while(0)
 105 #define SYNTAX_ERROR2(msgid, arg) \
 106   do { cpp_error (pfile, msgid, arg); goto syntax_error; } while(0)
 107
 108 /* Parse and convert an integer for #if.  Accepts decimal, hex, or octal
 109    with or without size suffixes.  */
 110 struct suffix
 111 {
 112   unsigned char s[4];
 113   unsigned char u;
 114   unsigned char l;
 115 };
 116
 117 const struct suffix vsuf_1[] = {
 118   { "u", 1, 0 }, { "U", 1, 0 },
 119   { "l", 0, 1 }, { "L", 0, 1 }
 120 };
 121
 122 const struct suffix vsuf_2[] = {
 123   { "ul", 1, 1 }, { "UL", 1, 1 }, { "uL", 1, 1 }, { "Ul", 1, 1 },
 124   { "lu", 1, 1 }, { "LU", 1, 1 }, { "Lu", 1, 1 }, { "lU", 1, 1 },
 125   { "ll", 0, 2 }, { "LL", 0, 2 }
 126 };
 127
 128 const struct suffix vsuf_3[] = {
 129   { "ull", 1, 2 }, { "ULL", 1, 2 }, { "uLL", 1, 2 }, { "Ull", 1, 2 },
 130   { "llu", 1, 2 }, { "LLU", 1, 2 }, { "LLu", 1, 2 }, { "llU", 1, 2 }
 131 };
 132 #define Nsuff(tab) (sizeof tab / sizeof (struct suffix))
 133
 134 static struct op
 135 parse_number (pfile, tok)
 136      cpp_reader *pfile;
 137      const cpp_token *tok;
 138 {
 139   struct op op;
 140   const U_CHAR *start = tok->val.str.text;
 141   const U_CHAR *end = start + tok->val.str.len;
 142   const U_CHAR *p = start;
 143   int c = 0, i, nsuff;
 144   unsigned HOST_WIDEST_INT n = 0, nd, MAX_over_base;
 145   int base = 10;
 146   int overflow = 0;
 147   int digit, largest_digit = 0;
 148   const struct suffix *sufftab;
 149
 150   op.unsignedp = 0;
 151
 152   if (p[0] == '0')
 153     {
 154       if (end - start >= 3 && (p[1] == 'x' || p[1] == 'X'))
 155         {
 156           p += 2;
 157           base = 16;
 158         }
 159       else
 160         {
 161           p += 1;
 162           base = 8;
 163         }
 164     }
 165
 166   /* Some buggy compilers (e.g. MPW C) seem to need both casts.  */
 167   MAX_over_base = (((unsigned HOST_WIDEST_INT) -1)
 168                    / ((unsigned HOST_WIDEST_INT) base));
 169
 170   for(; p < end; p++)
 171     {
 172       c = *p;
 173
 174       if (c >= '0' && c <= '9')
 175         digit = c - '0';
 176       /* We believe that in all live character sets, a-f are
 177          consecutive, and so are A-F.  */
 178       else if (base == 16 && c >= 'a' && c <= 'f')
 179         digit = c - 'a' + 10;
 180       else if (base == 16 && c >= 'A' && c <= 'F')
 181         digit = c - 'A' + 10;
 182       else
 183         break;
 184
 185       if (largest_digit < digit)
 186         largest_digit = digit;
 187       nd = n * base + digit;
 188       overflow |= MAX_over_base < n || nd < n;
 189       n = nd;
 190     }
 191
 192   if (p < end)
 193     {
 194       /* Check for a floating point constant.  Note that float constants
 195          with an exponent or suffix but no decimal point are technically
 196          invalid (C99 6.4.4.2) but accepted elsewhere.  */
 197       if ((c == '.' || c == 'F' || c == 'f')
 198           || (base == 10 && (c == 'E' || c == 'e')
 199               && p+1 < end && (p[1] == '+' || p[1] == '-'))
 200           || (base == 16 && (c == 'P' || c == 'p')
 201               && p+1 < end && (p[1] == '+' || p[1] == '-')))
 202         SYNTAX_ERROR ("floating point numbers are not valid in #if");
 203
 204       /* Determine the suffix. l means long, and u means unsigned.
 205          See the suffix tables, above.  */
 206       switch (end - p)
 207         {
 208         case 1: sufftab = vsuf_1; nsuff = Nsuff(vsuf_1); break;
 209         case 2: sufftab = vsuf_2; nsuff = Nsuff(vsuf_2); break;
 210         case 3: sufftab = vsuf_3; nsuff = Nsuff(vsuf_3); break;
 211         default: goto invalid_suffix;
 212         }
 213
 214       for (i = 0; i < nsuff; i++)
 215         if (memcmp (p, sufftab[i].s, end - p) == 0)
 216           break;
 217       if (i == nsuff)
 218         goto invalid_suffix;
 219       op.unsignedp = sufftab[i].u;
 220
 221       if (CPP_OPTION (pfile, c89) && sufftab[i].l == 2)
 222         SYNTAX_ERROR ("too many 'l' suffixes in integer constant");
 223     }
 224
 225   if (base <= largest_digit)
 226     cpp_pedwarn (pfile, "integer constant contains digits beyond the radix");
 227
 228   if (overflow)
 229     cpp_pedwarn (pfile, "integer constant out of range");
 230
 231   /* If too big to be signed, consider it unsigned.  */
 232   else if ((HOST_WIDEST_INT) n < 0 && ! op.unsignedp)
 233     {
 234       if (base == 10)
 235         cpp_warning (pfile, "integer constant is so large that it is unsigned");
 236       op.unsignedp = 1;
 237     }
 238
 239   op.value = n;
 240   op.op = CPP_INT;
 241   return op;
 242
 243  invalid_suffix:
 244   cpp_error (pfile, "invalid suffix '%.*s' on integer constant",
 245              (int) (end - p), p);
 246  syntax_error:
 247   op.op = CPP_ERROR;
 248   return op;
 249 }
 250
 251 /* Parse and convert a character constant for #if.  Understands backslash
 252    escapes (\n, \031) and multibyte characters (if so configured).  */
 253 static struct op
 254 parse_charconst (pfile, tok)
 255      cpp_reader *pfile;
 256      const cpp_token *tok;
 257 {
 258   struct op op;
 259   HOST_WIDEST_INT result = 0;
 260   int num_chars = 0;
 261   int num_bits;
 262   unsigned int width = MAX_CHAR_TYPE_SIZE, mask = MAX_CHAR_TYPE_MASK;
 263   int max_chars;
 264   const U_CHAR *ptr = tok->val.str.text;
 265   const U_CHAR *end = ptr + tok->val.str.len;
 266
 267   int c = -1;
 268
 269   if (tok->type == CPP_WCHAR)
 270     width = MAX_WCHAR_TYPE_SIZE, mask = MAX_WCHAR_TYPE_MASK;
 271   max_chars = MAX_LONG_TYPE_SIZE / width;
 272
 273   while (ptr < end)
 274     {
 275       c = *ptr++;
 276       if (c == '\'')
 277         CPP_ICE ("unescaped ' in character constant");
 278       else if (c == '\\')
 279         {
 280           c = parse_escape (pfile, &ptr, end, mask);
 281           if (width < HOST_BITS_PER_INT
 282               && (unsigned int) c >= (unsigned int)(1 << width))
 283             cpp_pedwarn (pfile,
 284                          "escape sequence out of range for character");
 285         }
 286
 287       /* Merge character into result; ignore excess chars.  */
 288       if (++num_chars <= max_chars)
 289         {
 290           if (width < HOST_BITS_PER_INT)
 291             result = (result << width) | (c & ((1 << width) - 1));
 292           else
 293             result = c;
 294         }
 295     }
 296
 297   if (num_chars == 0)
 298     SYNTAX_ERROR ("empty character constant");
 299   else if (num_chars > max_chars)
 300     SYNTAX_ERROR ("character constant too long");
 301   else if (num_chars != 1)
 302     cpp_warning (pfile, "multi-character character constant");
 303
 304   /* If char type is signed, sign-extend the constant.  */
 305   num_bits = num_chars * width;
 306
 307   if (pfile->spec_nodes->n__CHAR_UNSIGNED__->type != T_VOID
 308       || ((result >> (num_bits - 1)) & 1) == 0)
 309     op.value = result & ((unsigned HOST_WIDEST_INT) ~0
 310                          >> (HOST_BITS_PER_WIDEST_INT - num_bits));
 311   else
 312     op.value = result | ~((unsigned HOST_WIDEST_INT) ~0
 313                           >> (HOST_BITS_PER_WIDEST_INT - num_bits));
 314
 315   /* This is always a signed type.  */
 316   op.unsignedp = 0;
 317   op.op = CPP_INT;
 318   return op;
 319
 320  syntax_error:
 321   op.op = CPP_ERROR;
 322   return op;
 323 }
 324
 325 static struct op
 326 parse_defined (pfile)
 327      cpp_reader *pfile;
 328 {
 329   int paren;
 330   const cpp_token *tok;
 331   struct op op;
 332
 333   paren = 0;
 334   tok = _cpp_get_raw_token (pfile);
 335   if (tok->type == CPP_OPEN_PAREN)
 336     {
 337       paren = 1;
 338       tok = _cpp_get_raw_token (pfile);
 339     }
 340
 341   if (tok->type != CPP_NAME)
 342     SYNTAX_ERROR ("\"defined\" without an identifier");
 343
 344   if (paren && _cpp_get_raw_token (pfile)->type != CPP_CLOSE_PAREN)
 345     SYNTAX_ERROR ("missing close paren after \"defined\"");
 346
 347   if (tok->val.node->type == T_POISON)
 348     SYNTAX_ERROR2 ("attempt to use poisoned \"%s\"", tok->val.node->name);
 349
 350   op.value = tok->val.node->type != T_VOID;
 351   op.unsignedp = 0;
 352   op.op = CPP_INT;
 353   return op;
 354
 355  syntax_error:
 356   op.op = CPP_ERROR;
 357   return op;
 358 }
 359
 360 static struct op
 361 parse_assertion (pfile)
 362      cpp_reader *pfile;
 363 {
 364   struct op op;
 365   struct answer *answer;
 366   cpp_hashnode *hp;
 367
 368   op.op = CPP_ERROR;
 369   hp = _cpp_parse_assertion (pfile, &answer);
 370   if (hp)
 371     {
 372       /* If we get here, the syntax is valid.  */
 373       op.op = CPP_INT;
 374       op.unsignedp = 0;
 375       op.value = (hp->type == T_ASSERTION &&
 376                   (answer == 0 || *_cpp_find_answer (hp, &answer->list) != 0));
 377
 378       if (answer)
 379         FREE_ANSWER (answer);
 380     }
 381   return op;
 382 }
 383
 384 /* Read one token.  */
 385
 386 static struct op
 387 lex (pfile, skip_evaluation)
 388      cpp_reader *pfile;
 389      int skip_evaluation;
 390 {
 391   struct op op;
 392   const cpp_token *tok;
 393
 394  retry:
 395   tok = _cpp_get_token (pfile);
 396
 397   switch (tok->type)
 398     {
 399     case CPP_PLACEMARKER:
 400       goto retry;
 401
 402     case CPP_INT:
 403     case CPP_NUMBER:
 404       return parse_number (pfile, tok);
 405     case CPP_CHAR:
 406     case CPP_WCHAR:
 407       return parse_charconst (pfile, tok);
 408
 409     case CPP_STRING:
 410     case CPP_WSTRING:
 411       SYNTAX_ERROR ("string constants are not valid in #if");
 412
 413     case CPP_FLOAT:
 414       SYNTAX_ERROR ("floating point numbers are not valid in #if");
 415
 416     case CPP_OTHER:
 417       if (ISGRAPH (tok->val.aux))
 418         SYNTAX_ERROR2 ("invalid character '%c' in #if", tok->val.aux);
 419       else
 420         SYNTAX_ERROR2 ("invalid character '\\%03o' in #if", tok->val.aux);
 421
 422     case CPP_DEFINED:
 423       return parse_defined (pfile);
 424
 425     case CPP_NAME:
 426       op.op = CPP_INT;
 427       op.unsignedp = 0;
 428       op.value = 0;
 429
 430       if (CPP_OPTION (pfile, warn_undef) && !skip_evaluation)
 431         cpp_warning (pfile, "\"%s\" is not defined", tok->val.node->name);
 432       return op;
 433
 434     case CPP_HASH:
 435       return parse_assertion (pfile);
 436
 437     default:
 438       if ((tok->type > CPP_EQ && tok->type < CPP_PLUS_EQ)
 439           || tok->type == CPP_EOF)
 440         {
 441           op.op = tok->type;
 442           return op;
 443         }
 444
 445       SYNTAX_ERROR2("'%s' is not valid in #if expressions", TOKEN_NAME (tok));
 446   }
 447
 448  syntax_error:
 449   op.op = CPP_ERROR;
 450   return op;
 451 }
 452
 453 /* Parse a C escape sequence.  STRING_PTR points to a variable
 454    containing a pointer to the string to parse.  That pointer
 455    is updated past the characters we use.  The value of the
 456    escape sequence is returned.
 457
 458    If \ is followed by 000, we return 0 and leave the string pointer
 459    after the zeros.  A value of 0 does not mean end of string.  */
 460
 461 static HOST_WIDEST_INT
 462 parse_escape (pfile, string_ptr, limit, result_mask)
 463      cpp_reader *pfile;
 464      const U_CHAR **string_ptr;
 465      const U_CHAR *limit;
 466      HOST_WIDEST_INT result_mask;
 467 {
 468   const U_CHAR *ptr = *string_ptr;
 469   /* We know we have at least one following character.  */
 470   int c = *ptr++;
 471   switch (c)
 472     {
 473     case 'a': c = TARGET_BELL;    break;
 474     case 'b': c = TARGET_BS;      break;
 475     case 'f': c = TARGET_FF;      break;
 476     case 'n': c = TARGET_NEWLINE; break;
 477     case 'r': c = TARGET_CR;      break;
 478     case 't': c = TARGET_TAB;     break;
 479     case 'v': c = TARGET_VT;      break;
 480
 481     case 'e': case 'E':
 482       if (CPP_PEDANTIC (pfile))
 483         cpp_pedwarn (pfile, "non-ISO-standard escape sequence, '\\%c'", c);
 484       c = TARGET_ESC;
 485       break;
 486
 487     case '0': case '1': case '2': case '3':
 488     case '4': case '5': case '6': case '7':
 489       {
 490         unsigned int i = c - '0';
 491         int count = 0;
 492         while (++count < 3)
 493           {
 494             if (ptr >= limit)
 495               break;
 496
 497             c = *ptr;
 498             if (c < '0' || c > '7')
 499               break;
 500             ptr++;
 501             i = (i << 3) + c - '0';
 502           }
 503         if (i != (i & result_mask))
 504           {
 505             i &= result_mask;
 506             cpp_pedwarn (pfile, "octal escape sequence out of range");
 507           }
 508         c = i;
 509         break;
 510       }
 511
 512     case 'x':
 513       {
 514         unsigned int i = 0, overflow = 0;
 515         int digits_found = 0, digit;
 516         for (;;)
 517           {
 518             if (ptr >= limit)
 519               break;
 520             c = *ptr;
 521             if (c >= '0' && c <= '9')
 522               digit = c - '0';
 523             else if (c >= 'a' && c <= 'f')
 524               digit = c - 'a' + 10;
 525             else if (c >= 'A' && c <= 'F')
 526               digit = c - 'A' + 10;
 527             else
 528               break;
 529             ptr++;
 530             overflow |= i ^ (i << 4 >> 4);
 531             i = (i << 4) + digit;
 532             digits_found = 1;
 533           }
 534         if (!digits_found)
 535           cpp_error (pfile, "\\x used with no following hex digits");
 536         if (overflow | (i != (i & result_mask)))
 537           {
 538             i &= result_mask;
 539             cpp_pedwarn (pfile, "hex escape sequence out of range");
 540           }
 541         c = i;
 542         break;
 543       }
 544     }
 545   *string_ptr = ptr;
 546   return c;
 547 }
 548
 549 static void
 550 integer_overflow (pfile)
 551      cpp_reader *pfile;
 552 {
 553   if (CPP_PEDANTIC (pfile))
 554     cpp_pedwarn (pfile, "integer overflow in preprocessor expression");
 555 }
 556
 557 static HOST_WIDEST_INT
 558 left_shift (pfile, a, unsignedp, b)
 559      cpp_reader *pfile;
 560      HOST_WIDEST_INT a;
 561      unsigned int unsignedp;
 562      unsigned HOST_WIDEST_INT b;
 563 {
 564   if (b >= HOST_BITS_PER_WIDEST_INT)
 565     {
 566       if (! unsignedp && a != 0)
 567         integer_overflow (pfile);
 568       return 0;
 569     }
 570   else if (unsignedp)
 571     return (unsigned HOST_WIDEST_INT) a << b;
 572   else
 573     {
 574       HOST_WIDEST_INT l = a << b;
 575       if (l >> b != a)
 576         integer_overflow (pfile);
 577       return l;
 578     }
 579 }
 580
 581 static HOST_WIDEST_INT
 582 right_shift (pfile, a, unsignedp, b)
 583      cpp_reader *pfile ATTRIBUTE_UNUSED;
 584      HOST_WIDEST_INT a;
 585      unsigned int unsignedp;
 586      unsigned HOST_WIDEST_INT b;
 587 {
 588   if (b >= HOST_BITS_PER_WIDEST_INT)
 589     return unsignedp ? 0 : a >> (HOST_BITS_PER_WIDEST_INT - 1);
 590   else if (unsignedp)
 591     return (unsigned HOST_WIDEST_INT) a >> b;
 592   else
 593     return a >> b;
 594 }
 595 \f
 596 /* Operator precedence and flags table.
 597
 598 After an operator is returned from the lexer, if it has priority less
 599 than or equal to the operator on the top of the stack, we reduce the
 600 stack by one operator and repeat the test.  Since equal priorities
 601 reduce, this is naturally left-associative.
 602
 603 We handle right-associative operators by clearing the lower bit of all
 604 left-associative operators, and setting it for right-associative ones.
 605 After the reduction phase of a new operator, just before it is pushed
 606 onto the stack, its RIGHT_ASSOC bit is cleared.  The effect is that
 607 during the reduction phase, the current right-associative operator has
 608 a priority one greater than any other operator of otherwise equal
 609 precedence that has been pushed on the top of the stack.  This avoids
 610 a reduction pass, and effectively makes the logic right-associative.
 611
 612 The remaining cases are '(' and ')'.  We handle '(' by skipping the
 613 reduction phase completely.  ')' is given lower priority than
 614 everything else, including '(', effectively forcing a reduction of the
 615 parenthesised expression.  If there is no matching '(', the stack will
 616 be reduced all the way to the beginning, exiting the parser in the
 617 same way as the ultra-low priority end-of-expression dummy operator.
 618 The exit code checks to see if the operator that caused it is ')', and
 619 if so outputs an appropriate error message.
 620
 621 The parser assumes all shifted operators require a right operand
 622 unless the flag NO_R_OPERAND is set, and similarly for NO_L_OPERAND.
 623 These semantics are automatically checked, any extra semantics need to
 624 be handled with operator-specific code.  */
 625
 626 #define FLAG_BITS  8
 627 #define FLAG_MASK ((1 << FLAG_BITS) - 1)
 628 #define PRIO_SHIFT (FLAG_BITS + 1)
 629 #define EXTRACT_PRIO(cnst) (cnst >> FLAG_BITS)
 630 #define EXTRACT_FLAGS(cnst) (cnst & FLAG_MASK)
 631
 632 /* Flags.  */
 633 #define HAVE_VALUE     (1 << 0)
 634 #define NO_L_OPERAND   (1 << 1)
 635 #define NO_R_OPERAND   (1 << 2)
 636 #define SHORT_CIRCUIT  (1 << 3)
 637
 638 /* Priority and flag combinations.  */
 639 #define RIGHT_ASSOC         (1 << FLAG_BITS)
 640 #define FORCE_REDUCE_PRIO   (0 << PRIO_SHIFT)
 641 #define CLOSE_PAREN_PRIO    (1 << PRIO_SHIFT)
 642 #define OPEN_PAREN_PRIO    ((2 << PRIO_SHIFT) | NO_L_OPERAND)
 643 #define COMMA_PRIO          (3 << PRIO_SHIFT)
 644 #define COND_PRIO          ((4 << PRIO_SHIFT) | RIGHT_ASSOC | SHORT_CIRCUIT)
 645 #define COLON_PRIO         ((5 << PRIO_SHIFT) | SHORT_CIRCUIT)
 646 #define OROR_PRIO          ((6 << PRIO_SHIFT) | SHORT_CIRCUIT)
 647 #define ANDAND_PRIO        ((7 << PRIO_SHIFT) | SHORT_CIRCUIT)
 648 #define OR_PRIO             (8 << PRIO_SHIFT)
 649 #define XOR_PRIO            (9 << PRIO_SHIFT)
 650 #define AND_PRIO           (10 << PRIO_SHIFT)
 651 #define MINMAX_PRIO        (11 << PRIO_SHIFT)
 652 #define EQUAL_PRIO         (12 << PRIO_SHIFT)
 653 #define LESS_PRIO          (13 << PRIO_SHIFT)
 654 #define SHIFT_PRIO         (14 << PRIO_SHIFT)
 655 #define PLUS_PRIO          (15 << PRIO_SHIFT)
 656 #define MUL_PRIO           (16 << PRIO_SHIFT)
 657 #define UNARY_PRIO        ((17 << PRIO_SHIFT) | RIGHT_ASSOC | NO_L_OPERAND)
 658
 659 /* Operator to priority map.  Must be in the same order as the first
 660    N entries of enum cpp_ttype.  */
 661 static const short
 662 op_to_prio[] =
 663 {
 664   /* EQ */              0,              /* dummy entry - can't happen */
 665   /* NOT */             UNARY_PRIO,
 666   /* GREATER */         LESS_PRIO,
 667   /* LESS */            LESS_PRIO,
 668   /* PLUS */            UNARY_PRIO,     /* note these two can be unary */
 669   /* MINUS */           UNARY_PRIO,     /* or binary */
 670   /* MULT */            MUL_PRIO,
 671   /* DIV */             MUL_PRIO,
 672   /* MOD */             MUL_PRIO,
 673   /* AND */             AND_PRIO,
 674   /* OR */              OR_PRIO,
 675   /* XOR */             XOR_PRIO,
 676   /* RSHIFT */          SHIFT_PRIO,
 677   /* LSHIFT */          SHIFT_PRIO,
 678   /* MIN */             MINMAX_PRIO,    /* C++ specific */
 679   /* MAX */             MINMAX_PRIO,    /* extensions */
 680
 681   /* COMPL */           UNARY_PRIO,
 682   /* AND_AND */         ANDAND_PRIO,
 683   /* OR_OR */           OROR_PRIO,
 684   /* QUERY */           COND_PRIO,
 685   /* COLON */           COLON_PRIO,
 686   /* COMMA */           COMMA_PRIO,
 687   /* OPEN_PAREN */      OPEN_PAREN_PRIO,
 688   /* CLOSE_PAREN */     CLOSE_PAREN_PRIO,
 689   /* EQ_EQ */           EQUAL_PRIO,
 690   /* NOT_EQ */          EQUAL_PRIO,
 691   /* GREATER_EQ */      LESS_PRIO,
 692   /* LESS_EQ */         LESS_PRIO
 693 };
 694
 695 #define COMPARE(OP) \
 696   top->unsignedp = 0; \
 697   top->value = (unsigned1 | unsigned2) \
 698   ? (unsigned HOST_WIDEST_INT) v1 OP (unsigned HOST_WIDEST_INT) v2 \
 699   : (v1 OP v2)
 700 #define EQUALITY(OP) \
 701   top->value = v1 OP v2; \
 702   top->unsignedp = 0;
 703 #define BITWISE(OP) \
 704   top->value = v1 OP v2; \
 705   top->unsignedp = unsigned1 | unsigned2;
 706 #define MINMAX(OP) \
 707   top->value = (v1 OP v2) ? v1 : v2; \
 708   top->unsignedp = unsigned1 | unsigned2;
 709 #define UNARY(OP) \
 710   top->value = OP v2; \
 711   top->unsignedp = unsigned2; \
 712   top->flags |= HAVE_VALUE;
 713 #define SHIFT(PSH, MSH) \
 714   if (skip_evaluation)  \
 715     break;              \
 716   top->unsignedp = unsigned1; \
 717   if (v2 < 0 && ! unsigned2)  \
 718     top->value = MSH (pfile, v1, unsigned1, -v2); \
 719   else \
 720     top->value = PSH (pfile, v1, unsigned1, v2);
 721
 722 /* Parse and evaluate a C expression, reading from PFILE.
 723    Returns the truth value of the expression.  */
 724
 725 #define TYPE_NAME(t) _cpp_token_spellings[t].name
 726
 727 int
 728 _cpp_parse_expr (pfile)
 729      cpp_reader *pfile;
 730 {
 731   /* The implementation is an operator precedence parser, i.e. a
 732      bottom-up parser, using a stack for not-yet-reduced tokens.
 733
 734      The stack base is 'stack', and the current stack pointer is 'top'.
 735      There is a stack element for each operator (only),
 736      and the most recently pushed operator is 'top->op'.
 737      An operand (value) is stored in the 'value' field of the stack
 738      element of the operator that precedes it.
 739      In that case the 'flags' field has the HAVE_VALUE flag set.  */
 740
 741 #define INIT_STACK_SIZE 20
 742   struct op init_stack[INIT_STACK_SIZE];
 743   struct op *stack = init_stack;
 744   struct op *limit = stack + INIT_STACK_SIZE;
 745   register struct op *top = stack + 1;
 746   int skip_evaluation = 0;
 747   int result;
 748
 749   /* Save parser state and set it to something sane.  */
 750   int save_skipping = pfile->skipping;
 751   pfile->skipping = 0;
 752
 753   /* We've finished when we try to reduce this.  */
 754   top->op = CPP_EOF;
 755   /* Nifty way to catch missing '('.  */
 756   top->prio = EXTRACT_PRIO(CLOSE_PAREN_PRIO);
 757   /* Avoid missing right operand checks.  */
 758   top->flags = NO_R_OPERAND;
 759
 760   for (;;)
 761     {
 762       unsigned int prio;
 763       unsigned int flags;
 764       struct op op;
 765
 766       /* Read a token */
 767       op = lex (pfile, skip_evaluation);
 768
 769       /* If the token is an operand, push its value and get next
 770          token.  If it is an operator, get its priority and flags, and
 771          try to reduce the expression on the stack.  */
 772       switch (op.op)
 773         {
 774         case CPP_ERROR:
 775           goto syntax_error;
 776         push_immediate:
 777         case CPP_INT:
 778           /* Push a value onto the stack.  */
 779           if (top->flags & HAVE_VALUE)
 780             SYNTAX_ERROR ("missing binary operator");
 781           top->value = op.value;
 782           top->unsignedp = op.unsignedp;
 783           top->flags |= HAVE_VALUE;
 784           continue;
 785
 786         case CPP_EOF:   prio = FORCE_REDUCE_PRIO;       break;
 787         case CPP_PLUS:
 788         case CPP_MINUS: prio = PLUS_PRIO;  if (top->flags & HAVE_VALUE) break;
 789           /* else unary; fall through */
 790         default:        prio = op_to_prio[op.op];       break;
 791         }
 792
 793       /* Separate the operator's code into priority and flags.  */
 794       flags = EXTRACT_FLAGS(prio);
 795       prio = EXTRACT_PRIO(prio);
 796       if (prio == EXTRACT_PRIO(OPEN_PAREN_PRIO))
 797         goto skip_reduction;
 798
 799       /* Check for reductions.  Then push the operator.  */
 800       while (prio <= top->prio)
 801         {
 802           HOST_WIDEST_INT v1, v2;
 803           unsigned int unsigned1, unsigned2;
 804
 805           /* Most operators that can appear on the stack require a
 806              right operand.  Check this before trying to reduce.  */
 807           if ((top->flags & (HAVE_VALUE | NO_R_OPERAND)) == 0)
 808             {
 809               if (top->op == CPP_OPEN_PAREN)
 810                 SYNTAX_ERROR ("void expression between '(' and ')'");
 811               else
 812                 SYNTAX_ERROR2 ("operator '%s' has no right operand",
 813                                TYPE_NAME (top->op));
 814             }
 815
 816           unsigned2 = top->unsignedp, v2 = top->value;
 817           top--;
 818           unsigned1 = top->unsignedp, v1 = top->value;
 819
 820           /* Now set top->value = (top[1].op)(v1, v2); */
 821           switch (top[1].op)
 822             {
 823             default:
 824               cpp_ice (pfile, "impossible operator type %s", TYPE_NAME (op.op));
 825               goto syntax_error;
 826
 827             case CPP_NOT:        UNARY(!);      break;
 828             case CPP_COMPL:      UNARY(~);      break;
 829             case CPP_LESS:       COMPARE(<);    break;
 830             case CPP_GREATER:    COMPARE(>);    break;
 831             case CPP_LESS_EQ:    COMPARE(<=);   break;
 832             case CPP_GREATER_EQ: COMPARE(>=);   break;
 833             case CPP_EQ_EQ:      EQUALITY(==);  break;
 834             case CPP_NOT_EQ:     EQUALITY(!=);  break;
 835             case CPP_AND:        BITWISE(&);    break;
 836             case CPP_XOR:        BITWISE(^);    break;
 837             case CPP_OR:         BITWISE(|);    break;
 838             case CPP_LSHIFT:     SHIFT(left_shift, right_shift); break;
 839             case CPP_RSHIFT:     SHIFT(right_shift, left_shift); break;
 840             case CPP_MIN:        MINMAX(<);     break;
 841             case CPP_MAX:        MINMAX(>);     break;
 842
 843             case CPP_PLUS:
 844               if (!(top->flags & HAVE_VALUE))
 845                 {
 846                   /* Can't use UNARY(+) because K+R C did not have unary
 847                      plus.  Can't use UNARY() because some compilers object
 848                      to the empty argument.  */
 849                   top->value = v2;
 850                   top->unsignedp = unsigned2;
 851                   top->flags |= HAVE_VALUE;
 852
 853                   if (CPP_WTRADITIONAL (pfile))
 854                     cpp_warning (pfile,
 855                         "traditional C rejects the unary plus operator");
 856                 }
 857               else
 858                 {
 859                   top->value = v1 + v2;
 860                   top->unsignedp = unsigned1 | unsigned2;
 861                   if (! top->unsignedp && ! skip_evaluation
 862                       && ! possible_sum_sign (v1, v2, top->value))
 863                     integer_overflow (pfile);
 864                 }
 865               break;
 866             case CPP_MINUS:
 867               if (!(top->flags & HAVE_VALUE))
 868                 {
 869                   UNARY(-);
 870                   if (!skip_evaluation && (top->value & v2) < 0 && !unsigned2)
 871                     integer_overflow (pfile);
 872                 }
 873               else
 874                 { /* Binary '-' */
 875                   top->value = v1 - v2;
 876                   top->unsignedp = unsigned1 | unsigned2;
 877                   if (! top->unsignedp && ! skip_evaluation
 878                       && ! possible_sum_sign (top->value, v2, v1))
 879                     integer_overflow (pfile);
 880                 }
 881               break;
 882             case CPP_MULT:
 883               top->unsignedp = unsigned1 | unsigned2;
 884               if (top->unsignedp)
 885                 top->value = (unsigned HOST_WIDEST_INT) v1 * v2;
 886               else if (!skip_evaluation)
 887                 {
 888                   top->value = v1 * v2;
 889                   if (v1 && (top->value / v1 != v2
 890                              || (top->value & v1 & v2) < 0))
 891                     integer_overflow (pfile);
 892                 }
 893               break;
 894             case CPP_DIV:
 895             case CPP_MOD:
 896               if (skip_evaluation)
 897                 break;
 898               if (v2 == 0)
 899                 SYNTAX_ERROR ("division by zero in #if");
 900               top->unsignedp = unsigned1 | unsigned2;
 901               if (top[1].op == CPP_DIV)
 902                 {
 903                   if (top->unsignedp)
 904                     top->value = (unsigned HOST_WIDEST_INT) v1 / v2;
 905                   else
 906                     {
 907                       top->value = v1 / v2;
 908                       if ((top->value & v1 & v2) < 0)
 909                         integer_overflow (pfile);
 910                     }
 911                 }
 912               else
 913                 {
 914                   if (top->unsignedp)
 915                     top->value = (unsigned HOST_WIDEST_INT) v1 % v2;
 916                   else
 917                     top->value = v1 % v2;
 918                 }
 919               break;
 920
 921             case CPP_OR_OR:
 922               top->value = v1 || v2;
 923               top->unsignedp = 0;
 924               if (v1) skip_evaluation--;
 925               break;
 926             case CPP_AND_AND:
 927               top->value = v1 && v2;
 928               top->unsignedp = 0;
 929               if (!v1) skip_evaluation--;
 930               break;
 931             case CPP_COMMA:
 932               if (CPP_PEDANTIC (pfile))
 933                 cpp_pedwarn (pfile, "comma operator in operand of #if");
 934               top->value = v2;
 935               top->unsignedp = unsigned2;
 936               break;
 937             case CPP_QUERY:
 938               SYNTAX_ERROR ("syntax error '?' without following ':'");
 939             case CPP_COLON:
 940               if (top[0].op != CPP_QUERY)
 941                 SYNTAX_ERROR ("syntax error ':' without preceding '?'");
 942               top--;
 943               if (top->value) skip_evaluation--;
 944               top->value = top->value ? v1 : v2;
 945               top->unsignedp = unsigned1 | unsigned2;
 946               break;
 947             case CPP_OPEN_PAREN:
 948               if (op.op != CPP_CLOSE_PAREN)
 949                 SYNTAX_ERROR ("missing ')' in expression");
 950               op.value = v2;
 951               op.unsignedp = unsigned2;
 952               goto push_immediate;
 953             case CPP_EOF:
 954               /* Reducing this dummy operator indicates we've finished.  */
 955               if (op.op == CPP_CLOSE_PAREN)
 956                 SYNTAX_ERROR ("missing '(' in expression");
 957               goto done;
 958             }
 959         }
 960
 961       /* Handle short-circuit evaluations.  */
 962       if (flags & SHORT_CIRCUIT)
 963         switch (op.op)
 964           {
 965           case CPP_OR_OR:    if (top->value) skip_evaluation++; break;
 966           case CPP_AND_AND:
 967           case CPP_QUERY:    if (!top->value) skip_evaluation++; break;
 968           case CPP_COLON:
 969             if (top[-1].value) /* Was '?' condition true?  */
 970               skip_evaluation++;
 971             else
 972               skip_evaluation--;
 973           default:
 974             break;
 975           }
 976
 977     skip_reduction:
 978       /* Check we have a left operand iff we need one.  */
 979       if (flags & NO_L_OPERAND)
 980         {
 981           if (top->flags & HAVE_VALUE)
 982             SYNTAX_ERROR2 ("missing binary operator before '%s'",
 983                            TYPE_NAME (op.op));
 984         }
 985       else
 986         {
 987           if (!(top->flags & HAVE_VALUE))
 988             SYNTAX_ERROR2 ("operator '%s' has no left operand",
 989                            TYPE_NAME (op.op));
 990         }
 991
 992       /* Check for and handle stack overflow.  */
 993       top++;
 994       if (top == limit)
 995         {
 996           struct op *new_stack;
 997           int old_size = (char *) limit - (char *) stack;
 998           int new_size = 2 * old_size;
 999           if (stack != init_stack)
1000             new_stack = (struct op *) xrealloc (stack, new_size);
1001           else
1002             {
1003               new_stack = (struct op *) xmalloc (new_size);
1004               memcpy (new_stack, stack, old_size);
1005             }
1006           stack = new_stack;
1007           top = (struct op *) ((char *) new_stack + old_size);
1008           limit = (struct op *) ((char *) new_stack + new_size);
1009         }
1010
1011       top->flags = flags;
1012       top->prio = prio & ~EXTRACT_PRIO(RIGHT_ASSOC);
1013       top->op = op.op;
1014     }
1015
1016  done:
1017   result = (top[1].value != 0);
1018   if (top != stack)
1019     CPP_ICE ("unbalanced stack in #if");
1020   else if (!(top[1].flags & HAVE_VALUE))
1021     {
1022       SYNTAX_ERROR ("#if with no expression");
1023     syntax_error:
1024       result = 0;  /* Return 0 on syntax error.  */
1025     }
1026
1027   /* Free dynamic stack if we allocated one.  */
1028   if (stack != init_stack)
1029     free (stack);
1030   pfile->skipping = save_skipping;
1031   return result;
1032 }