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