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