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