src/cppexp.c

   1 /*
   2 ** Splint - annotation-assisted static program checker
   3 ** Copyright (C) 1994-2003 University of Virginia,
   4 **         Massachusetts Institute of Technology
   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 of the License, or (at your
   9 ** option) any later version.
  10 **
  11 ** This program is distributed in the hope that it will be useful, but
  12 ** WITHOUT ANY WARRANTY; without even the implied warranty of
  13 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 ** General Public License for more details.
  15 **
  16 ** The GNU General Public License is available from http://www.gnu.org/ or
  17 ** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  18 ** MA 02111-1307, USA.
  19 **
  20 ** For information on splint: info@splint.org
  21 ** To report a bug: splint-bug@splint.org
  22 ** For more information: http://www.splint.org
  23 */
  24 /*
  25 ** cppexp.c
  26 */
  27 /* Parse C expressions for CCCP.
  28    Copyright (C) 1987, 1992, 1994, 1995, 1997 Free Software Foundation.
  29
  30 This program is free software; you can redistribute it and/or modify it
  31 under the terms of the GNU General Public License as published by the
  32 Free Software Foundation; either version 2, or (at your option) any
  33 later version.
  34
  35 This program is distributed in the hope that it will be useful,
  36 but WITHOUT ANY WARRANTY; without even the implied warranty of
  37 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  38 GNU General Public License for more details.
  39
  40 You should have received a copy of the GNU General Public License
  41 along with this program; if not, write to the Free Software
  42 Foundation, 59 Temple Place - Suite 330,
  43 Boston, MA 02111-1307, USA.
  44
  45  In other words, you are welcome to use, share and improve this program.
  46  You are forbidden to forbid anyone else to use, share and improve
  47  what you give them.   Help stamp out software-hoarding!
  48
  49 Written by Per Bothner 1994.  */
  50
  51 /* Parse a C expression from text in a string  */
  52
  53 /*@+charint@*/
  54 /*@+ignorequals@*/
  55 /*@+ignoresigns@*/
  56 /*@+matchanyintegral@*/
  57
  58 # include "splintMacros.nf"
  59 # include "basic.h"
  60
  61 # include "cppconf.h"
  62 # include "cpplib.h"
  63 # include "cpphash.h"
  64 # include "cppexp.h"
  65 # include "cpperror.h"
  66
  67
  68 /*@constant short CPPREADER_ERRORTOK@*/
  69 #define CPPREADER_ERRORTOK 299
  70
  71 /*@constant int OROR@*/
  72 #define OROR 300
  73
  74 /*@constant int ANDAND@*/
  75 #define ANDAND 301
  76
  77 /*@constant int CPP_EQUALTOK@*/
  78 #define CPP_EQUALTOK 302
  79
  80 /*@constant int NOTEQUAL@*/
  81 #define NOTEQUAL 303
  82
  83 /*@constant int LEQ@*/
  84 #define LEQ 304
  85
  86 /*@constant int GEQ@*/
  87 #define GEQ 305
  88
  89 /*@constant int LSH@*/
  90 #define LSH 306
  91
  92 /*@constant int RSH@*/
  93 #define RSH 307
  94
  95 /*@constant int NAME@*/
  96 #define NAME 308
  97
  98 /*@constant short CPPEXP_INT@*/
  99 #define CPPEXP_INT 309
 100
 101 /*@constant short CPPEXP_CHAR@*/
 102 #define CPPEXP_CHAR 310
 103
 104 /*@constant int LEFT_OPERAND_REQUIRED@*/
 105 #define LEFT_OPERAND_REQUIRED 1
 106
 107 /*@constant int RIGHT_OPERAND_REQUIRED@*/
 108 #define RIGHT_OPERAND_REQUIRED 2
 109
 110 /*@constant int HAVE_VALUE@*/
 111 #define HAVE_VALUE 4
 112
 113 /* Yield nonzero if adding two numbers with A's and B's signs can yield a
 114    number with SUM's sign, where A, B, and SUM are all C integers.  */
 115
 116 /*@function static bool possibleSumSign (sef int, int, int)
 117       modifies nothing ; @*/
 118
 119 #define possibleSumSign(a, b, sum) ((((a) ^ (b)) | ~ ((a) ^ (sum))) < 0)
 120
 121 static struct operation cppexp_lex (cppReader *);
 122 static void integer_overflow (cppReader *);
 123 static long left_shift (cppReader *, long, bool p_unsignedp, unsigned long);
 124 static long right_shift (long, bool p_unsignedp, unsigned long);
 125
 126
 127 struct operation {
 128   short op;
 129
 130   /* Priority of op (relative to it right operand).  */
 131   /*@reldef@*/ char rprio;
 132
 133   /*@reldef@*/ char flags;
 134
 135   /* true if value should be treated as unsigned */
 136   /*@reldef@*/ bool unsignedp;
 137
 138   /* The value logically "right" of op.  */
 139   /*@reldef@*/ HOST_WIDE_INT value;
 140 } ;
 141
 142 /* Take care of parsing a number (anything that starts with a digit).
 143    LEN is the number of characters in it.  */
 144
 145 /* maybe needs to actually deal with floating point numbers */
 146
 147 static struct operation
 148 cppReader_parseNumber (cppReader *pfile, char *start, int olen) /*@requires maxRead(start) >= (olen - 1) @*/
 149 {
 150   struct operation op;
 151   char *p = start;
 152   char c;
 153   int i;
 154   long n = 0;
 155   unsigned long nd, ULONG_MAX_over_base;
 156   int base = 10;
 157   int len = olen;
 158   bool overflow = FALSE;
 159   int digit, largest_digit = 0;
 160   bool spec_long = FALSE;
 161
 162   op.unsignedp = FALSE;
 163
 164   for (i = 0; i < len; i++)
 165     {
 166        if (p[i] == '.') {
 167         /* It's a float since it contains a point.  */
 168         cppReader_errorLit
 169           (pfile,
 170            cstring_makeLiteralTemp
 171            ("Floating point numbers not allowed in #if expressions"));
 172         op.op = CPPREADER_ERRORTOK;
 173         return op;
 174       }
 175     }
 176
 177   if (len >= 3 && (mstring_equalPrefix (p, "0x")
 178                    || mstring_equalPrefix (p, "0X")))
 179     {
 180       p += 2;
 181       base = 16;
 182       len -= 2;
 183     }
 184   else if (*p == '0')
 185     {
 186       base = 8;
 187     }
 188   else
 189     {
 190       ;
 191     }
 192
 193   /* Some buggy compilers (e.g. MPW C) seem to need both casts.  */
 194   ULONG_MAX_over_base = ((unsigned long) -1) / ((unsigned long) base);
 195
 196   for (; len > 0; len--) {
 197     c = *p++;
 198
 199     if (c >= '0' && c <= '9')
 200       {
 201         digit = (int) (c - '0');
 202       }
 203     else if (base == 16 && c >= 'a' && c <= 'f')
 204       {
 205         digit = (int) (c - 'a') + 10;
 206       }
 207     else if (base == 16 && c >= 'A' && c <= 'F')
 208       {
 209         digit = (int) (c - 'A') + 10;
 210       }
 211     else
 212       {
 213         /* `l' means long, and `u' means unsigned.  */
 214         while (TRUE)
 215           {
 216             if (c == 'l' || c == 'L')
 217               {
 218                 if (spec_long)
 219                   cppReader_errorLit (pfile,
 220                                       cstring_makeLiteralTemp ("two `l's in integer constant"));
 221                 spec_long = TRUE;
 222               }
 223             else if (c == 'u' || c == 'U')
 224               {
 225                 if (op.unsignedp)
 226                   cppReader_errorLit (pfile,
 227                                       cstring_makeLiteralTemp ("two `u's in integer constant"));
 228                 op.unsignedp = TRUE;
 229               }
 230             else
 231               {
 232                 /*@innerbreak@*/ break;
 233               }
 234
 235             if (--len == 0)
 236               {
 237                 /*@innerbreak@*/ break;
 238               }
 239
 240              c = *p++;
 241           }
 242         /* Don't look for any more digits after the suffixes.  */
 243         break;
 244       }
 245
 246     if (largest_digit < digit)
 247       {
 248         largest_digit = digit;
 249       }
 250
 251     nd = (long unsigned) (n * base + digit);
 252     overflow |= (ULONG_MAX_over_base < (unsigned long) n)
 253       | (nd < (unsigned long) n);
 254     n = (long) nd;
 255   }
 256
 257   if (len != 0)
 258     {
 259       cppReader_errorLit
 260         (pfile,
 261          cstring_makeLiteralTemp ("Invalid number in #if expression"));
 262       op.op = CPPREADER_ERRORTOK;
 263       return op;
 264     }
 265
 266   if (base <= largest_digit)
 267     {
 268       cppReader_pedwarnLit
 269         (pfile,
 270          cstring_makeLiteralTemp
 271          ("Integer constant contains digits beyond the radix"));
 272     }
 273
 274   if (overflow)
 275     {
 276       cppReader_pedwarnLit
 277         (pfile,
 278          cstring_makeLiteralTemp ("Integer constant out of range"));
 279     }
 280
 281   /* If too big to be signed, consider it unsigned.  */
 282   if ((long) n < 0 && ! op.unsignedp)
 283     {
 284       if (base == 10)
 285         {
 286           cppReader_warningLit
 287             (pfile,
 288              cstring_makeLiteralTemp ("Integer constant is so large that it is unsigned"));
 289         }
 290
 291       op.unsignedp = TRUE;
 292     }
 293
 294   op.value = n;
 295   op.op = CPPEXP_INT;
 296   DPRINTF (("Parse number: %d", op.value));
 297   return op;
 298 }
 299
 300 struct token {
 301   /*@null@*/ /*@observer@*/ char *operator;
 302   int token;
 303 };
 304
 305 static struct token tokentab2[] = {
 306   { "&&", ANDAND },
 307   { "||", OROR },
 308   { "<<", LSH },
 309   { ">>", RSH },
 310   { "==", CPP_EQUALTOK },
 311   { "!=", NOTEQUAL },
 312   { "<=", LEQ },
 313   { ">=", GEQ },
 314   { "++", CPPREADER_ERRORTOK },
 315   { "--", CPPREADER_ERRORTOK },
 316   { NULL, CPPREADER_ERRORTOK }
 317 } ;
 318
 319 /* Read one token.  */
 320
 321 struct operation cppexp_lex (cppReader *pfile)
 322 {
 323   int ic;
 324   char c;
 325   register struct token *toktab;
 326   enum cpp_token token;
 327   struct operation op;
 328   char *tok_start, *tok_end;
 329   int old_written;
 330
 331  retry:
 332
 333   old_written = size_toInt (cpplib_getWritten (pfile));
 334   cppSkipHspace (pfile);
 335   ic = cpplib_bufPeek (cppReader_getBufferSafe (pfile));
 336
 337   c = (char) ic;
 338
 339   if  (c == '#')
 340     {
 341       /* was: llassert (c != '#'); - Solaris uses this, attempt to continue anyway... */
 342       cppReader_pedwarn (pfile,
 343                          message ("non-standard pre-processor directive: %c", c));
 344     }
 345
 346   DPRINTF (("Read: %c", c));
 347
 348   if (c == '\n')
 349     {
 350       op.op = 0;
 351       return op;
 352     }
 353
 354   token = cpplib_getTokenForceExpand (pfile);
 355
 356   tok_start = pfile->token_buffer + old_written;
 357   tok_end = cpplib_getPWritten (pfile);
 358
 359   DPRINTF (("Token: %s < %s", tok_start, tok_end));
 360
 361   pfile->limit = tok_start;
 362
 363   switch (token)
 364     {
 365     case CPP_EOF: /* Should not happen ...  */
 366     case CPP_VSPACE:
 367       op.op = 0;
 368       return op;
 369     case CPP_POP:
 370       if (cstring_isDefined (cppReader_getBufferSafe (pfile)->fname))
 371         {
 372           op.op = 0;
 373           return op;
 374         }
 375       (void) cppReader_popBuffer (pfile);
 376       goto retry;
 377     case CPP_HSPACE:   case CPP_COMMENT:
 378       goto retry;
 379     case CPP_NUMBER:
 380       return cppReader_parseNumber (pfile, tok_start, tok_end - tok_start);
 381     case CPP_STRING:
 382       cppReader_errorLit (pfile,
 383                           cstring_makeLiteralTemp ("string constants not allowed in #if expressions"));
 384       op.op = CPPREADER_ERRORTOK;
 385       return op;
 386     case CPP_CHAR:
 387       /* This code for reading a character constant
 388          handles multicharacter constants and wide characters.
 389          It is mostly copied from c-lex.c.  */
 390       {
 391         int result = 0;
 392         int num_chars = 0;
 393         size_t width = MAX_CHAR_TYPE_SIZE;
 394         int wide_flag = 0;
 395         int max_chars;
 396         char *ptr = tok_start;
 397
 398         if (*ptr == 'L')
 399           {
 400             ptr++;
 401             wide_flag = 1;
 402             width = MAX_WCHAR_TYPE_SIZE;
 403             max_chars = 1;
 404           }
 405         else
 406           {
 407             max_chars = size_toInt (MAX_LONG_TYPE_SIZE / width);
 408           }
 409
 410         ++ptr;
 411          while (ptr < tok_end && ((c = *ptr++) != '\''))
 412           {
 413             if (c == '\\')
 414               {
 415                 c = cppReader_parseEscape (pfile, &ptr);
 416                 if (width < HOST_BITS_PER_INT && c >= (1 << width))
 417                   {
 418                     cppReader_pedwarnLit
 419                       (pfile,
 420                        cstring_makeLiteralTemp ("Escape sequence out of range for character"));
 421                   }
 422               }
 423
 424             num_chars++;
 425
 426             /* Merge character into result; ignore excess chars.  */
 427             if (num_chars < max_chars + 1)
 428               {
 429                 if (width < HOST_BITS_PER_INT)
 430                   {
 431                     result = (int) ((unsigned) result << width) | (c & ((1 << width) - 1));
 432                   }
 433                 else
 434                   {
 435                     result = c;
 436                   }
 437               }
 438           }
 439
 440         if (c != '\'')
 441           cppReader_errorLit (pfile,
 442                               cstring_makeLiteralTemp ("malformatted character constant"));
 443         else if (num_chars == 0)
 444           cppReader_errorLit (pfile,
 445                               cstring_makeLiteralTemp ("empty character constant"));
 446         else if (num_chars > max_chars)
 447           {
 448             num_chars = max_chars;
 449             cppReader_errorLit (pfile,
 450                                 cstring_makeLiteralTemp ("character constant too long"));
 451           }
 452         else if (num_chars != 1 && ! cppReader_isTraditional (pfile))
 453           {
 454             cppReader_warningLit (pfile,
 455                                   cstring_makeLiteralTemp ("multi-character character constant"));
 456           }
 457         else
 458           {
 459             ;
 460           }
 461
 462         /* If char type is signed, sign-extend the constant.  */
 463         if (wide_flag == 0)
 464           {
 465             int num_bits = num_chars * width;
 466
 467             if ((cpphash_lookup ("__CHAR_UNSIGNED__",
 468                              sizeof ("__CHAR_UNSIGNED__") - 1, -1) != NULL)
 469                 || (((unsigned) result >> (int_toNonNegative (num_bits - 1))) & 1) == 0)
 470               {
 471                 op.value
 472                   = result & ((unsigned long) ~0
 473                               >> int_toNonNegative ((HOST_BITS_PER_LONG - num_bits)));
 474               }
 475             else
 476               {
 477                 op.value
 478                   = result | ~((unsigned long) ~0
 479                                >> int_toNonNegative ((HOST_BITS_PER_LONG - num_bits)));
 480               }
 481           }
 482         else
 483           {
 484               op.value = result;
 485           }
 486         }
 487
 488       /* This is always a signed type.  */
 489       op.unsignedp = FALSE;
 490       op.op = CPPEXP_CHAR;
 491
 492       return op;
 493
 494     case CPP_NAME:
 495       DPRINTF (("Name!"));
 496       return cppReader_parseNumber (pfile, "0", 0);
 497
 498     case CPP_OTHER:
 499       /* See if it is a special token of length 2.  */
 500       if (tok_start + 2 == tok_end)
 501         {
 502           for (toktab = tokentab2; toktab->operator != NULL; toktab++)
 503             {
 504              if (tok_start[0] == toktab->operator[0]  &&
 505                  tok_start[1] == toktab->operator[1])
 506                 {
 507                   /*@loopbreak@*/ break;
 508                 }
 509             }
 510
 511           if (toktab->token == CPPREADER_ERRORTOK)
 512             {
 513               cppReader_error (pfile,
 514                                message ("`%s' not allowed in operand of `#if'",
 515                                         cstring_fromChars (tok_start)));
 516             }
 517
 518           op.op = toktab->token;
 519           return op;
 520         }
 521       /*@fallthrough@*/
 522     default:
 523       op.op = *tok_start;
 524       return op;
 525   }
 526
 527   /*@notreached@*/
 528   BADEXIT;
 529 }
 530
 531
 532 /* Parse a C escape sequence.  STRING_PTR points to a variable
 533    containing a pointer to the string to parse.  That pointer
 534    is updated past the characters we use.  The value of the
 535    escape sequence is returned.
 536
 537    A negative value means the sequence \ newline was seen,
 538    which is supposed to be equivalent to nothing at all.
 539
 540    If \ is followed by a null character, we return a negative
 541    value and leave the string pointer pointing at the null character.
 542
 543    If \ is followed by 000, we return 0 and leave the string pointer
 544    after the zeros.  A value of 0 does not mean end of string.  */
 545
 546 int
 547 cppReader_parseEscape (cppReader *pfile, char **string_ptr)
 548 {
 549    char c = *(*string_ptr)++;
 550
 551   switch (c)
 552     {
 553     case 'a':
 554       return TARGET_BELL;
 555     case 'b':
 556       return TARGET_BS;
 557     case 'e':
 558     case 'E':
 559       if (cppReader_isPedantic (pfile))
 560         {
 561           cppReader_pedwarn (pfile,
 562                        message ("non-standard escape sequence, `\\%c'", c));
 563         }
 564       return (char) 033;
 565     case 'f':
 566       return TARGET_FF;
 567     case 'n':
 568       return TARGET_NEWLINE;
 569     case 'r':
 570       return TARGET_CR;
 571     case 't':
 572       return TARGET_TAB;
 573     case 'v':
 574       return TARGET_VT;
 575     case '\n':
 576       return -2;
 577     case 0:
 578       (*string_ptr)--;
 579       return 0;
 580
 581     case '0':
 582     case '1':
 583     case '2':
 584     case '3':
 585     case '4':
 586     case '5':
 587     case '6':
 588     case '7':
 589       {
 590         int i = (int) c - '0';
 591         int count = 0;
 592
 593         while (++count < 3)
 594           {
 595             c = *(*string_ptr)++;
 596             if (c >= '0' && c <= '7')
 597               {
 598                 i = ((unsigned) i << 3) + c - '0';
 599               }
 600
 601             else
 602               {
 603                 (*string_ptr)--;
 604                 /*@loopbreak@*/ break;
 605               }
 606           }
 607         if ((i & ~((1 << MAX_CHAR_TYPE_SIZE) - 1)) != 0)
 608           {
 609             i &= (1 << MAX_CHAR_TYPE_SIZE) - 1;
 610             cppReader_pedwarnLit (pfile,
 611                             cstring_makeLiteralTemp ("octal character constant does not fit in a byte"));
 612           }
 613         return i;
 614       }
 615     case 'x':
 616       {
 617         register unsigned i = 0, overflow = 0, digits_found = 0, digit;
 618         for (;;)
 619           {
 620             c = *(*string_ptr)++;
 621
 622             if (c >= '0' && c <= '9')
 623               {
 624                 digit = (unsigned int) (c - '0');
 625               }
 626             else if (c >= 'a' && c <= 'f')
 627               {
 628                 digit = (unsigned int) (c - 'a') + 10;
 629               }
 630             else if (c >= 'A' && c <= 'F')
 631               {
 632                 digit = (unsigned int) (c - 'A') + 10;
 633               }
 634             else
 635               {
 636                 (*string_ptr)--;
 637                 /*@loopbreak@*/ break;
 638               }
 639             overflow |= i ^ (i << 4 >> 4);
 640             i = (i << 4) + digit;
 641             digits_found = 1;
 642           }
 643
 644         if (digits_found == 0)
 645           {
 646             cppReader_errorLit (pfile,
 647                                 cstring_makeLiteralTemp ("\\x used with no following hex digits"));
 648           }
 649
 650         if ((overflow | (i & ~((1 << int_toNonNegative (BITS_PER_UNIT)) - 1))) != 0)
 651           {
 652             i &= (1 << BITS_PER_UNIT) - 1;
 653             cppReader_pedwarnLit (pfile,
 654                             cstring_makeLiteralTemp ("hex character constant does not fit in a byte"));
 655           }
 656
 657         return i;
 658       }
 659     default:
 660       return c;
 661     }
 662 }
 663
 664 static void
 665 integer_overflow (cppReader *pfile)
 666 {
 667   if (cppReader_isPedantic (pfile))
 668     cppReader_pedwarnLit (pfile,
 669                     cstring_makeLiteralTemp ("integer overflow in preprocessor expression"));
 670 }
 671
 672 static long
 673 left_shift (cppReader *pfile, long a, bool unsignedp, unsigned long b)
 674 {
 675   if (b >= HOST_BITS_PER_LONG)
 676     {
 677       if (!unsignedp && a != 0)
 678         {
 679           integer_overflow (pfile);
 680         }
 681
 682       return 0;
 683     }
 684   else if (unsignedp)
 685     {
 686       return (unsigned long) a << b;
 687     }
 688   else
 689     {
 690       /*@-shiftimplementation@*/
 691       long l = a << b; /* int_toNonNegative removed (allow shifts of negative values) */
 692
 693       if (l >> b != a) /* int_toNonNegative removed (allow shifts of negative values) */
 694         {
 695           integer_overflow (pfile);
 696         }
 697
 698       return l;
 699     }
 700 }
 701
 702 static long
 703 right_shift (long a, bool unsignedp, unsigned long b)
 704 {
 705   if (b >= HOST_BITS_PER_LONG)
 706     return (unsignedp ? 0 : int_toNonNegative (a) >> (HOST_BITS_PER_LONG - 1));
 707   else if (unsignedp)
 708     return (unsigned long) a >> b;
 709   else
 710     return a >> b; /* int_toNonNegative removed (allow shifts of negative values) */
 711   /*@=shiftimplementation@*/
 712 }
 713
 714 /* These priorities are all even, so we can handle associatively.  */
 715
 716 /*@constant int PAREN_INNER_PRIO@*/
 717 #define PAREN_INNER_PRIO 0
 718
 719 /*@constant int COMMA_PRIO@*/
 720 #define COMMA_PRIO 4
 721
 722 /*@constant int COND_PRIO@*/
 723 #define COND_PRIO (COMMA_PRIO+2)
 724
 725 /*@constant int OROR_PRIO@*/
 726 #define OROR_PRIO (COND_PRIO+2)
 727
 728 /*@constant int ANDAND_PRIO@*/
 729 #define ANDAND_PRIO (OROR_PRIO+2)
 730
 731 /*@constant int OR_PRIO@*/
 732 #define OR_PRIO (ANDAND_PRIO+2)
 733
 734 /*@constant int XOR_PRIO@*/
 735 #define XOR_PRIO (OR_PRIO+2)
 736
 737 /*@constant int AND_PRIO@*/
 738 #define AND_PRIO (XOR_PRIO+2)
 739
 740 /*@constant int CPP_EQUAL_PRIO@*/
 741 #define CPP_EQUAL_PRIO (AND_PRIO+2)
 742
 743 /*@constant int LESS_PRIO@*/
 744 #define LESS_PRIO (CPP_EQUAL_PRIO+2)
 745
 746 /*@constant int SHIFT_PRIO@*/
 747 #define SHIFT_PRIO (LESS_PRIO+2)
 748
 749 /*@constant int PLUS_PRIO@*/
 750 #define PLUS_PRIO (SHIFT_PRIO+2)
 751
 752 /*@constant int MUL_PRIO@*/
 753 #define MUL_PRIO (PLUS_PRIO+2)
 754
 755 /*@constant int UNARY_PRIO@*/
 756 #define UNARY_PRIO (MUL_PRIO+2)
 757
 758 /*@constant int PAREN_OUTER_PRIO@*/
 759 #define PAREN_OUTER_PRIO (UNARY_PRIO+2)
 760
 761 /*@notfunction@*/
 762 #define COMPARE(OP) \
 763   top->unsignedp = FALSE;\
 764   top->value = ((unsigned1 || unsigned2) \
 765                  ? (unsigned long) v1 OP (unsigned long) v2 \
 766                  : ((long) v1 OP (long) v2)) ? 1 : 0
 767
 768 /* Parse and evaluate a C expression, reading from PFILE.
 769    Returns the value of the expression.  */
 770
 771 /*@constant int INIT_STACK_SIZE@*/
 772 # define INIT_STACK_SIZE 20
 773
 774 HOST_WIDE_INT
 775 cppReader_parseExpression (cppReader *pfile)
 776 {
 777   /* The implementation is an operator precedence parser,
 778      i.e. a bottom-up parser, using a stack for not-yet-reduced tokens.
 779
 780      The stack base is 'stack', and the current stack pointer is 'top'.
 781      There is a stack element for each operator (only),
 782      and the most recently pushed operator is 'top->op'.
 783      An operand (value) is stored in the 'value' field of the stack
 784      element of the operator that precedes it.
 785      In that case the 'flags' field has the HAVE_VALUE flag set.  */
 786
 787   struct operation init_stack[INIT_STACK_SIZE];
 788   struct operation *stack = init_stack;
 789   struct operation *limit = stack + INIT_STACK_SIZE;
 790   register struct operation *top = stack;
 791   int lprio, rprio = 0;
 792   int skip_evaluation = 0;
 793
 794   top->rprio = 0;
 795   top->flags = 0;
 796
 797   for (;;)
 798     {
 799       struct operation op;
 800       int flags = 0;
 801
 802       /* Read a token */
 803       op = cppexp_lex (pfile);
 804
 805       /* See if the token is an operand, in which case go to set_value.
 806          If the token is an operator, figure out its left and right
 807          priorities, and then goto maybe_reduce.  */
 808
 809       switch (op.op)
 810         {
 811         case NAME:
 812           top->value = 0;
 813           top->unsignedp = FALSE;
 814           goto set_value;
 815         case CPPEXP_INT:
 816         case CPPEXP_CHAR:
 817           top->value = op.value;
 818           top->unsignedp = op.unsignedp;
 819           goto set_value;
 820         case 0:
 821           lprio = 0;  goto maybe_reduce;
 822         case '+':  case '-':
 823           /* Is this correct if unary ? FIXME */
 824           flags = RIGHT_OPERAND_REQUIRED;
 825           lprio = PLUS_PRIO;  rprio = lprio + 1;  goto maybe_reduce;
 826         case '!':  case '~':
 827           flags = RIGHT_OPERAND_REQUIRED;
 828           rprio = UNARY_PRIO;  lprio = rprio + 1;  goto maybe_reduce;
 829         case '*':  case '/':  case '%':
 830           lprio = MUL_PRIO;  goto binop;
 831         case '<':  case '>':  case LEQ:  case GEQ:
 832           lprio = LESS_PRIO;  goto binop;
 833         case CPP_EQUALTOK:  case NOTEQUAL:
 834           lprio = CPP_EQUAL_PRIO;  goto binop;
 835         case LSH:  case RSH:
 836           lprio = SHIFT_PRIO;  goto binop;
 837         case '&':  lprio = AND_PRIO;  goto binop;
 838         case '^':  lprio = XOR_PRIO;  goto binop;
 839         case '|':  lprio = OR_PRIO;  goto binop;
 840         case ANDAND:  lprio = ANDAND_PRIO;  goto binop;
 841         case OROR:  lprio = OROR_PRIO;  goto binop;
 842         case ',':
 843           lprio = COMMA_PRIO;  goto binop;
 844         case '(':
 845           lprio = PAREN_OUTER_PRIO;  rprio = PAREN_INNER_PRIO;
 846           goto maybe_reduce;
 847         case ')':
 848           lprio = PAREN_INNER_PRIO;  rprio = PAREN_OUTER_PRIO;
 849           goto maybe_reduce;
 850         case ':':
 851           lprio = COND_PRIO;  rprio = COND_PRIO;
 852           goto maybe_reduce;
 853         case '?':
 854           lprio = COND_PRIO + 1;  rprio = COND_PRIO;
 855           goto maybe_reduce;
 856         binop:
 857           flags = LEFT_OPERAND_REQUIRED | RIGHT_OPERAND_REQUIRED;
 858           rprio = lprio + 1;
 859           goto maybe_reduce;
 860         default:
 861           cppReader_error
 862             (pfile,
 863              message ("Invalid character in #if: %c",
 864                       (char) op.op));
 865           goto syntax_error;
 866         }
 867
 868     set_value:
 869       /* Push a value onto the stack.  */
 870       if ((top->flags & HAVE_VALUE) != 0)
 871         {
 872           cppReader_errorLit (pfile,
 873                               cstring_makeLiteralTemp ("syntax error in #if"));
 874           goto syntax_error;
 875         }
 876       top->flags |= HAVE_VALUE;
 877       continue;
 878
 879     maybe_reduce:
 880       /* Push an operator, and check if we can reduce now.  */
 881       while (top->rprio > lprio)
 882         {
 883           /*@-usedef@*/
 884           HOST_WIDE_INT v1 = top[-1].value;
 885           HOST_WIDE_INT v2 = top[0].value;
 886           bool unsigned1 = top[-1].unsignedp;
 887           bool unsigned2 = top[0].unsignedp;
 888
 889           top--;
 890
 891           if (((top[1].flags & LEFT_OPERAND_REQUIRED) != 0)
 892               && ((top[0].flags & HAVE_VALUE) == 0))
 893             {
 894               cppReader_errorLit (pfile,
 895                                   cstring_makeLiteralTemp ("syntax error - missing left operand"));
 896               goto syntax_error;
 897             }
 898           if (((top[1].flags & RIGHT_OPERAND_REQUIRED) != 0)
 899               && ((top[1].flags & HAVE_VALUE) == 0))
 900             {
 901               cppReader_errorLit (pfile,
 902                                   cstring_makeLiteralTemp ("syntax error - missing right operand"));
 903               goto syntax_error;
 904             }
 905           /* top[0].value = (top[1].op)(v1, v2);*/
 906           switch (top[1].op)
 907             {
 908             case '+':
 909               if ((top->flags & HAVE_VALUE) == 0)
 910                 { /* Unary '+' */
 911                   top->value = v2;
 912                   top->unsignedp = unsigned2;
 913                   top->flags |= HAVE_VALUE;
 914                 }
 915               else
 916                 {
 917                   top->value = v1 + v2;
 918                   top->unsignedp = unsigned1 || unsigned2;
 919                   if (!top->unsignedp && (skip_evaluation == 0)
 920                       && ! possibleSumSign (v1, v2, top->value))
 921                     integer_overflow (pfile);
 922                 }
 923               /*@switchbreak@*/ break;
 924             case '-':
 925               if ((top->flags & HAVE_VALUE) == 0)
 926                 { /* Unary '-' */
 927                   top->value = - v2;
 928                   if ((skip_evaluation == 0)
 929                       && (top->value & v2) < 0 && !unsigned2)
 930                     integer_overflow (pfile);
 931                   top->unsignedp = unsigned2;
 932                   top->flags |= HAVE_VALUE;
 933                 }
 934               else
 935                 { /* Binary '-' */
 936                   top->value = v1 - v2;
 937                   top->unsignedp = unsigned1 || unsigned2;
 938                   if (!top->unsignedp && (skip_evaluation == 0)
 939                       && !possibleSumSign (top->value, v2, v1))
 940                     {
 941                       integer_overflow (pfile);
 942                     }
 943                 }
 944               /*@switchbreak@*/ break;
 945             case '*':
 946               top->unsignedp = unsigned1 || unsigned2;
 947
 948               if (top->unsignedp)
 949                 {
 950                   top->value = (unsigned long) v1 * v2;
 951                 }
 952               else if (skip_evaluation == 0)
 953                 {
 954                   top->value = v1 * v2;
 955                   if ((v1 != 0)
 956                       && (top->value / v1 != v2
 957                           || (top->value & v1 & v2) < 0))
 958                     {
 959                       integer_overflow (pfile);
 960                     }
 961                 }
 962               else
 963                 {
 964                   ;
 965                 }
 966
 967               /*@switchbreak@*/ break;
 968             case '/':
 969               if (skip_evaluation != 0)
 970                 /*@switchbreak@*/ break;
 971               if (v2 == 0)
 972                 {
 973                   cppReader_errorLit (pfile,
 974                                       cstring_makeLiteralTemp ("Division by zero in #if"));
 975                   v2 = 1;
 976                 }
 977               top->unsignedp = unsigned1 || unsigned2;
 978               if (top->unsignedp)
 979                 top->value = (unsigned long) v1 / v2;
 980               else
 981                 {
 982                   top->value = v1 / v2;
 983                   if ((top->value & v1 & v2) < 0)
 984                     integer_overflow (pfile);
 985                 }
 986               /*@switchbreak@*/ break;
 987             case '%':
 988               if (skip_evaluation != 0)
 989                 /*@switchbreak@*/ break;
 990               if (v2 == 0)
 991                 {
 992                   cppReader_errorLit (pfile,
 993                                       cstring_makeLiteralTemp ("Division by zero in #if"));
 994                   v2 = 1;
 995                 }
 996               top->unsignedp = unsigned1 || unsigned2;
 997               if (top->unsignedp)
 998                 top->value = (unsigned long) v1 % v2;
 999               else
1000                 top->value = v1 % v2;
1001               /*@switchbreak@*/ break;
1002             case '!':
1003               if ((top->flags & HAVE_VALUE) != 0)
1004                 {
1005                   cppReader_errorLit (pfile,
1006                                       cstring_makeLiteralTemp ("Syntax error"));
1007                   goto syntax_error;
1008                 }
1009
1010               top->value = (v2 == 0) ? 1 : 0;
1011               top->unsignedp = FALSE;
1012               top->flags |= HAVE_VALUE;
1013               /*@switchbreak@*/ break;
1014             case '~':
1015               if ((top->flags & HAVE_VALUE) != 0)
1016                 {
1017                   cppReader_errorLit (pfile,
1018                                       cstring_makeLiteralTemp ("syntax error"));
1019                   goto syntax_error;
1020                 }
1021               top->value = ~ v2;
1022               top->unsignedp = unsigned2;
1023               top->flags |= HAVE_VALUE;
1024               /*@switchbreak@*/ break;
1025             case '<':  COMPARE(<);  /*@switchbreak@*/ break;
1026             case '>':  COMPARE(>);  /*@switchbreak@*/ break;
1027             case LEQ:  COMPARE(<=); /*@switchbreak@*/ break;
1028             case GEQ:  COMPARE(>=); /*@switchbreak@*/ break;
1029             case CPP_EQUALTOK:
1030               top->value = (v1 == v2) ? 1 : 0;
1031               top->unsignedp = FALSE;
1032               /*@switchbreak@*/ break;
1033             case NOTEQUAL:
1034               top->value = (v1 != v2) ? 1 : 0;
1035               top->unsignedp = FALSE;
1036               /*@switchbreak@*/ break;
1037             case LSH:
1038               if (skip_evaluation != 0)
1039                 {
1040                   /*@switchbreak@*/ break;
1041                 }
1042
1043               top->unsignedp = unsigned1;
1044               if (v2 < 0 && ! unsigned2)
1045                 top->value = right_shift (v1, unsigned1, -v2);
1046               else
1047                 top->value = left_shift (pfile, v1, unsigned1, v2);
1048               /*@switchbreak@*/ break;
1049             case RSH:
1050               if (skip_evaluation != 0)
1051                 {
1052                   /*@switchbreak@*/ break;
1053                 }
1054               top->unsignedp = unsigned1;
1055               if (v2 < 0 && ! unsigned2)
1056                 top->value = left_shift (pfile, v1, unsigned1, -v2);
1057               else
1058                 top->value = right_shift (v1, unsigned1, v2);
1059               /*@switchbreak@*/ break;
1060
1061 /*@notfunction@*/
1062 #define LOGICAL(OP) \
1063               top->value = v1 OP v2;\
1064               top->unsignedp = unsigned1 || unsigned2;
1065
1066             case '&':  LOGICAL(&); /*@switchbreak@*/ break;
1067             case '^':  LOGICAL(^); /*@switchbreak@*/ break;
1068             case '|':  LOGICAL(|); /*@switchbreak@*/ break;
1069             case ANDAND:
1070               top->value = ((v1 != 0) && (v2 != 0)) ? 1 : 0;
1071               top->unsignedp = FALSE;
1072
1073               if (v1 == 0)
1074                 {
1075                   skip_evaluation--;
1076                 }
1077               /*@switchbreak@*/ break;
1078             case OROR:
1079               top->value = ((v1 != 0) || (v2 != 0)) ? 1 : 0;
1080               top->unsignedp = FALSE;
1081               if (v1 != 0)
1082                 {
1083                   skip_evaluation--;
1084                 }
1085               /*@switchbreak@*/ break;
1086             case ',':
1087               if (cppReader_isPedantic (pfile))
1088                 cppReader_pedwarnLit (pfile,
1089                                 cstring_makeLiteralTemp ("comma operator in operand of `#if'"));
1090               top->value = v2;
1091               top->unsignedp = unsigned2;
1092               /*@switchbreak@*/ break;
1093             case '(':  case '?':
1094               cppReader_errorLit (pfile,
1095                                   cstring_makeLiteralTemp ("syntax error in #if"));
1096               goto syntax_error;
1097             case ':':
1098               if (top[0].op != '?')
1099                 {
1100                   cppReader_errorLit (pfile,
1101                                       cstring_makeLiteralTemp ("syntax error ':' without preceding '?'"));
1102                   goto syntax_error;
1103                 }
1104               else if (((top[1].flags & HAVE_VALUE) == 0)
1105                        || ((top[-1].flags & HAVE_VALUE) == 0)
1106                        || ((top[0].flags & HAVE_VALUE) == 0))
1107                 {
1108                   cppReader_errorLit (pfile,
1109                                       cstring_makeLiteralTemp ("bad syntax for ?: operator"));
1110                   goto syntax_error;
1111                 }
1112               else
1113                 {
1114                   top--;
1115                   if (top->value != 0)
1116                     {
1117                       skip_evaluation--;
1118                     }
1119
1120                   top->value = (top->value != 0) ? v1 : v2;
1121                   top->unsignedp = unsigned1 || unsigned2;
1122                 }
1123               /*@switchbreak@*/ break;
1124             case ')':
1125               if (((top[1].flags & HAVE_VALUE) != 0)
1126                   || ((top[0].flags & HAVE_VALUE) == 0)
1127                   || top[0].op != '('
1128                   || ((top[-1].flags & HAVE_VALUE) != 0))
1129                 {
1130                   cppReader_errorLit (pfile,
1131                                       cstring_makeLiteralTemp ("mismatched parentheses in #if"));
1132                   goto syntax_error;
1133                 }
1134               else
1135                 {
1136                   top--;
1137                   top->value = v1;
1138                   top->unsignedp = unsigned1;
1139                   top->flags |= HAVE_VALUE;
1140                 }
1141               /*@switchbreak@*/ break;
1142             default:
1143               /*@-formatconst@*/
1144               fprintf (stderr,
1145                        top[1].op >= ' ' && top[1].op <= '~'
1146                        ? "unimplemented operator '%c'\n"
1147                        : "unimplemented operator '\\%03o'\n",
1148                        top[1].op);
1149               /*@=formatconst@*/
1150             }
1151         }
1152       if (op.op == 0)
1153         {
1154           long val;
1155
1156           if (top != stack)
1157             {
1158               cppReader_errorLit (pfile,
1159                                   cstring_makeLiteralTemp ("internal error in #if expression"));
1160             }
1161
1162           val = top->value;
1163
1164           if (stack != init_stack)
1165             {
1166               sfree (stack);
1167               /*@-branchstate@*/
1168             } /*@=branchstate@*/
1169
1170           return val;
1171         }
1172       top++;
1173
1174       /* Check for and handle stack overflow.  */
1175       if (top == limit)
1176         {
1177           struct operation *new_stack;
1178           size_t old_size = size_fromInt ((char *) limit - (char *) stack);
1179           size_t new_size = (size_t) (2 * old_size);
1180
1181           if (stack != init_stack)
1182             {
1183               new_stack = (struct operation *) drealloc ((char *) stack,
1184                                                          new_size);
1185             }
1186           else
1187             {
1188               new_stack = (struct operation *) dmalloc (new_size);
1189
1190               /* Bug: the parameters were in the wrong order! */
1191               memcpy ((char *) new_stack, (char *) stack, old_size);
1192               /*@-branchstate@*/
1193             } /*@=branchstate@*/
1194
1195           stack = new_stack;
1196           top = (struct operation *) ((char *) new_stack + old_size);
1197           limit = (struct operation *) ((char *) new_stack + new_size);
1198           /*@-branchstate@*/
1199         } /*@=branchstate@*/
1200
1201       top->flags = flags;
1202       top->rprio = rprio;
1203       top->op = op.op;
1204       if ((op.op == OROR && (top[-1].value != 0))
1205           || (op.op == ANDAND && (top[-1].value == 0))
1206           || (op.op == '?' && (top[-1].value == 0)))
1207         {
1208           skip_evaluation++;
1209         }
1210       else if (op.op == ':')
1211         {
1212           if (top[-2].value != 0) /* Was condition true? */
1213             {
1214               skip_evaluation++;
1215             }
1216           else
1217             {
1218               skip_evaluation--;
1219             }
1220         }
1221       else
1222         {
1223           ;
1224         }
1225     }
1226  syntax_error:
1227   /*@-usereleased@*/
1228   if (stack != init_stack)
1229     {
1230       sfree (stack);
1231       /*@-branchstate@*/
1232     } /*@=branchstate@*/
1233   /*@=usereleased@*/
1234
1235   cppReader_skipRestOfLine (pfile);
1236   return 0;
1237 }