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