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