libcpp/expr.c

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