gcc/cppexp.c

   1 /* Parse C expressions for cpplib.
   2    Copyright (C) 1987, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2001,
   3    2002 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 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "cpplib.h"
  26 #include "cpphash.h"
  27
  28 #define PART_PRECISION (sizeof (cpp_num_part) * CHAR_BIT)
  29 #define HALF_MASK (~(cpp_num_part) 0 >> (PART_PRECISION / 2))
  30 #define LOW_PART(num_part) (num_part & HALF_MASK)
  31 #define HIGH_PART(num_part) (num_part >> (PART_PRECISION / 2))
  32
  33 struct op
  34 {
  35   const cpp_token *token;       /* The token forming op (for diagnostics).  */
  36   cpp_num value;                /* The value logically "right" of op.  */
  37   enum cpp_ttype op;
  38 };
  39
  40 /* Some simple utility routines on double integers.  */
  41 #define num_zerop(num) ((num.low | num.high) == 0)
  42 #define num_eq(num1, num2) (num1.low == num2.low && num1.high == num2.high)
  43 static bool num_positive PARAMS ((cpp_num, size_t));
  44 static bool num_greater_eq PARAMS ((cpp_num, cpp_num, size_t));
  45 static cpp_num num_trim PARAMS ((cpp_num, size_t));
  46 static cpp_num num_part_mul PARAMS ((cpp_num_part, cpp_num_part));
  47
  48 static cpp_num num_unary_op PARAMS ((cpp_reader *, cpp_num, enum cpp_ttype));
  49 static cpp_num num_binary_op PARAMS ((cpp_reader *, cpp_num, cpp_num,
  50                                       enum cpp_ttype));
  51 static cpp_num num_negate PARAMS ((cpp_num, size_t));
  52 static cpp_num num_bitwise_op PARAMS ((cpp_reader *, cpp_num, cpp_num,
  53                                        enum cpp_ttype));
  54 static cpp_num num_inequality_op PARAMS ((cpp_reader *, cpp_num, cpp_num,
  55                                           enum cpp_ttype));
  56 static cpp_num num_equality_op PARAMS ((cpp_reader *, cpp_num, cpp_num,
  57                                         enum cpp_ttype));
  58 static cpp_num num_mul PARAMS ((cpp_reader *, cpp_num, cpp_num));
  59 static cpp_num num_div_op PARAMS ((cpp_reader *, cpp_num, cpp_num,
  60                                    enum cpp_ttype));
  61 static cpp_num num_lshift PARAMS ((cpp_num, size_t, size_t));
  62 static cpp_num num_rshift PARAMS ((cpp_num, size_t, size_t));
  63
  64 static cpp_num append_digit PARAMS ((cpp_num, int, int, size_t));
  65 static cpp_num parse_defined PARAMS ((cpp_reader *));
  66 static cpp_num eval_token PARAMS ((cpp_reader *, const cpp_token *));
  67 static struct op *reduce PARAMS ((cpp_reader *, struct op *, enum cpp_ttype));
  68 static unsigned int interpret_float_suffix PARAMS ((const uchar *, size_t));
  69 static unsigned int interpret_int_suffix PARAMS ((const uchar *, size_t));
  70 static void check_promotion PARAMS ((cpp_reader *, const struct op *));
  71
  72 /* Token type abuse to create unary plus and minus operators.  */
  73 #define CPP_UPLUS (CPP_LAST_CPP_OP + 1)
  74 #define CPP_UMINUS (CPP_LAST_CPP_OP + 2)
  75
  76 /* With -O2, gcc appears to produce nice code, moving the error
  77    message load and subsequent jump completely out of the main path.  */
  78 #define SYNTAX_ERROR(msgid) \
  79   do { cpp_error (pfile, DL_ERROR, msgid); goto syntax_error; } while(0)
  80 #define SYNTAX_ERROR2(msgid, arg) \
  81   do { cpp_error (pfile, DL_ERROR, msgid, arg); goto syntax_error; } while(0)
  82
  83 /* Subroutine of cpp_classify_number.  S points to a float suffix of
  84    length LEN, possibly zero.  Returns 0 for an invalid suffix, or a
  85    flag vector describing the suffix.  */
  86 static unsigned int
  87 interpret_float_suffix (s, len)
  88      const uchar *s;
  89      size_t len;
  90 {
  91   size_t f = 0, l = 0, i = 0;
  92
  93   while (len--)
  94     switch (s[len])
  95       {
  96       case 'f': case 'F': f++; break;
  97       case 'l': case 'L': l++; break;
  98       case 'i': case 'I':
  99       case 'j': case 'J': i++; break;
 100       default:
 101         return 0;
 102       }
 103
 104   if (f + l > 1 || i > 1)
 105     return 0;
 106
 107   return ((i ? CPP_N_IMAGINARY : 0)
 108           | (f ? CPP_N_SMALL :
 109              l ? CPP_N_LARGE : CPP_N_MEDIUM));
 110 }
 111
 112 /* Subroutine of cpp_classify_number.  S points to an integer suffix
 113    of length LEN, possibly zero. Returns 0 for an invalid suffix, or a
 114    flag vector describing the suffix.  */
 115 static unsigned int
 116 interpret_int_suffix (s, len)
 117      const uchar *s;
 118      size_t len;
 119 {
 120   size_t u, l, i;
 121
 122   u = l = i = 0;
 123
 124   while (len--)
 125     switch (s[len])
 126       {
 127       case 'u': case 'U':       u++; break;
 128       case 'i': case 'I':
 129       case 'j': case 'J':       i++; break;
 130       case 'l': case 'L':       l++;
 131         /* If there are two Ls, they must be adjacent and the same case.  */
 132         if (l == 2 && s[len] != s[len + 1])
 133           return 0;
 134         break;
 135       default:
 136         return 0;
 137       }
 138
 139   if (l > 2 || u > 1 || i > 1)
 140     return 0;
 141
 142   return ((i ? CPP_N_IMAGINARY : 0)
 143           | (u ? CPP_N_UNSIGNED : 0)
 144           | ((l == 0) ? CPP_N_SMALL
 145              : (l == 1) ? CPP_N_MEDIUM : CPP_N_LARGE));
 146 }
 147
 148 /* Categorize numeric constants according to their field (integer,
 149    floating point, or invalid), radix (decimal, octal, hexadecimal),
 150    and type suffixes.  */
 151 unsigned int
 152 cpp_classify_number (pfile, token)
 153      cpp_reader *pfile;
 154      const cpp_token *token;
 155 {
 156   const uchar *str = token->val.str.text;
 157   const uchar *limit;
 158   unsigned int max_digit, result, radix;
 159   enum {NOT_FLOAT = 0, AFTER_POINT, AFTER_EXPON} float_flag;
 160
 161   /* If the lexer has done its job, length one can only be a single
 162      digit.  Fast-path this very common case.  */
 163   if (token->val.str.len == 1)
 164     return CPP_N_INTEGER | CPP_N_SMALL | CPP_N_DECIMAL;
 165
 166   limit = str + token->val.str.len;
 167   float_flag = NOT_FLOAT;
 168   max_digit = 0;
 169   radix = 10;
 170
 171   /* First, interpret the radix.  */
 172   if (*str == '0')
 173     {
 174       radix = 8;
 175       str++;
 176
 177       /* Require at least one hex digit to classify it as hex.  */
 178       if ((*str == 'x' || *str == 'X')
 179           && (str[1] == '.' || ISXDIGIT (str[1])))
 180         {
 181           radix = 16;
 182           str++;
 183         }
 184     }
 185
 186   /* Now scan for a well-formed integer or float.  */
 187   for (;;)
 188     {
 189       unsigned int c = *str++;
 190
 191       if (ISDIGIT (c) || (ISXDIGIT (c) && radix == 16))
 192         {
 193           c = hex_value (c);
 194           if (c > max_digit)
 195             max_digit = c;
 196         }
 197       else if (c == '.')
 198         {
 199           if (float_flag == NOT_FLOAT)
 200             float_flag = AFTER_POINT;
 201           else
 202             SYNTAX_ERROR ("too many decimal points in number");
 203         }
 204       else if ((radix <= 10 && (c == 'e' || c == 'E'))
 205                || (radix == 16 && (c == 'p' || c == 'P')))
 206         {
 207           float_flag = AFTER_EXPON;
 208           break;
 209         }
 210       else
 211         {
 212           /* Start of suffix.  */
 213           str--;
 214           break;
 215         }
 216     }
 217
 218   if (float_flag != NOT_FLOAT && radix == 8)
 219     radix = 10;
 220
 221   if (max_digit >= radix)
 222     SYNTAX_ERROR2 ("invalid digit \"%c\" in octal constant", '0' + max_digit);
 223
 224   if (float_flag != NOT_FLOAT)
 225     {
 226       if (radix == 16 && CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, c99))
 227         cpp_error (pfile, DL_PEDWARN,
 228                    "use of C99 hexadecimal floating constant");
 229
 230       if (float_flag == AFTER_EXPON)
 231         {
 232           if (*str == '+' || *str == '-')
 233             str++;
 234
 235           /* Exponent is decimal, even if string is a hex float.  */
 236           if (!ISDIGIT (*str))
 237             SYNTAX_ERROR ("exponent has no digits");
 238
 239           do
 240             str++;
 241           while (ISDIGIT (*str));
 242         }
 243       else if (radix == 16)
 244         SYNTAX_ERROR ("hexadecimal floating constants require an exponent");
 245
 246       result = interpret_float_suffix (str, limit - str);
 247       if (result == 0)
 248         {
 249           cpp_error (pfile, DL_ERROR,
 250                      "invalid suffix \"%.*s\" on floating constant",
 251                      (int) (limit - str), str);
 252           return CPP_N_INVALID;
 253         }
 254
 255       /* Traditional C didn't accept any floating suffixes.  */
 256       if (limit != str
 257           && CPP_WTRADITIONAL (pfile)
 258           && ! cpp_sys_macro_p (pfile))
 259         cpp_error (pfile, DL_WARNING,
 260                    "traditional C rejects the \"%.*s\" suffix",
 261                    (int) (limit - str), str);
 262
 263       result |= CPP_N_FLOATING;
 264     }
 265   else
 266     {
 267       result = interpret_int_suffix (str, limit - str);
 268       if (result == 0)
 269         {
 270           cpp_error (pfile, DL_ERROR,
 271                      "invalid suffix \"%.*s\" on integer constant",
 272                      (int) (limit - str), str);
 273           return CPP_N_INVALID;
 274         }
 275
 276       /* Traditional C only accepted the 'L' suffix.
 277          Suppress warning about 'LL' with -Wno-long-long.  */
 278       if (CPP_WTRADITIONAL (pfile) && ! cpp_sys_macro_p (pfile))
 279         {
 280           int u_or_i = (result & (CPP_N_UNSIGNED|CPP_N_IMAGINARY));
 281           int large = (result & CPP_N_WIDTH) == CPP_N_LARGE;
 282
 283           if (u_or_i || (large && CPP_OPTION (pfile, warn_long_long)))
 284             cpp_error (pfile, DL_WARNING,
 285                        "traditional C rejects the \"%.*s\" suffix",
 286                        (int) (limit - str), str);
 287         }
 288
 289       if ((result & CPP_N_WIDTH) == CPP_N_LARGE
 290           && ! CPP_OPTION (pfile, c99)
 291           && CPP_OPTION (pfile, warn_long_long))
 292         cpp_error (pfile, DL_PEDWARN, "use of C99 long long integer constant");
 293
 294       result |= CPP_N_INTEGER;
 295     }
 296
 297   if ((result & CPP_N_IMAGINARY) && CPP_PEDANTIC (pfile))
 298     cpp_error (pfile, DL_PEDWARN, "imaginary constants are a GCC extension");
 299
 300   if (radix == 10)
 301     result |= CPP_N_DECIMAL;
 302   else if (radix == 16)
 303     result |= CPP_N_HEX;
 304   else
 305     result |= CPP_N_OCTAL;
 306
 307   return result;
 308
 309  syntax_error:
 310   return CPP_N_INVALID;
 311 }
 312
 313 /* cpp_interpret_integer converts an integer constant into a cpp_num,
 314    of precision options->precision.
 315
 316    We do not provide any interface for decimal->float conversion,
 317    because the preprocessor doesn't need it and the floating point
 318    handling in GCC proper is too ugly to speak of.  */
 319 cpp_num
 320 cpp_interpret_integer (pfile, token, type)
 321      cpp_reader *pfile;
 322      const cpp_token *token;
 323      unsigned int type;
 324 {
 325   const uchar *p, *end;
 326   cpp_num result;
 327
 328   result.low = 0;
 329   result.high = 0;
 330   result.unsignedp = !!(type & CPP_N_UNSIGNED);
 331   result.overflow = false;
 332
 333   p = token->val.str.text;
 334   end = p + token->val.str.len;
 335
 336   /* Common case of a single digit.  */
 337   if (token->val.str.len == 1)
 338     result.low = p[0] - '0';
 339   else
 340     {
 341       cpp_num_part max;
 342       size_t precision = CPP_OPTION (pfile, precision);
 343       unsigned int base = 10, c = 0;
 344       bool overflow = false;
 345
 346       if ((type & CPP_N_RADIX) == CPP_N_OCTAL)
 347         {
 348           base = 8;
 349           p++;
 350         }
 351       else if ((type & CPP_N_RADIX) == CPP_N_HEX)
 352         {
 353           base = 16;
 354           p += 2;
 355         }
 356
 357       /* We can add a digit to numbers strictly less than this without
 358          needing the precision and slowness of double integers.  */
 359       max = ~(cpp_num_part) 0;
 360       if (precision < PART_PRECISION)
 361         max >>= PART_PRECISION - precision;
 362       max = (max - base + 1) / base + 1;
 363
 364       for (; p < end; p++)
 365         {
 366           c = *p;
 367
 368           if (ISDIGIT (c) || (base == 16 && ISXDIGIT (c)))
 369             c = hex_value (c);
 370           else
 371             break;
 372
 373           /* Strict inequality for when max is set to zero.  */
 374           if (result.low < max)
 375             result.low = result.low * base + c;
 376           else
 377             {
 378               result = append_digit (result, c, base, precision);
 379               overflow |= result.overflow;
 380               max = 0;
 381             }
 382         }
 383
 384       if (overflow)
 385         cpp_error (pfile, DL_PEDWARN,
 386                    "integer constant is too large for its type");
 387       /* If too big to be signed, consider it unsigned.  Only warn for
 388          decimal numbers.  Traditional numbers were always signed (but
 389          we still honor an explicit U suffix); but we only have
 390          traditional semantics in directives.  */
 391       else if (!result.unsignedp
 392                && !(CPP_OPTION (pfile, traditional)
 393                     && pfile->state.in_directive)
 394                && !num_positive (result, precision))
 395         {
 396           if (base == 10)
 397             cpp_error (pfile, DL_WARNING,
 398                        "integer constant is so large that it is unsigned");
 399           result.unsignedp = true;
 400         }
 401     }
 402
 403   return result;
 404 }
 405
 406 /* Append DIGIT to NUM, a number of PRECISION bits being read in base
 407    BASE.  */
 408 static cpp_num
 409 append_digit (num, digit, base, precision)
 410      cpp_num num;
 411      int digit, base;
 412      size_t precision;
 413 {
 414   cpp_num result;
 415   unsigned int shift = 3 + (base == 16);
 416   bool overflow;
 417   cpp_num_part add_high, add_low;
 418
 419   /* Multiply by 8 or 16.  Catching this overflow here means we don't
 420      need to worry about add_high overflowing.  */
 421   overflow = !!(num.high >> (PART_PRECISION - shift));
 422   result.high = num.high << shift;
 423   result.low = num.low << shift;
 424   result.high |= num.low >> (PART_PRECISION - shift);
 425
 426   if (base == 10)
 427     {
 428       add_low = num.low << 1;
 429       add_high = (num.high << 1) + (num.low >> (PART_PRECISION - 1));
 430     }
 431   else
 432     add_high = add_low = 0;
 433
 434   if (add_low + digit < add_low)
 435     add_high++;
 436   add_low += digit;
 437
 438   if (result.low + add_low < result.low)
 439     add_high++;
 440   if (result.high + add_high < result.high)
 441     overflow = true;
 442
 443   result.low += add_low;
 444   result.high += add_high;
 445
 446   /* The above code catches overflow of a cpp_num type.  This catches
 447      overflow of the (possibly shorter) target precision.  */
 448   num.low = result.low;
 449   num.high = result.high;
 450   result = num_trim (result, precision);
 451   if (!num_eq (result, num))
 452     overflow = true;
 453
 454   result.unsignedp = num.unsignedp;
 455   result.overflow = overflow;
 456   return result;
 457 }
 458
 459 /* Handle meeting "defined" in a preprocessor expression.  */
 460 static cpp_num
 461 parse_defined (pfile)
 462      cpp_reader *pfile;
 463 {
 464   cpp_num result;
 465   int paren = 0;
 466   cpp_hashnode *node = 0;
 467   const cpp_token *token;
 468   cpp_context *initial_context = pfile->context;
 469
 470   /* Don't expand macros.  */
 471   pfile->state.prevent_expansion++;
 472
 473   token = cpp_get_token (pfile);
 474   if (token->type == CPP_OPEN_PAREN)
 475     {
 476       paren = 1;
 477       token = cpp_get_token (pfile);
 478     }
 479
 480   if (token->type == CPP_NAME)
 481     {
 482       node = token->val.node;
 483       if (paren && cpp_get_token (pfile)->type != CPP_CLOSE_PAREN)
 484         {
 485           cpp_error (pfile, DL_ERROR, "missing ')' after \"defined\"");
 486           node = 0;
 487         }
 488     }
 489   else
 490     {
 491       cpp_error (pfile, DL_ERROR,
 492                  "operator \"defined\" requires an identifier");
 493       if (token->flags & NAMED_OP)
 494         {
 495           cpp_token op;
 496
 497           op.flags = 0;
 498           op.type = token->type;
 499           cpp_error (pfile, DL_ERROR,
 500                      "(\"%s\" is an alternative token for \"%s\" in C++)",
 501                      cpp_token_as_text (pfile, token),
 502                      cpp_token_as_text (pfile, &op));
 503         }
 504     }
 505
 506   if (node)
 507     {
 508       if (pfile->context != initial_context)
 509         cpp_error (pfile, DL_WARNING,
 510                    "this use of \"defined\" may not be portable");
 511
 512       _cpp_mark_macro_used (node);
 513
 514       /* A possible controlling macro of the form #if !defined ().
 515          _cpp_parse_expr checks there was no other junk on the line.  */
 516       pfile->mi_ind_cmacro = node;
 517     }
 518
 519   pfile->state.prevent_expansion--;
 520
 521   result.unsignedp = false;
 522   result.high = 0;
 523   result.overflow = false;
 524   result.low = node && node->type == NT_MACRO;
 525   return result;
 526 }
 527
 528 /* Convert a token into a CPP_NUMBER (an interpreted preprocessing
 529    number or character constant, or the result of the "defined" or "#"
 530    operators).  */
 531 static cpp_num
 532 eval_token (pfile, token)
 533      cpp_reader *pfile;
 534      const cpp_token *token;
 535 {
 536   cpp_num result;
 537   unsigned int temp;
 538   int unsignedp = 0;
 539
 540   switch (token->type)
 541     {
 542     case CPP_NUMBER:
 543       temp = cpp_classify_number (pfile, token);
 544       switch (temp & CPP_N_CATEGORY)
 545         {
 546         case CPP_N_FLOATING:
 547           cpp_error (pfile, DL_ERROR,
 548                      "floating constant in preprocessor expression");
 549           break;
 550         case CPP_N_INTEGER:
 551           if (!(temp & CPP_N_IMAGINARY))
 552             return cpp_interpret_integer (pfile, token, temp);
 553           cpp_error (pfile, DL_ERROR,
 554                      "imaginary number in preprocessor expression");
 555           break;
 556
 557         case CPP_N_INVALID:
 558           /* Error already issued.  */
 559           break;
 560         }
 561       result.high = result.low = 0;
 562       break;
 563
 564     case CPP_WCHAR:
 565     case CPP_CHAR:
 566       {
 567         cppchar_t cc = cpp_interpret_charconst (pfile, token,
 568                                                 &temp, &unsignedp);
 569
 570         result.high = 0;
 571         result.low = cc;
 572         /* Sign-extend the result if necessary.  */
 573         if (!unsignedp && (cppchar_signed_t) cc < 0)
 574           {
 575             if (PART_PRECISION > BITS_PER_CPPCHAR_T)
 576               result.low |= ~(~(cpp_num_part) 0
 577                               >> (PART_PRECISION - BITS_PER_CPPCHAR_T));
 578             result.high = ~(cpp_num_part) 0;
 579             result = num_trim (result, CPP_OPTION (pfile, precision));
 580           }
 581       }
 582       break;
 583
 584     case CPP_NAME:
 585       if (token->val.node == pfile->spec_nodes.n_defined)
 586         return parse_defined (pfile);
 587       else if (CPP_OPTION (pfile, cplusplus)
 588                && (token->val.node == pfile->spec_nodes.n_true
 589                    || token->val.node == pfile->spec_nodes.n_false))
 590         {
 591           result.high = 0;
 592           result.low = (token->val.node == pfile->spec_nodes.n_true);
 593         }
 594       else
 595         {
 596           result.high = 0;
 597           result.low = 0;
 598           if (CPP_OPTION (pfile, warn_undef) && !pfile->state.skip_eval)
 599             cpp_error (pfile, DL_WARNING, "\"%s\" is not defined",
 600                        NODE_NAME (token->val.node));
 601         }
 602       break;
 603
 604     default: /* CPP_HASH */
 605       _cpp_test_assertion (pfile, &temp);
 606       result.high = 0;
 607       result.low = temp;
 608     }
 609
 610   result.unsignedp = !!unsignedp;
 611   result.overflow = false;
 612   return result;
 613 }
 614 \f
 615 /* Operator precedence and flags table.
 616
 617 After an operator is returned from the lexer, if it has priority less
 618 than the operator on the top of the stack, we reduce the stack by one
 619 operator and repeat the test.  Since equal priorities do not reduce,
 620 this is naturally right-associative.
 621
 622 We handle left-associative operators by decrementing the priority of
 623 just-lexed operators by one, but retaining the priority of operators
 624 already on the stack.
 625
 626 The remaining cases are '(' and ')'.  We handle '(' by skipping the
 627 reduction phase completely.  ')' is given lower priority than
 628 everything else, including '(', effectively forcing a reduction of the
 629 parenthesized expression.  If there is a matching '(', the routine
 630 reduce() exits immediately.  If the normal exit route sees a ')', then
 631 there cannot have been a matching '(' and an error message is output.
 632
 633 The parser assumes all shifted operators require a left operand unless
 634 the flag NO_L_OPERAND is set.  These semantics are automatic; any
 635 extra semantics need to be handled with operator-specific code.  */
 636
 637 /* Flags.  If CHECK_PROMOTION, we warn if the effective sign of an
 638    operand changes because of integer promotions.  */
 639 #define NO_L_OPERAND    (1 << 0)
 640 #define LEFT_ASSOC      (1 << 1)
 641 #define CHECK_PROMOTION (1 << 2)
 642
 643 /* Operator to priority map.  Must be in the same order as the first
 644    N entries of enum cpp_ttype.  */
 645 static const struct operator
 646 {
 647   uchar prio;
 648   uchar flags;
 649 } optab[] =
 650 {
 651   /* EQ */              {0, 0}, /* Shouldn't happen.  */
 652   /* NOT */             {16, NO_L_OPERAND},
 653   /* GREATER */         {12, LEFT_ASSOC | CHECK_PROMOTION},
 654   /* LESS */            {12, LEFT_ASSOC | CHECK_PROMOTION},
 655   /* PLUS */            {14, LEFT_ASSOC | CHECK_PROMOTION},
 656   /* MINUS */           {14, LEFT_ASSOC | CHECK_PROMOTION},
 657   /* MULT */            {15, LEFT_ASSOC | CHECK_PROMOTION},
 658   /* DIV */             {15, LEFT_ASSOC | CHECK_PROMOTION},
 659   /* MOD */             {15, LEFT_ASSOC | CHECK_PROMOTION},
 660   /* AND */             {9, LEFT_ASSOC | CHECK_PROMOTION},
 661   /* OR */              {7, LEFT_ASSOC | CHECK_PROMOTION},
 662   /* XOR */             {8, LEFT_ASSOC | CHECK_PROMOTION},
 663   /* RSHIFT */          {13, LEFT_ASSOC},
 664   /* LSHIFT */          {13, LEFT_ASSOC},
 665
 666   /* MIN */             {10, LEFT_ASSOC | CHECK_PROMOTION},
 667   /* MAX */             {10, LEFT_ASSOC | CHECK_PROMOTION},
 668
 669   /* COMPL */           {16, NO_L_OPERAND},
 670   /* AND_AND */         {6, LEFT_ASSOC},
 671   /* OR_OR */           {5, LEFT_ASSOC},
 672   /* QUERY */           {3, 0},
 673   /* COLON */           {4, LEFT_ASSOC | CHECK_PROMOTION},
 674   /* COMMA */           {2, LEFT_ASSOC},
 675   /* OPEN_PAREN */      {1, NO_L_OPERAND},
 676   /* CLOSE_PAREN */     {0, 0},
 677   /* EOF */             {0, 0},
 678   /* EQ_EQ */           {11, LEFT_ASSOC},
 679   /* NOT_EQ */          {11, LEFT_ASSOC},
 680   /* GREATER_EQ */      {12, LEFT_ASSOC | CHECK_PROMOTION},
 681   /* LESS_EQ */         {12, LEFT_ASSOC | CHECK_PROMOTION},
 682   /* UPLUS */           {16, NO_L_OPERAND},
 683   /* UMINUS */          {16, NO_L_OPERAND}
 684 };
 685
 686 /* Parse and evaluate a C expression, reading from PFILE.
 687    Returns the truth value of the expression.
 688
 689    The implementation is an operator precedence parser, i.e. a
 690    bottom-up parser, using a stack for not-yet-reduced tokens.
 691
 692    The stack base is op_stack, and the current stack pointer is 'top'.
 693    There is a stack element for each operator (only), and the most
 694    recently pushed operator is 'top->op'.  An operand (value) is
 695    stored in the 'value' field of the stack element of the operator
 696    that precedes it.  */
 697 bool
 698 _cpp_parse_expr (pfile)
 699      cpp_reader *pfile;
 700 {
 701   struct op *top = pfile->op_stack;
 702   unsigned int lex_count;
 703   bool saw_leading_not, want_value = true;
 704
 705   pfile->state.skip_eval = 0;
 706
 707   /* Set up detection of #if ! defined().  */
 708   pfile->mi_ind_cmacro = 0;
 709   saw_leading_not = false;
 710   lex_count = 0;
 711
 712   /* Lowest priority operator prevents further reductions.  */
 713   top->op = CPP_EOF;
 714
 715   for (;;)
 716     {
 717       struct op op;
 718
 719       lex_count++;
 720       op.token = cpp_get_token (pfile);
 721       op.op = op.token->type;
 722
 723       switch (op.op)
 724         {
 725           /* These tokens convert into values.  */
 726         case CPP_NUMBER:
 727         case CPP_CHAR:
 728         case CPP_WCHAR:
 729         case CPP_NAME:
 730         case CPP_HASH:
 731           if (!want_value)
 732             SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
 733                            cpp_token_as_text (pfile, op.token));
 734           want_value = false;
 735           top->value = eval_token (pfile, op.token);
 736           continue;
 737
 738         case CPP_NOT:
 739           saw_leading_not = lex_count == 1;
 740           break;
 741         case CPP_PLUS:
 742           if (want_value)
 743             op.op = CPP_UPLUS;
 744           break;
 745         case CPP_MINUS:
 746           if (want_value)
 747             op.op = CPP_UMINUS;
 748           break;
 749         case CPP_OTHER:
 750           if (ISGRAPH (op.token->val.c))
 751             SYNTAX_ERROR2 ("invalid character '%c' in #if", op.token->val.c);
 752           else
 753             SYNTAX_ERROR2 ("invalid character '\\%03o' in #if",
 754                            op.token->val.c);
 755
 756         default:
 757           if ((int) op.op <= (int) CPP_EQ || (int) op.op >= (int) CPP_PLUS_EQ)
 758             SYNTAX_ERROR2 ("token \"%s\" is not valid in preprocessor expressions",
 759                            cpp_token_as_text (pfile, op.token));
 760           break;
 761         }
 762
 763       /* Check we have a value or operator as appropriate.  */
 764       if (optab[op.op].flags & NO_L_OPERAND)
 765         {
 766           if (!want_value)
 767             SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
 768                            cpp_token_as_text (pfile, op.token));
 769         }
 770       else if (want_value)
 771         {
 772           /* Ordering here is subtle and intended to favor the
 773              missing parenthesis diagnostics over alternatives.  */
 774           if (op.op == CPP_CLOSE_PAREN)
 775             {
 776               if (top->op == CPP_OPEN_PAREN)
 777                 SYNTAX_ERROR ("void expression between '(' and ')'");
 778             }
 779           else if (top->op == CPP_EOF)
 780             SYNTAX_ERROR ("#if with no expression");
 781           if (top->op != CPP_EOF && top->op != CPP_OPEN_PAREN)
 782             SYNTAX_ERROR2 ("operator '%s' has no right operand",
 783                            cpp_token_as_text (pfile, top->token));
 784         }
 785
 786       top = reduce (pfile, top, op.op);
 787       if (!top)
 788         goto syntax_error;
 789
 790       if (op.op == CPP_EOF)
 791         break;
 792
 793       switch (op.op)
 794         {
 795         case CPP_CLOSE_PAREN:
 796           continue;
 797         case CPP_OR_OR:
 798           if (!num_zerop (top->value))
 799             pfile->state.skip_eval++;
 800           break;
 801         case CPP_AND_AND:
 802         case CPP_QUERY:
 803           if (num_zerop (top->value))
 804             pfile->state.skip_eval++;
 805           break;
 806         case CPP_COLON:
 807           if (top->op != CPP_QUERY)
 808             SYNTAX_ERROR (" ':' without preceding '?'");
 809           if (!num_zerop (top[-1].value)) /* Was '?' condition true?  */
 810             pfile->state.skip_eval++;
 811           else
 812             pfile->state.skip_eval--;
 813         default:
 814           break;
 815         }
 816
 817       want_value = true;
 818
 819       /* Check for and handle stack overflow.  */
 820       if (++top == pfile->op_limit)
 821         top = _cpp_expand_op_stack (pfile);
 822
 823       top->op = op.op;
 824       top->token = op.token;
 825     }
 826
 827   /* The controlling macro expression is only valid if we called lex 3
 828      times: <!> <defined expression> and <EOF>.  push_conditional ()
 829      checks that we are at top-of-file.  */
 830   if (pfile->mi_ind_cmacro && !(saw_leading_not && lex_count == 3))
 831     pfile->mi_ind_cmacro = 0;
 832
 833   if (top != pfile->op_stack)
 834     {
 835       cpp_error (pfile, DL_ICE, "unbalanced stack in #if");
 836     syntax_error:
 837       return false;  /* Return false on syntax error.  */
 838     }
 839
 840   return !num_zerop (top->value);
 841 }
 842
 843 /* Reduce the operator / value stack if possible, in preparation for
 844    pushing operator OP.  Returns NULL on error, otherwise the top of
 845    the stack.  */
 846 static struct op *
 847 reduce (pfile, top, op)
 848      cpp_reader *pfile;
 849      struct op *top;
 850      enum cpp_ttype op;
 851 {
 852   unsigned int prio;
 853
 854   if (top->op <= CPP_EQ || top->op > CPP_LAST_CPP_OP + 2)
 855     {
 856     bad_op:
 857       cpp_error (pfile, DL_ICE, "impossible operator '%u'", top->op);
 858       return 0;
 859     }
 860
 861   if (op == CPP_OPEN_PAREN)
 862     return top;
 863
 864   /* Decrement the priority of left-associative operators to force a
 865      reduction with operators of otherwise equal priority.  */
 866   prio = optab[op].prio - ((optab[op].flags & LEFT_ASSOC) != 0);
 867   while (prio < optab[top->op].prio)
 868     {
 869       if (CPP_OPTION (pfile, warn_num_sign_change)
 870           && optab[top->op].flags & CHECK_PROMOTION)
 871         check_promotion (pfile, top);
 872
 873       switch (top->op)
 874         {
 875         case CPP_UPLUS:
 876         case CPP_UMINUS:
 877         case CPP_NOT:
 878         case CPP_COMPL:
 879           top[-1].value = num_unary_op (pfile, top->value, top->op);
 880           break;
 881
 882         case CPP_PLUS:
 883         case CPP_MINUS:
 884         case CPP_RSHIFT:
 885         case CPP_LSHIFT:
 886         case CPP_MIN:
 887         case CPP_MAX:
 888         case CPP_COMMA:
 889           top[-1].value = num_binary_op (pfile, top[-1].value,
 890                                          top->value, top->op);
 891           break;
 892
 893         case CPP_GREATER:
 894         case CPP_LESS:
 895         case CPP_GREATER_EQ:
 896         case CPP_LESS_EQ:
 897           top[-1].value
 898             = num_inequality_op (pfile, top[-1].value, top->value, top->op);
 899           break;
 900
 901         case CPP_EQ_EQ:
 902         case CPP_NOT_EQ:
 903           top[-1].value
 904             = num_equality_op (pfile, top[-1].value, top->value, top->op);
 905           break;
 906
 907         case CPP_AND:
 908         case CPP_OR:
 909         case CPP_XOR:
 910           top[-1].value
 911             = num_bitwise_op (pfile, top[-1].value, top->value, top->op);
 912           break;
 913
 914         case CPP_MULT:
 915           top[-1].value = num_mul (pfile, top[-1].value, top->value);
 916           break;
 917
 918         case CPP_DIV:
 919         case CPP_MOD:
 920           top[-1].value = num_div_op (pfile, top[-1].value,
 921                                       top->value, top->op);
 922           break;
 923
 924         case CPP_OR_OR:
 925           top--;
 926           if (!num_zerop (top->value))
 927             pfile->state.skip_eval--;
 928           top->value.low = (!num_zerop (top->value)
 929                             || !num_zerop (top[1].value));
 930           top->value.high = 0;
 931           top->value.unsignedp = false;
 932           top->value.overflow = false;
 933           continue;
 934
 935         case CPP_AND_AND:
 936           top--;
 937           if (num_zerop (top->value))
 938             pfile->state.skip_eval--;
 939           top->value.low = (!num_zerop (top->value)
 940                             && !num_zerop (top[1].value));
 941           top->value.high = 0;
 942           top->value.unsignedp = false;
 943           top->value.overflow = false;
 944           continue;
 945
 946         case CPP_OPEN_PAREN:
 947           if (op != CPP_CLOSE_PAREN)
 948             {
 949               cpp_error (pfile, DL_ERROR, "missing ')' in expression");
 950               return 0;
 951             }
 952           top--;
 953           top->value = top[1].value;
 954           return top;
 955
 956         case CPP_COLON:
 957           top -= 2;
 958           if (!num_zerop (top->value))
 959             {
 960               pfile->state.skip_eval--;
 961               top->value = top[1].value;
 962             }
 963           else
 964             top->value = top[2].value;
 965           top->value.unsignedp = (top[1].value.unsignedp
 966                                   || top[2].value.unsignedp);
 967           continue;
 968
 969         case CPP_QUERY:
 970           cpp_error (pfile, DL_ERROR, "'?' without following ':'");
 971           return 0;
 972
 973         default:
 974           goto bad_op;
 975         }
 976
 977       top--;
 978       if (top->value.overflow && !pfile->state.skip_eval)
 979         cpp_error (pfile, DL_PEDWARN,
 980                    "integer overflow in preprocessor expression");
 981     }
 982
 983   if (op == CPP_CLOSE_PAREN)
 984     {
 985       cpp_error (pfile, DL_ERROR, "missing '(' in expression");
 986       return 0;
 987     }
 988
 989   return top;
 990 }
 991
 992 /* Returns the position of the old top of stack after expansion.  */
 993 struct op *
 994 _cpp_expand_op_stack (pfile)
 995      cpp_reader *pfile;
 996 {
 997   size_t old_size = (size_t) (pfile->op_limit - pfile->op_stack);
 998   size_t new_size = old_size * 2 + 20;
 999
1000   pfile->op_stack = (struct op *) xrealloc (pfile->op_stack,
1001                                             new_size * sizeof (struct op));
1002   pfile->op_limit = pfile->op_stack + new_size;
1003
1004   return pfile->op_stack + old_size;
1005 }
1006
1007 /* Emits a warning if the effective sign of either operand of OP
1008    changes because of integer promotions.  */
1009 static void
1010 check_promotion (pfile, op)
1011      cpp_reader *pfile;
1012      const struct op *op;
1013 {
1014   if (op->value.unsignedp == op[-1].value.unsignedp)
1015     return;
1016
1017   if (op->value.unsignedp)
1018     {
1019       if (!num_positive (op[-1].value, CPP_OPTION (pfile, precision)))
1020         cpp_error (pfile, DL_WARNING,
1021                    "the left operand of \"%s\" changes sign when promoted",
1022                    cpp_token_as_text (pfile, op->token));
1023     }
1024   else if (!num_positive (op->value, CPP_OPTION (pfile, precision)))
1025     cpp_error (pfile, DL_WARNING,
1026                "the right operand of \"%s\" changes sign when promoted",
1027                cpp_token_as_text (pfile, op->token));
1028 }
1029
1030 /* Clears the unused high order bits of the number pointed to by PNUM.  */
1031 static cpp_num
1032 num_trim (num, precision)
1033      cpp_num num;
1034      size_t precision;
1035 {
1036   if (precision > PART_PRECISION)
1037     {
1038       precision -= PART_PRECISION;
1039       if (precision < PART_PRECISION)
1040         num.high &= ((cpp_num_part) 1 << precision) - 1;
1041     }
1042   else
1043     {
1044       if (precision < PART_PRECISION)
1045         num.low &= ((cpp_num_part) 1 << precision) - 1;
1046       num.high = 0;
1047     }
1048
1049   return num;
1050 }
1051
1052 /* True iff A (presumed signed) >= 0.  */
1053 static bool
1054 num_positive (num, precision)
1055      cpp_num num;
1056      size_t precision;
1057 {
1058   if (precision > PART_PRECISION)
1059     {
1060       precision -= PART_PRECISION;
1061       return (num.high & (cpp_num_part) 1 << (precision - 1)) == 0;
1062     }
1063
1064   return (num.low & (cpp_num_part) 1 << (precision - 1)) == 0;
1065 }
1066
1067 /* Sign extend a number, with PRECISION significant bits and all
1068    others assumed clear, to fill out a cpp_num structure.  */
1069 cpp_num
1070 cpp_num_sign_extend (num, precision)
1071      cpp_num num;
1072      size_t precision;
1073 {
1074   if (!num.unsignedp)
1075     {
1076       if (precision > PART_PRECISION)
1077         {
1078           precision -= PART_PRECISION;
1079           if (precision < PART_PRECISION
1080               && (num.high & (cpp_num_part) 1 << (precision - 1)))
1081             num.high |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1082         }
1083       else if (num.low & (cpp_num_part) 1 << (precision - 1))
1084         {
1085           if (precision < PART_PRECISION)
1086             num.low |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1087           num.high = ~(cpp_num_part) 0;
1088         }
1089     }
1090
1091   return num;
1092 }
1093
1094 /* Returns the negative of NUM.  */
1095 static cpp_num
1096 num_negate (num, precision)
1097      cpp_num num;
1098      size_t precision;
1099 {
1100   cpp_num copy;
1101
1102   copy = num;
1103   num.high = ~num.high;
1104   num.low = ~num.low;
1105   if (++num.low == 0)
1106     num.high++;
1107   num = num_trim (num, precision);
1108   num.overflow = (!num.unsignedp && num_eq (num, copy) && !num_zerop (num));
1109
1110   return num;
1111 }
1112
1113 /* Returns true if A >= B.  */
1114 static bool
1115 num_greater_eq (pa, pb, precision)
1116      cpp_num pa, pb;
1117      size_t precision;
1118 {
1119   bool unsignedp;
1120
1121   unsignedp = pa.unsignedp || pb.unsignedp;
1122
1123   if (!unsignedp)
1124     {
1125       /* Both numbers have signed type.  If they are of different
1126        sign, the answer is the sign of A.  */
1127       unsignedp = num_positive (pa, precision);
1128
1129       if (unsignedp != num_positive (pb, precision))
1130         return unsignedp;
1131
1132       /* Otherwise we can do an unsigned comparison.  */
1133     }
1134
1135   return (pa.high > pb.high) || (pa.high == pb.high && pa.low >= pb.low);
1136 }
1137
1138 /* Returns LHS OP RHS, where OP is a bit-wise operation.  */
1139 static cpp_num
1140 num_bitwise_op (pfile, lhs, rhs, op)
1141      cpp_reader *pfile ATTRIBUTE_UNUSED;
1142      cpp_num lhs, rhs;
1143      enum cpp_ttype op;
1144 {
1145   lhs.overflow = false;
1146   lhs.unsignedp = lhs.unsignedp || rhs.unsignedp;
1147
1148   /* As excess precision is zeroed, there is no need to num_trim () as
1149      these operations cannot introduce a set bit there.  */
1150   if (op == CPP_AND)
1151     {
1152       lhs.low &= rhs.low;
1153       lhs.high &= rhs.high;
1154     }
1155   else if (op == CPP_OR)
1156     {
1157       lhs.low |= rhs.low;
1158       lhs.high |= rhs.high;
1159     }
1160   else
1161     {
1162       lhs.low ^= rhs.low;
1163       lhs.high ^= rhs.high;
1164     }
1165
1166   return lhs;
1167 }
1168
1169 /* Returns LHS OP RHS, where OP is an inequality.  */
1170 static cpp_num
1171 num_inequality_op (pfile, lhs, rhs, op)
1172      cpp_reader *pfile;
1173      cpp_num lhs, rhs;
1174      enum cpp_ttype op;
1175 {
1176   bool gte = num_greater_eq (lhs, rhs, CPP_OPTION (pfile, precision));
1177
1178   if (op == CPP_GREATER_EQ)
1179     lhs.low = gte;
1180   else if (op == CPP_LESS)
1181     lhs.low = !gte;
1182   else if (op == CPP_GREATER)
1183     lhs.low = gte && !num_eq (lhs, rhs);
1184   else /* CPP_LESS_EQ.  */
1185     lhs.low = !gte || num_eq (lhs, rhs);
1186
1187   lhs.high = 0;
1188   lhs.overflow = false;
1189   lhs.unsignedp = false;
1190   return lhs;
1191 }
1192
1193 /* Returns LHS OP RHS, where OP is == or !=.  */
1194 static cpp_num
1195 num_equality_op (pfile, lhs, rhs, op)
1196      cpp_reader *pfile ATTRIBUTE_UNUSED;
1197      cpp_num lhs, rhs;
1198      enum cpp_ttype op;
1199 {
1200   /* Work around a 3.0.4 bug; see PR 6950.  */
1201   bool eq = num_eq (lhs, rhs);
1202   if (op == CPP_NOT_EQ)
1203     eq = !eq;
1204   lhs.low = eq;
1205   lhs.high = 0;
1206   lhs.overflow = false;
1207   lhs.unsignedp = false;
1208   return lhs;
1209 }
1210
1211 /* Shift NUM, of width PRECISION, right by N bits.  */
1212 static cpp_num
1213 num_rshift (num, precision, n)
1214      cpp_num num;
1215      size_t precision, n;
1216 {
1217   cpp_num_part sign_mask;
1218
1219   if (num.unsignedp || num_positive (num, precision))
1220     sign_mask = 0;
1221   else
1222     sign_mask = ~(cpp_num_part) 0;
1223
1224   if (n >= precision)
1225     num.high = num.low = sign_mask;
1226   else
1227     {
1228       /* Sign-extend.  */
1229       if (precision < PART_PRECISION)
1230         num.high = sign_mask, num.low |= sign_mask << precision;
1231       else if (precision < 2 * PART_PRECISION)
1232         num.high |= sign_mask << (precision - PART_PRECISION);
1233
1234       if (n >= PART_PRECISION)
1235         {
1236           n -= PART_PRECISION;
1237           num.low = num.high;
1238           num.high = sign_mask;
1239         }
1240
1241       if (n)
1242         {
1243           num.low = (num.low >> n) | (num.high << (PART_PRECISION - n));
1244           num.high = (num.high >> n) | (sign_mask << (PART_PRECISION - n));
1245         }
1246     }
1247
1248   num = num_trim (num, precision);
1249   num.overflow = false;
1250   return num;
1251 }
1252
1253 /* Shift NUM, of width PRECISION, left by N bits.  */
1254 static cpp_num
1255 num_lshift (num, precision, n)
1256      cpp_num num;
1257      size_t precision, n;
1258 {
1259   if (n >= precision)
1260     {
1261       num.overflow = !num.unsignedp && !num_zerop (num);
1262       num.high = num.low = 0;
1263     }
1264   else
1265     {
1266       cpp_num orig, maybe_orig;
1267       size_t m = n;
1268
1269       orig = num;
1270       if (m >= PART_PRECISION)
1271         {
1272           m -= PART_PRECISION;
1273           num.high = num.low;
1274           num.low = 0;
1275         }
1276       if (m)
1277         {
1278           num.high = (num.high << m) | (num.low >> (PART_PRECISION - m));
1279           num.low <<= m;
1280         }
1281       num = num_trim (num, precision);
1282
1283       if (num.unsignedp)
1284         num.overflow = false;
1285       else
1286         {
1287           maybe_orig = num_rshift (num, precision, n);
1288           num.overflow = !num_eq (orig, maybe_orig);
1289         }
1290     }
1291
1292   return num;
1293 }
1294
1295 /* The four unary operators: +, -, ! and ~.  */
1296 static cpp_num
1297 num_unary_op (pfile, num, op)
1298      cpp_reader *pfile;
1299      cpp_num num;
1300      enum cpp_ttype op;
1301 {
1302   switch (op)
1303     {
1304     case CPP_UPLUS:
1305       if (CPP_WTRADITIONAL (pfile) && !pfile->state.skip_eval)
1306         cpp_error (pfile, DL_WARNING,
1307                    "traditional C rejects the unary plus operator");
1308       num.overflow = false;
1309       break;
1310
1311     case CPP_UMINUS:
1312       num = num_negate (num, CPP_OPTION (pfile, precision));
1313       break;
1314
1315     case CPP_COMPL:
1316       num.high = ~num.high;
1317       num.low = ~num.low;
1318       num = num_trim (num, CPP_OPTION (pfile, precision));
1319       num.overflow = false;
1320       break;
1321
1322     default: /* case CPP_NOT: */
1323       num.low = num_zerop (num);
1324       num.high = 0;
1325       num.overflow = false;
1326       num.unsignedp = false;
1327       break;
1328     }
1329
1330   return num;
1331 }
1332
1333 /* The various binary operators.  */
1334 static cpp_num
1335 num_binary_op (pfile, lhs, rhs, op)
1336      cpp_reader *pfile;
1337      cpp_num lhs, rhs;
1338      enum cpp_ttype op;
1339 {
1340   cpp_num result;
1341   size_t precision = CPP_OPTION (pfile, precision);
1342   bool gte;
1343   size_t n;
1344
1345   switch (op)
1346     {
1347       /* Shifts.  */
1348     case CPP_LSHIFT:
1349     case CPP_RSHIFT:
1350       if (!rhs.unsignedp && !num_positive (rhs, precision))
1351         {
1352           /* A negative shift is a positive shift the other way.  */
1353           if (op == CPP_LSHIFT)
1354             op = CPP_RSHIFT;
1355           else
1356             op = CPP_LSHIFT;
1357           rhs = num_negate (rhs, precision);
1358         }
1359       if (rhs.high)
1360         n = ~0;                 /* Maximal.  */
1361       else
1362         n = rhs.low;
1363       if (op == CPP_LSHIFT)
1364         lhs = num_lshift (lhs, precision, n);
1365       else
1366         lhs = num_rshift (lhs, precision, n);
1367       break;
1368
1369       /* Min / Max.  */
1370     case CPP_MIN:
1371     case CPP_MAX:
1372       {
1373         bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1374
1375         gte = num_greater_eq (lhs, rhs, precision);
1376         if (op == CPP_MIN)
1377           gte = !gte;
1378         if (!gte)
1379           lhs = rhs;
1380         lhs.unsignedp = unsignedp;
1381       }
1382       break;
1383
1384       /* Arithmetic.  */
1385     case CPP_MINUS:
1386       rhs = num_negate (rhs, precision);
1387     case CPP_PLUS:
1388       result.low = lhs.low + rhs.low;
1389       result.high = lhs.high + rhs.high;
1390       if (result.low < lhs.low)
1391         result.high++;
1392
1393       result = num_trim (result, precision);
1394       result.unsignedp = lhs.unsignedp || rhs.unsignedp;
1395       if (result.unsignedp)
1396         result.overflow = false;
1397       else
1398         {
1399           bool lhsp = num_positive (lhs, precision);
1400           result.overflow = (lhsp == num_positive (rhs, precision)
1401                              && lhsp != num_positive (result, precision));
1402         }
1403       return result;
1404
1405       /* Comma.  */
1406     default: /* case CPP_COMMA: */
1407       if (CPP_PEDANTIC (pfile) && !pfile->state.skip_eval)
1408         cpp_error (pfile, DL_PEDWARN,
1409                    "comma operator in operand of #if");
1410       lhs = rhs;
1411       break;
1412     }
1413
1414   return lhs;
1415 }
1416
1417 /* Multiplies two unsigned cpp_num_parts to give a cpp_num.  This
1418    cannot overflow.  */
1419 static cpp_num
1420 num_part_mul (lhs, rhs)
1421      cpp_num_part lhs, rhs;
1422 {
1423   cpp_num result;
1424   cpp_num_part middle[2], temp;
1425
1426   result.low = LOW_PART (lhs) * LOW_PART (rhs);
1427   result.high = HIGH_PART (lhs) * HIGH_PART (rhs);
1428
1429   middle[0] = LOW_PART (lhs) * HIGH_PART (rhs);
1430   middle[1] = HIGH_PART (lhs) * LOW_PART (rhs);
1431
1432   temp = result.low;
1433   result.low += LOW_PART (middle[0]) << (PART_PRECISION / 2);
1434   if (result.low < temp)
1435     result.high++;
1436
1437   temp = result.low;
1438   result.low += LOW_PART (middle[1]) << (PART_PRECISION / 2);
1439   if (result.low < temp)
1440     result.high++;
1441
1442   result.high += HIGH_PART (middle[0]);
1443   result.high += HIGH_PART (middle[1]);
1444   result.unsignedp = 1;
1445
1446   return result;
1447 }
1448
1449 /* Multiply two preprocessing numbers.  */
1450 static cpp_num
1451 num_mul (pfile, lhs, rhs)
1452      cpp_reader *pfile;
1453      cpp_num lhs, rhs;
1454 {
1455   cpp_num result, temp;
1456   bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1457   bool overflow, negate = false;
1458   size_t precision = CPP_OPTION (pfile, precision);
1459
1460   /* Prepare for unsigned multiplication.  */
1461   if (!unsignedp)
1462     {
1463       if (!num_positive (lhs, precision))
1464         negate = !negate, lhs = num_negate (lhs, precision);
1465       if (!num_positive (rhs, precision))
1466         negate = !negate, rhs = num_negate (rhs, precision);
1467     }
1468
1469   overflow = lhs.high && rhs.high;
1470   result = num_part_mul (lhs.low, rhs.low);
1471
1472   temp = num_part_mul (lhs.high, rhs.low);
1473   result.high += temp.low;
1474   if (temp.high)
1475     overflow = true;
1476
1477   temp = num_part_mul (lhs.low, rhs.high);
1478   result.high += temp.low;
1479   if (temp.high)
1480     overflow = true;
1481
1482   temp.low = result.low, temp.high = result.high;
1483   result = num_trim (result, precision);
1484   if (!num_eq (result, temp))
1485     overflow = true;
1486
1487   if (negate)
1488     result = num_negate (result, precision);
1489
1490   if (unsignedp)
1491     result.overflow = false;
1492   else
1493     result.overflow = overflow || (num_positive (result, precision) ^ !negate
1494                                    && !num_zerop (result));
1495   result.unsignedp = unsignedp;
1496
1497   return result;
1498 }
1499
1500 /* Divide two preprocessing numbers, returning the answer or the
1501    remainder depending upon OP.  */
1502 static cpp_num
1503 num_div_op (pfile, lhs, rhs, op)
1504      cpp_reader *pfile;
1505      cpp_num lhs, rhs;
1506      enum cpp_ttype op;
1507 {
1508   cpp_num result, sub;
1509   cpp_num_part mask;
1510   bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1511   bool negate = false, lhs_neg = false;
1512   size_t i, precision = CPP_OPTION (pfile, precision);
1513
1514   /* Prepare for unsigned division.  */
1515   if (!unsignedp)
1516     {
1517       if (!num_positive (lhs, precision))
1518         negate = !negate, lhs_neg = true, lhs = num_negate (lhs, precision);
1519       if (!num_positive (rhs, precision))
1520         negate = !negate, rhs = num_negate (rhs, precision);
1521     }
1522
1523   /* Find the high bit.  */
1524   if (rhs.high)
1525     {
1526       i = precision - 1;
1527       mask = (cpp_num_part) 1 << (i - PART_PRECISION);
1528       for (; ; i--, mask >>= 1)
1529         if (rhs.high & mask)
1530           break;
1531     }
1532   else if (rhs.low)
1533     {
1534       if (precision > PART_PRECISION)
1535         i = precision - PART_PRECISION - 1;
1536       else
1537         i = precision - 1;
1538       mask = (cpp_num_part) 1 << i;
1539       for (; ; i--, mask >>= 1)
1540         if (rhs.low & mask)
1541           break;
1542     }
1543   else
1544     {
1545       if (!pfile->state.skip_eval)
1546         cpp_error (pfile, DL_ERROR, "division by zero in #if");
1547       return lhs;
1548     }
1549
1550   /* First nonzero bit of RHS is bit I.  Do naive division by
1551      shifting the RHS fully left, and subtracting from LHS if LHS is
1552      at least as big, and then repeating but with one less shift.
1553      This is not very efficient, but is easy to understand.  */
1554
1555   rhs.unsignedp = true;
1556   lhs.unsignedp = true;
1557   i = precision - i - 1;
1558   sub = num_lshift (rhs, precision, i);
1559
1560   result.high = result.low = 0;
1561   for (;;)
1562     {
1563       if (num_greater_eq (lhs, sub, precision))
1564         {
1565           lhs = num_binary_op (pfile, lhs, sub, CPP_MINUS);
1566           if (i >= PART_PRECISION)
1567             result.high |= (cpp_num_part) 1 << (i - PART_PRECISION);
1568           else
1569             result.low |= (cpp_num_part) 1 << i;
1570         }
1571       if (i-- == 0)
1572         break;
1573       sub.low = (sub.low >> 1) | (sub.high << (PART_PRECISION - 1));
1574       sub.high >>= 1;
1575     }
1576
1577   /* We divide so that the remainder has the sign of the LHS.  */
1578   if (op == CPP_DIV)
1579     {
1580       result.unsignedp = unsignedp;
1581       if (unsignedp)
1582         result.overflow = false;
1583       else
1584         {
1585           if (negate)
1586             result = num_negate (result, precision);
1587           result.overflow = num_positive (result, precision) ^ !negate;
1588         }
1589
1590       return result;
1591     }
1592
1593   /* CPP_MOD.  */
1594   lhs.unsignedp = unsignedp;
1595   lhs.overflow = false;
1596   if (lhs_neg)
1597     lhs = num_negate (lhs, precision);
1598
1599   return lhs;
1600 }