gcc/cppexp.c

   1 /* Parse C expressions for cpplib.
   2    Copyright (C) 1987, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2001
   3    Free Software Foundation.
   4    Contributed by Per Bothner, 1994.
   5
   6 This program is free software; you can redistribute it and/or modify it
   7 under the terms of the GNU General Public License as published by the
   8 Free Software Foundation; either version 2, or (at your option) any
   9 later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21 /* Parse a C expression from text in a string  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "cpplib.h"
  26 #include "cpphash.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, pedantic)
 209           && ! CPP_OPTION (pfile, c99))
 210         cpp_pedwarn (pfile, "too many 'l' suffixes in integer constant");
 211     }
 212
 213   if (base <= largest_digit)
 214     cpp_pedwarn (pfile, "integer constant contains digits beyond the radix");
 215
 216   if (overflow)
 217     cpp_pedwarn (pfile, "integer constant out of range");
 218
 219   /* If too big to be signed, consider it unsigned.  */
 220   else if ((HOST_WIDEST_INT) n < 0 && ! op.unsignedp)
 221     {
 222       if (base == 10)
 223         cpp_warning (pfile, "integer constant is so large that it is unsigned");
 224       op.unsignedp = 1;
 225     }
 226
 227   op.value = n;
 228   op.op = CPP_INT;
 229   return op;
 230
 231  invalid_suffix:
 232   cpp_error (pfile, "invalid suffix '%.*s' on integer constant",
 233              (int) (end - p), p);
 234  syntax_error:
 235   op.op = CPP_ERROR;
 236   return op;
 237 }
 238
 239 /* Parse and convert a character constant for #if.  Understands backslash
 240    escapes (\n, \031) and multibyte characters (if so configured).  */
 241 static struct op
 242 parse_charconst (pfile, tok)
 243      cpp_reader *pfile;
 244      const cpp_token *tok;
 245 {
 246   struct op op;
 247   HOST_WIDEST_INT result = 0;
 248   int num_chars = 0;
 249   int num_bits;
 250   unsigned int width = MAX_CHAR_TYPE_SIZE;
 251   HOST_WIDEST_INT mask = MAX_CHAR_TYPE_MASK;
 252   int max_chars;
 253   const U_CHAR *ptr = tok->val.str.text;
 254   const U_CHAR *end = ptr + tok->val.str.len;
 255
 256   int c = -1;
 257
 258   if (tok->type == CPP_WCHAR)
 259     width = MAX_WCHAR_TYPE_SIZE, mask = MAX_WCHAR_TYPE_MASK;
 260   max_chars = MAX_LONG_TYPE_SIZE / width;
 261
 262   while (ptr < end)
 263     {
 264       c = *ptr++;
 265       if (c == '\'')
 266         CPP_ICE ("unescaped ' in character constant");
 267       else if (c == '\\')
 268         {
 269           c = parse_escape (pfile, &ptr, end, mask);
 270           if (width < HOST_BITS_PER_INT
 271               && (unsigned int) c >= (unsigned int)(1 << width))
 272             cpp_pedwarn (pfile,
 273                          "escape sequence out of range for character");
 274         }
 275
 276       /* Merge character into result; ignore excess chars.  */
 277       if (++num_chars <= max_chars)
 278         {
 279           if (width < HOST_BITS_PER_INT)
 280             result = (result << width) | (c & ((1 << width) - 1));
 281           else
 282             result = c;
 283         }
 284     }
 285
 286   if (num_chars == 0)
 287     SYNTAX_ERROR ("empty character constant");
 288   else if (num_chars > max_chars)
 289     SYNTAX_ERROR ("character constant too long");
 290   else if (num_chars != 1)
 291     cpp_warning (pfile, "multi-character character constant");
 292
 293   /* If char type is signed, sign-extend the constant.  */
 294   num_bits = num_chars * width;
 295
 296   if (pfile->spec_nodes.n__CHAR_UNSIGNED__->type == NT_MACRO
 297       || ((result >> (num_bits - 1)) & 1) == 0)
 298     op.value = result & ((unsigned HOST_WIDEST_INT) ~0
 299                          >> (HOST_BITS_PER_WIDEST_INT - num_bits));
 300   else
 301     op.value = result | ~((unsigned HOST_WIDEST_INT) ~0
 302                           >> (HOST_BITS_PER_WIDEST_INT - num_bits));
 303
 304   /* This is always a signed type.  */
 305   op.unsignedp = 0;
 306   op.op = CPP_INT;
 307   return op;
 308
 309  syntax_error:
 310   op.op = CPP_ERROR;
 311   return op;
 312 }
 313
 314 static struct op
 315 parse_defined (pfile)
 316      cpp_reader *pfile;
 317 {
 318   int paren = 0;
 319   cpp_hashnode *node = 0;
 320   cpp_token token;
 321   struct op op;
 322
 323   /* Don't expand macros.  */
 324   pfile->state.prevent_expansion++;
 325
 326   cpp_get_token (pfile, &token);
 327   if (token.type == CPP_OPEN_PAREN)
 328     {
 329       paren = 1;
 330       cpp_get_token (pfile, &token);
 331     }
 332
 333   if (token.type == CPP_NAME)
 334     {
 335       node = token.val.node;
 336       if (paren)
 337         {
 338           cpp_get_token (pfile, &token);
 339           if (token.type != CPP_CLOSE_PAREN)
 340             {
 341               cpp_error (pfile, "missing ')' after \"defined\"");
 342               node = 0;
 343             }
 344         }
 345     }
 346   else
 347     {
 348       cpp_error (pfile, "operator \"defined\" requires an identifier");
 349       if (token.flags & NAMED_OP)
 350         {
 351           cpp_token op;
 352
 353           op.flags = 0;
 354           op.type = token.type;
 355           cpp_error (pfile,
 356                      "(\"%s\" is an alternative token for \"%s\" in C++)",
 357                      cpp_token_as_text (pfile, &token),
 358                      cpp_token_as_text (pfile, &op));
 359         }
 360     }
 361
 362   if (!node)
 363     op.op = CPP_ERROR;
 364   else
 365     {
 366       op.value = node->type == NT_MACRO;
 367       op.unsignedp = 0;
 368       op.op = CPP_INT;
 369
 370       /* No macros?  At top of file?  */
 371       if (pfile->mi_state == MI_OUTSIDE && pfile->mi_cmacro == 0
 372           && pfile->mi_if_not_defined == MI_IND_NOT && pfile->mi_lexed == 1)
 373         {
 374           cpp_start_lookahead (pfile);
 375           cpp_get_token (pfile, &token);
 376           if (token.type == CPP_EOF)
 377             pfile->mi_ind_cmacro = node;
 378           cpp_stop_lookahead (pfile, 0);
 379         }
 380     }
 381
 382   pfile->state.prevent_expansion--;
 383   return op;
 384 }
 385
 386 /* Read one token.  */
 387
 388 static struct op
 389 lex (pfile, skip_evaluation, token)
 390      cpp_reader *pfile;
 391      int skip_evaluation;
 392      cpp_token *token;
 393 {
 394   struct op op;
 395
 396   cpp_get_token (pfile, token);
 397
 398   switch (token->type)
 399     {
 400     case CPP_INT:
 401     case CPP_NUMBER:
 402       return parse_number (pfile, token);
 403
 404     case CPP_CHAR:
 405     case CPP_WCHAR:
 406       return parse_charconst (pfile, token);
 407
 408     case CPP_STRING:
 409     case CPP_WSTRING:
 410       SYNTAX_ERROR ("string constants are not valid in #if");
 411
 412     case CPP_FLOAT:
 413       SYNTAX_ERROR ("floating point numbers are not valid in #if");
 414
 415     case CPP_OTHER:
 416       if (ISGRAPH (token->val.c))
 417         SYNTAX_ERROR2 ("invalid character '%c' in #if", token->val.c);
 418       else
 419         SYNTAX_ERROR2 ("invalid character '\\%03o' in #if", token->val.c);
 420
 421     case CPP_NAME:
 422       if (token->val.node == pfile->spec_nodes.n_defined)
 423         {
 424           if (pfile->context->prev && CPP_PEDANTIC (pfile))
 425             cpp_pedwarn (pfile, "\"defined\" operator appears during macro expansion");
 426
 427           return parse_defined (pfile);
 428         }
 429       /* Controlling #if expressions cannot contain identifiers (they
 430          could become macros in the future).  */
 431       pfile->mi_state = MI_FAILED;
 432
 433       op.op = CPP_INT;
 434       op.unsignedp = 0;
 435       op.value = 0;
 436
 437       if (CPP_OPTION (pfile, warn_undef) && !skip_evaluation)
 438         cpp_warning (pfile, "\"%s\" is not defined", token->val.node->name);
 439
 440       return op;
 441
 442     case CPP_HASH:
 443       {
 444         int temp;
 445
 446         op.op = CPP_INT;
 447         if (_cpp_test_assertion (pfile, &temp))
 448           op.op = CPP_ERROR;
 449         op.unsignedp = 0;
 450         op.value = temp;
 451         return op;
 452       }
 453
 454     case CPP_NOT:
 455       /* We don't worry about its position here.  */
 456       pfile->mi_if_not_defined = MI_IND_NOT;
 457       /* Fall through.  */
 458
 459     default:
 460       if ((token->type > CPP_EQ && token->type < CPP_PLUS_EQ)
 461           || token->type == CPP_EOF)
 462         {
 463           op.op = token->type;
 464           return op;
 465         }
 466
 467       SYNTAX_ERROR2 ("\"%s\" is not valid in #if expressions",
 468                      cpp_token_as_text (pfile, token));
 469     }
 470
 471  syntax_error:
 472   op.op = CPP_ERROR;
 473   return op;
 474 }
 475
 476 /* Parse a C escape sequence.  STRING_PTR points to a variable
 477    containing a pointer to the string to parse.  That pointer
 478    is updated past the characters we use.  The value of the
 479    escape sequence is returned.
 480
 481    If \ is followed by 000, we return 0 and leave the string pointer
 482    after the zeros.  A value of 0 does not mean end of string.  */
 483
 484 static HOST_WIDEST_INT
 485 parse_escape (pfile, string_ptr, limit, result_mask)
 486      cpp_reader *pfile;
 487      const U_CHAR **string_ptr;
 488      const U_CHAR *limit;
 489      HOST_WIDEST_INT result_mask;
 490 {
 491   const U_CHAR *ptr = *string_ptr;
 492   /* We know we have at least one following character.  */
 493   int c = *ptr++;
 494   switch (c)
 495     {
 496     case 'a': c = TARGET_BELL;    break;
 497     case 'b': c = TARGET_BS;      break;
 498     case 'f': c = TARGET_FF;      break;
 499     case 'n': c = TARGET_NEWLINE; break;
 500     case 'r': c = TARGET_CR;      break;
 501     case 't': c = TARGET_TAB;     break;
 502     case 'v': c = TARGET_VT;      break;
 503
 504     case 'e': case 'E':
 505       if (CPP_PEDANTIC (pfile))
 506         cpp_pedwarn (pfile, "non-ISO-standard escape sequence, '\\%c'", c);
 507       c = TARGET_ESC;
 508       break;
 509
 510     case '0': case '1': case '2': case '3':
 511     case '4': case '5': case '6': case '7':
 512       {
 513         unsigned int i = c - '0';
 514         int count = 0;
 515         while (++count < 3)
 516           {
 517             if (ptr >= limit)
 518               break;
 519
 520             c = *ptr;
 521             if (c < '0' || c > '7')
 522               break;
 523             ptr++;
 524             i = (i << 3) + c - '0';
 525           }
 526         if (i != (i & result_mask))
 527           {
 528             i &= result_mask;
 529             cpp_pedwarn (pfile, "octal escape sequence out of range");
 530           }
 531         c = i;
 532         break;
 533       }
 534
 535     case 'x':
 536       {
 537         unsigned int i = 0, overflow = 0;
 538         int digits_found = 0, digit;
 539         for (;;)
 540           {
 541             if (ptr >= limit)
 542               break;
 543             c = *ptr;
 544             if (c >= '0' && c <= '9')
 545               digit = c - '0';
 546             else if (c >= 'a' && c <= 'f')
 547               digit = c - 'a' + 10;
 548             else if (c >= 'A' && c <= 'F')
 549               digit = c - 'A' + 10;
 550             else
 551               break;
 552             ptr++;
 553             overflow |= i ^ (i << 4 >> 4);
 554             i = (i << 4) + digit;
 555             digits_found = 1;
 556           }
 557         if (!digits_found)
 558           cpp_error (pfile, "\\x used with no following hex digits");
 559         if (overflow | (i != (i & result_mask)))
 560           {
 561             i &= result_mask;
 562             cpp_pedwarn (pfile, "hex escape sequence out of range");
 563           }
 564         c = i;
 565         break;
 566       }
 567     }
 568   *string_ptr = ptr;
 569   return c;
 570 }
 571
 572 static void
 573 integer_overflow (pfile)
 574      cpp_reader *pfile;
 575 {
 576   if (CPP_PEDANTIC (pfile))
 577     cpp_pedwarn (pfile, "integer overflow in preprocessor expression");
 578 }
 579
 580 static HOST_WIDEST_INT
 581 left_shift (pfile, a, unsignedp, b)
 582      cpp_reader *pfile;
 583      HOST_WIDEST_INT a;
 584      unsigned int unsignedp;
 585      unsigned HOST_WIDEST_INT b;
 586 {
 587   if (b >= HOST_BITS_PER_WIDEST_INT)
 588     {
 589       if (! unsignedp && a != 0)
 590         integer_overflow (pfile);
 591       return 0;
 592     }
 593   else if (unsignedp)
 594     return (unsigned HOST_WIDEST_INT) a << b;
 595   else
 596     {
 597       HOST_WIDEST_INT l = a << b;
 598       if (l >> b != a)
 599         integer_overflow (pfile);
 600       return l;
 601     }
 602 }
 603
 604 static HOST_WIDEST_INT
 605 right_shift (pfile, a, unsignedp, b)
 606      cpp_reader *pfile ATTRIBUTE_UNUSED;
 607      HOST_WIDEST_INT a;
 608      unsigned int unsignedp;
 609      unsigned HOST_WIDEST_INT b;
 610 {
 611   if (b >= HOST_BITS_PER_WIDEST_INT)
 612     return unsignedp ? 0 : a >> (HOST_BITS_PER_WIDEST_INT - 1);
 613   else if (unsignedp)
 614     return (unsigned HOST_WIDEST_INT) a >> b;
 615   else
 616     return a >> b;
 617 }
 618 \f
 619 /* Operator precedence and flags table.
 620
 621 After an operator is returned from the lexer, if it has priority less
 622 than or equal to the operator on the top of the stack, we reduce the
 623 stack by one operator and repeat the test.  Since equal priorities
 624 reduce, this is naturally left-associative.
 625
 626 We handle right-associative operators by clearing the lower bit of all
 627 left-associative operators, and setting it for right-associative ones.
 628 After the reduction phase of a new operator, just before it is pushed
 629 onto the stack, its RIGHT_ASSOC bit is cleared.  The effect is that
 630 during the reduction phase, the current right-associative operator has
 631 a priority one greater than any other operator of otherwise equal
 632 precedence that has been pushed on the top of the stack.  This avoids
 633 a reduction pass, and effectively makes the logic right-associative.
 634
 635 The remaining cases are '(' and ')'.  We handle '(' by skipping the
 636 reduction phase completely.  ')' is given lower priority than
 637 everything else, including '(', effectively forcing a reduction of the
 638 parenthesised expression.  If there is no matching '(', the stack will
 639 be reduced all the way to the beginning, exiting the parser in the
 640 same way as the ultra-low priority end-of-expression dummy operator.
 641 The exit code checks to see if the operator that caused it is ')', and
 642 if so outputs an appropriate error message.
 643
 644 The parser assumes all shifted operators require a right operand
 645 unless the flag NO_R_OPERAND is set, and similarly for NO_L_OPERAND.
 646 These semantics are automatically checked, any extra semantics need to
 647 be handled with operator-specific code.  */
 648
 649 #define FLAG_BITS  8
 650 #define FLAG_MASK ((1 << FLAG_BITS) - 1)
 651 #define PRIO_SHIFT (FLAG_BITS + 1)
 652 #define EXTRACT_PRIO(cnst) (cnst >> FLAG_BITS)
 653 #define EXTRACT_FLAGS(cnst) (cnst & FLAG_MASK)
 654
 655 /* Flags.  */
 656 #define HAVE_VALUE     (1 << 0)
 657 #define NO_L_OPERAND   (1 << 1)
 658 #define NO_R_OPERAND   (1 << 2)
 659 #define SHORT_CIRCUIT  (1 << 3)
 660
 661 /* Priority and flag combinations.  */
 662 #define RIGHT_ASSOC         (1 << FLAG_BITS)
 663 #define FORCE_REDUCE_PRIO   (0 << PRIO_SHIFT)
 664 #define CLOSE_PAREN_PRIO    (1 << PRIO_SHIFT)
 665 #define OPEN_PAREN_PRIO    ((2 << PRIO_SHIFT) | NO_L_OPERAND)
 666 #define COMMA_PRIO          (3 << PRIO_SHIFT)
 667 #define COND_PRIO          ((4 << PRIO_SHIFT) | RIGHT_ASSOC | SHORT_CIRCUIT)
 668 #define COLON_PRIO         ((5 << PRIO_SHIFT) | SHORT_CIRCUIT)
 669 #define OROR_PRIO          ((6 << PRIO_SHIFT) | SHORT_CIRCUIT)
 670 #define ANDAND_PRIO        ((7 << PRIO_SHIFT) | SHORT_CIRCUIT)
 671 #define OR_PRIO             (8 << PRIO_SHIFT)
 672 #define XOR_PRIO            (9 << PRIO_SHIFT)
 673 #define AND_PRIO           (10 << PRIO_SHIFT)
 674 #define MINMAX_PRIO        (11 << PRIO_SHIFT)
 675 #define EQUAL_PRIO         (12 << PRIO_SHIFT)
 676 #define LESS_PRIO          (13 << PRIO_SHIFT)
 677 #define SHIFT_PRIO         (14 << PRIO_SHIFT)
 678 #define PLUS_PRIO          (15 << PRIO_SHIFT)
 679 #define MUL_PRIO           (16 << PRIO_SHIFT)
 680 #define UNARY_PRIO        ((17 << PRIO_SHIFT) | RIGHT_ASSOC | NO_L_OPERAND)
 681
 682 /* Operator to priority map.  Must be in the same order as the first
 683    N entries of enum cpp_ttype.  */
 684 static const short
 685 op_to_prio[] =
 686 {
 687   /* EQ */              0,              /* dummy entry - can't happen */
 688   /* NOT */             UNARY_PRIO,
 689   /* GREATER */         LESS_PRIO,
 690   /* LESS */            LESS_PRIO,
 691   /* PLUS */            UNARY_PRIO,     /* note these two can be unary */
 692   /* MINUS */           UNARY_PRIO,     /* or binary */
 693   /* MULT */            MUL_PRIO,
 694   /* DIV */             MUL_PRIO,
 695   /* MOD */             MUL_PRIO,
 696   /* AND */             AND_PRIO,
 697   /* OR */              OR_PRIO,
 698   /* XOR */             XOR_PRIO,
 699   /* RSHIFT */          SHIFT_PRIO,
 700   /* LSHIFT */          SHIFT_PRIO,
 701   /* MIN */             MINMAX_PRIO,    /* C++ specific */
 702   /* MAX */             MINMAX_PRIO,    /* extensions */
 703
 704   /* COMPL */           UNARY_PRIO,
 705   /* AND_AND */         ANDAND_PRIO,
 706   /* OR_OR */           OROR_PRIO,
 707   /* QUERY */           COND_PRIO,
 708   /* COLON */           COLON_PRIO,
 709   /* COMMA */           COMMA_PRIO,
 710   /* OPEN_PAREN */      OPEN_PAREN_PRIO,
 711   /* CLOSE_PAREN */     CLOSE_PAREN_PRIO,
 712   /* EQ_EQ */           EQUAL_PRIO,
 713   /* NOT_EQ */          EQUAL_PRIO,
 714   /* GREATER_EQ */      LESS_PRIO,
 715   /* LESS_EQ */         LESS_PRIO
 716 };
 717
 718 #define COMPARE(OP) \
 719   top->unsignedp = 0; \
 720   top->value = (unsigned1 | unsigned2) \
 721   ? (unsigned HOST_WIDEST_INT) v1 OP (unsigned HOST_WIDEST_INT) v2 \
 722   : (v1 OP v2)
 723 #define EQUALITY(OP) \
 724   top->value = v1 OP v2; \
 725   top->unsignedp = 0;
 726 #define BITWISE(OP) \
 727   top->value = v1 OP v2; \
 728   top->unsignedp = unsigned1 | unsigned2;
 729 #define MINMAX(OP) \
 730   top->value = (v1 OP v2) ? v1 : v2; \
 731   top->unsignedp = unsigned1 | unsigned2;
 732 #define UNARY(OP) \
 733   top->value = OP v2; \
 734   top->unsignedp = unsigned2; \
 735   top->flags |= HAVE_VALUE;
 736 #define SHIFT(PSH, MSH) \
 737   if (skip_evaluation)  \
 738     break;              \
 739   top->unsignedp = unsigned1; \
 740   if (v2 < 0 && ! unsigned2)  \
 741     top->value = MSH (pfile, v1, unsigned1, -v2); \
 742   else \
 743     top->value = PSH (pfile, v1, unsigned1, v2);
 744
 745 /* Parse and evaluate a C expression, reading from PFILE.
 746    Returns the truth value of the expression.  */
 747
 748 int
 749 _cpp_parse_expr (pfile)
 750      cpp_reader *pfile;
 751 {
 752   /* The implementation is an operator precedence parser, i.e. a
 753      bottom-up parser, using a stack for not-yet-reduced tokens.
 754
 755      The stack base is 'stack', and the current stack pointer is 'top'.
 756      There is a stack element for each operator (only),
 757      and the most recently pushed operator is 'top->op'.
 758      An operand (value) is stored in the 'value' field of the stack
 759      element of the operator that precedes it.
 760      In that case the 'flags' field has the HAVE_VALUE flag set.  */
 761
 762 #define INIT_STACK_SIZE 20
 763   struct op init_stack[INIT_STACK_SIZE];
 764   struct op *stack = init_stack;
 765   struct op *limit = stack + INIT_STACK_SIZE;
 766   cpp_token token;
 767   register struct op *top = stack + 1;
 768   int skip_evaluation = 0;
 769   int result;
 770
 771   /* Set up detection of #if ! defined().  */
 772   pfile->mi_lexed = 0;
 773   pfile->mi_if_not_defined = MI_IND_NONE;
 774
 775   /* We've finished when we try to reduce this.  */
 776   top->op = CPP_EOF;
 777   /* Nifty way to catch missing '('.  */
 778   top->prio = EXTRACT_PRIO(CLOSE_PAREN_PRIO);
 779   /* Avoid missing right operand checks.  */
 780   top->flags = NO_R_OPERAND;
 781
 782   for (;;)
 783     {
 784       unsigned int prio;
 785       unsigned int flags;
 786       struct op op;
 787
 788       /* Read a token */
 789       op = lex (pfile, skip_evaluation, &token);
 790       pfile->mi_lexed++;
 791
 792       /* If the token is an operand, push its value and get next
 793          token.  If it is an operator, get its priority and flags, and
 794          try to reduce the expression on the stack.  */
 795       switch (op.op)
 796         {
 797         case CPP_ERROR:
 798           goto syntax_error;
 799         push_immediate:
 800         case CPP_INT:
 801           /* Push a value onto the stack.  */
 802           if (top->flags & HAVE_VALUE)
 803             SYNTAX_ERROR ("missing binary operator");
 804           top->value = op.value;
 805           top->unsignedp = op.unsignedp;
 806           top->flags |= HAVE_VALUE;
 807           continue;
 808
 809         case CPP_EOF:   prio = FORCE_REDUCE_PRIO;       break;
 810         case CPP_PLUS:
 811         case CPP_MINUS: prio = PLUS_PRIO;  if (top->flags & HAVE_VALUE) break;
 812           /* else unary; fall through */
 813         default:        prio = op_to_prio[op.op];       break;
 814         }
 815
 816       /* Separate the operator's code into priority and flags.  */
 817       flags = EXTRACT_FLAGS(prio);
 818       prio = EXTRACT_PRIO(prio);
 819       if (prio == EXTRACT_PRIO(OPEN_PAREN_PRIO))
 820         goto skip_reduction;
 821
 822       /* Check for reductions.  Then push the operator.  */
 823       while (prio <= top->prio)
 824         {
 825           HOST_WIDEST_INT v1, v2;
 826           unsigned int unsigned1, unsigned2;
 827
 828           /* Most operators that can appear on the stack require a
 829              right operand.  Check this before trying to reduce.  */
 830           if ((top->flags & (HAVE_VALUE | NO_R_OPERAND)) == 0)
 831             {
 832               if (top->op == CPP_OPEN_PAREN)
 833                 SYNTAX_ERROR ("void expression between '(' and ')'");
 834               else
 835                 SYNTAX_ERROR2 ("operator '%s' has no right operand",
 836                                op_as_text (pfile, top->op));
 837             }
 838
 839           unsigned2 = top->unsignedp, v2 = top->value;
 840           top--;
 841           unsigned1 = top->unsignedp, v1 = top->value;
 842
 843           /* Now set top->value = (top[1].op)(v1, v2); */
 844           switch (top[1].op)
 845             {
 846             default:
 847               cpp_ice (pfile, "impossible operator '%s'",
 848                                op_as_text (pfile, top[1].op));
 849               goto syntax_error;
 850
 851             case CPP_NOT:        UNARY(!);      break;
 852             case CPP_COMPL:      UNARY(~);      break;
 853             case CPP_LESS:       COMPARE(<);    break;
 854             case CPP_GREATER:    COMPARE(>);    break;
 855             case CPP_LESS_EQ:    COMPARE(<=);   break;
 856             case CPP_GREATER_EQ: COMPARE(>=);   break;
 857             case CPP_EQ_EQ:      EQUALITY(==);  break;
 858             case CPP_NOT_EQ:     EQUALITY(!=);  break;
 859             case CPP_AND:        BITWISE(&);    break;
 860             case CPP_XOR:        BITWISE(^);    break;
 861             case CPP_OR:         BITWISE(|);    break;
 862             case CPP_LSHIFT:     SHIFT(left_shift, right_shift); break;
 863             case CPP_RSHIFT:     SHIFT(right_shift, left_shift); break;
 864             case CPP_MIN:        MINMAX(<);     break;
 865             case CPP_MAX:        MINMAX(>);     break;
 866
 867             case CPP_PLUS:
 868               if (!(top->flags & HAVE_VALUE))
 869                 {
 870                   /* Can't use UNARY(+) because K+R C did not have unary
 871                      plus.  Can't use UNARY() because some compilers object
 872                      to the empty argument.  */
 873                   top->value = v2;
 874                   top->unsignedp = unsigned2;
 875                   top->flags |= HAVE_VALUE;
 876
 877                   if (CPP_WTRADITIONAL (pfile))
 878                     cpp_warning (pfile,
 879                         "traditional C rejects the unary plus operator");
 880                 }
 881               else
 882                 {
 883                   top->value = v1 + v2;
 884                   top->unsignedp = unsigned1 | unsigned2;
 885                   if (! top->unsignedp && ! skip_evaluation
 886                       && ! possible_sum_sign (v1, v2, top->value))
 887                     integer_overflow (pfile);
 888                 }
 889               break;
 890             case CPP_MINUS:
 891               if (!(top->flags & HAVE_VALUE))
 892                 {
 893                   UNARY(-);
 894                   if (!skip_evaluation && (top->value & v2) < 0 && !unsigned2)
 895                     integer_overflow (pfile);
 896                 }
 897               else
 898                 { /* Binary '-' */
 899                   top->value = v1 - v2;
 900                   top->unsignedp = unsigned1 | unsigned2;
 901                   if (! top->unsignedp && ! skip_evaluation
 902                       && ! possible_sum_sign (top->value, v2, v1))
 903                     integer_overflow (pfile);
 904                 }
 905               break;
 906             case CPP_MULT:
 907               top->unsignedp = unsigned1 | unsigned2;
 908               if (top->unsignedp)
 909                 top->value = (unsigned HOST_WIDEST_INT) v1 * v2;
 910               else if (!skip_evaluation)
 911                 {
 912                   top->value = v1 * v2;
 913                   if (v1 && (top->value / v1 != v2
 914                              || (top->value & v1 & v2) < 0))
 915                     integer_overflow (pfile);
 916                 }
 917               break;
 918             case CPP_DIV:
 919             case CPP_MOD:
 920               if (skip_evaluation)
 921                 break;
 922               if (v2 == 0)
 923                 SYNTAX_ERROR ("division by zero in #if");
 924               top->unsignedp = unsigned1 | unsigned2;
 925               if (top[1].op == CPP_DIV)
 926                 {
 927                   if (top->unsignedp)
 928                     top->value = (unsigned HOST_WIDEST_INT) v1 / v2;
 929                   else
 930                     {
 931                       top->value = v1 / v2;
 932                       if ((top->value & v1 & v2) < 0)
 933                         integer_overflow (pfile);
 934                     }
 935                 }
 936               else
 937                 {
 938                   if (top->unsignedp)
 939                     top->value = (unsigned HOST_WIDEST_INT) v1 % v2;
 940                   else
 941                     top->value = v1 % v2;
 942                 }
 943               break;
 944
 945             case CPP_OR_OR:
 946               top->value = v1 || v2;
 947               top->unsignedp = 0;
 948               if (v1) skip_evaluation--;
 949               break;
 950             case CPP_AND_AND:
 951               top->value = v1 && v2;
 952               top->unsignedp = 0;
 953               if (!v1) skip_evaluation--;
 954               break;
 955             case CPP_COMMA:
 956               if (CPP_PEDANTIC (pfile))
 957                 cpp_pedwarn (pfile, "comma operator in operand of #if");
 958               top->value = v2;
 959               top->unsignedp = unsigned2;
 960               break;
 961             case CPP_QUERY:
 962               SYNTAX_ERROR ("syntax error '?' without following ':'");
 963             case CPP_COLON:
 964               if (top[0].op != CPP_QUERY)
 965                 SYNTAX_ERROR ("syntax error ':' without preceding '?'");
 966               top--;
 967               if (top->value) skip_evaluation--;
 968               top->value = top->value ? v1 : v2;
 969               top->unsignedp = unsigned1 | unsigned2;
 970               break;
 971             case CPP_OPEN_PAREN:
 972               if (op.op != CPP_CLOSE_PAREN)
 973                 SYNTAX_ERROR ("missing ')' in expression");
 974               op.value = v2;
 975               op.unsignedp = unsigned2;
 976               goto push_immediate;
 977             case CPP_EOF:
 978               /* Reducing this dummy operator indicates we've finished.  */
 979               if (op.op == CPP_CLOSE_PAREN)
 980                 SYNTAX_ERROR ("missing '(' in expression");
 981               goto done;
 982             }
 983         }
 984
 985       /* Handle short-circuit evaluations.  */
 986       if (flags & SHORT_CIRCUIT)
 987         switch (op.op)
 988           {
 989           case CPP_OR_OR:    if (top->value) skip_evaluation++; break;
 990           case CPP_AND_AND:
 991           case CPP_QUERY:    if (!top->value) skip_evaluation++; break;
 992           case CPP_COLON:
 993             if (top[-1].value) /* Was '?' condition true?  */
 994               skip_evaluation++;
 995             else
 996               skip_evaluation--;
 997           default:
 998             break;
 999           }
1000
1001     skip_reduction:
1002       /* Check we have a left operand iff we need one.  */
1003       if (flags & NO_L_OPERAND)
1004         {
1005           if (top->flags & HAVE_VALUE)
1006             SYNTAX_ERROR2 ("missing binary operator before '%s'",
1007                            op_as_text (pfile, top->op));
1008         }
1009       else
1010         {
1011           if (!(top->flags & HAVE_VALUE))
1012             SYNTAX_ERROR2 ("operator '%s' has no left operand",
1013                            op_as_text (pfile, top->op));
1014         }
1015
1016       /* Check for and handle stack overflow.  */
1017       top++;
1018       if (top == limit)
1019         {
1020           struct op *new_stack;
1021           int old_size = (char *) limit - (char *) stack;
1022           int new_size = 2 * old_size;
1023           if (stack != init_stack)
1024             new_stack = (struct op *) xrealloc (stack, new_size);
1025           else
1026             {
1027               new_stack = (struct op *) xmalloc (new_size);
1028               memcpy (new_stack, stack, old_size);
1029             }
1030           stack = new_stack;
1031           top = (struct op *) ((char *) new_stack + old_size);
1032           limit = (struct op *) ((char *) new_stack + new_size);
1033         }
1034
1035       top->flags = flags;
1036       top->prio = prio & ~EXTRACT_PRIO(RIGHT_ASSOC);
1037       top->op = op.op;
1038     }
1039
1040  done:
1041   result = (top[1].value != 0);
1042   if (top != stack)
1043     CPP_ICE ("unbalanced stack in #if");
1044   else if (!(top[1].flags & HAVE_VALUE))
1045     {
1046       SYNTAX_ERROR ("#if with no expression");
1047     syntax_error:
1048       result = 0;  /* Return 0 on syntax error.  */
1049     }
1050
1051   /* Free dynamic stack if we allocated one.  */
1052   if (stack != init_stack)
1053     free (stack);
1054   return result;
1055 }
1056
1057 static const unsigned char *
1058 op_as_text (pfile, op)
1059      cpp_reader *pfile;
1060      enum cpp_ttype op;
1061 {
1062   cpp_token token;
1063
1064   token.type = op;
1065   token.flags = 0;
1066   return cpp_token_as_text (pfile, &token);
1067 }