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