libcpp/expr.c

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