1/* Parse C expressions for CCCP. 2 Copyright (C) 1987, 92, 94, 95, 97, 98, 1999 Free Software Foundation. 3 4This program is free software; you can redistribute it and/or modify it 5under the terms of the GNU General Public License as published by the 6Free Software Foundation; either version 2, or (at your option) any 7later version. 8 9This program is distributed in the hope that it will be useful, 10but WITHOUT ANY WARRANTY; without even the implied warranty of 11MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12GNU General Public License for more details. 13 14You should have received a copy of the GNU General Public License 15along with this program; if not, write to the Free Software 16Foundation, 59 Temple Place - Suite 330, 17Boston, MA 02111-1307, USA. 18 19 In other words, you are welcome to use, share and improve this program. 20 You are forbidden to forbid anyone else to use, share and improve 21 what you give them. Help stamp out software-hoarding! 22 23Written by Per Bothner 1994. */ 24 25/* Parse a C expression from text in a string */ 26 27#include "config.h" 28#include "system.h" 29#include "cpplib.h" 30 31#ifdef MULTIBYTE_CHARS 32#include <locale.h> 33#endif 34 35#ifndef CHAR_TYPE_SIZE 36#define CHAR_TYPE_SIZE BITS_PER_UNIT 37#endif 38 39#ifndef INT_TYPE_SIZE 40#define INT_TYPE_SIZE BITS_PER_WORD 41#endif 42 43#ifndef LONG_TYPE_SIZE 44#define LONG_TYPE_SIZE BITS_PER_WORD 45#endif 46 47#ifndef WCHAR_TYPE_SIZE 48#define WCHAR_TYPE_SIZE INT_TYPE_SIZE 49#endif 50 51#ifndef MAX_CHAR_TYPE_SIZE 52#define MAX_CHAR_TYPE_SIZE CHAR_TYPE_SIZE 53#endif 54 55#ifndef MAX_INT_TYPE_SIZE 56#define MAX_INT_TYPE_SIZE INT_TYPE_SIZE 57#endif 58 59#ifndef MAX_LONG_TYPE_SIZE 60#define MAX_LONG_TYPE_SIZE LONG_TYPE_SIZE 61#endif 62 63#ifndef MAX_WCHAR_TYPE_SIZE 64#define MAX_WCHAR_TYPE_SIZE WCHAR_TYPE_SIZE 65#endif 66 67#define MAX_CHAR_TYPE_MASK (MAX_CHAR_TYPE_SIZE < HOST_BITS_PER_WIDEST_INT \ 68 ? (~ (~ (HOST_WIDEST_INT) 0 << MAX_CHAR_TYPE_SIZE)) \ 69 : ~ (HOST_WIDEST_INT) 0) 70 71#define MAX_WCHAR_TYPE_MASK (MAX_WCHAR_TYPE_SIZE < HOST_BITS_PER_WIDEST_INT \ 72 ? ~ (~ (HOST_WIDEST_INT) 0 << MAX_WCHAR_TYPE_SIZE) \ 73 : ~ (HOST_WIDEST_INT) 0) 74 75/* Yield nonzero if adding two numbers with A's and B's signs can yield a 76 number with SUM's sign, where A, B, and SUM are all C integers. */ 77#define possible_sum_sign(a, b, sum) ((((a) ^ (b)) | ~ ((a) ^ (sum))) < 0) 78 79static void integer_overflow PARAMS ((cpp_reader *)); 80static HOST_WIDEST_INT left_shift PARAMS ((cpp_reader *, HOST_WIDEST_INT, int, unsigned HOST_WIDEST_INT)); 81static HOST_WIDEST_INT right_shift PARAMS ((cpp_reader *, HOST_WIDEST_INT, int, unsigned HOST_WIDEST_INT)); 82 83#define ERROR 299 84#define OROR 300 85#define ANDAND 301 86#define EQUAL 302 87#define NOTEQUAL 303 88#define LEQ 304 89#define GEQ 305 90#define LSH 306 91#define RSH 307 92#define NAME 308 93#define INT 309 94#define CHAR 310 95 96#define LEFT_OPERAND_REQUIRED 1 97#define RIGHT_OPERAND_REQUIRED 2 98#define HAVE_VALUE 4 99/* SKIP_OPERAND is set for '&&' '||' '?' and ':' when the 100 following operand should be short-circuited instead of evaluated. */ 101#define SKIP_OPERAND 8 102/*#define UNSIGNEDP 16*/ 103 104struct operation { 105 short op; 106 char rprio; /* Priority of op (relative to it right operand). */ 107 char flags; 108 char unsignedp; /* true if value should be treated as unsigned */ 109 HOST_WIDEST_INT value; /* The value logically "right" of op. */ 110}; 111 112/* Parse and convert an integer for #if. Accepts decimal, hex, or octal 113 with or without size suffixes. */ 114 115static struct operation 116parse_number (pfile, start, end) 117 cpp_reader *pfile; 118 U_CHAR *start; 119 U_CHAR *end; 120{ 121 struct operation op; 122 U_CHAR *p = start; 123 int c; 124 unsigned HOST_WIDEST_INT n = 0, nd, MAX_over_base; 125 int base = 10; 126 int overflow = 0; 127 int digit, largest_digit = 0; 128 int spec_long = 0; 129 130 op.unsignedp = 0; 131 132 if (p[0] == '0') 133 { 134 if (end - start >= 3 && (p[1] == 'x' || p[1] == 'X')) 135 { 136 p += 2; 137 base = 16; 138 } 139 else 140 { 141 p += 1; 142 base = 8; 143 } 144 } 145 146 /* Some buggy compilers (e.g. MPW C) seem to need both casts. */ 147 MAX_over_base = (((unsigned HOST_WIDEST_INT) -1) 148 / ((unsigned HOST_WIDEST_INT) base)); 149 150 while (p < end) 151 { 152 c = *p++; 153 154 if (c >= '0' && c <= '9') 155 digit = c - '0'; 156 else if (base == 16 && c >= 'a' && c <= 'f') /* FIXME: assumes ASCII */ 157 digit = c - 'a' + 10; 158 else if (base == 16 && c >= 'A' && c <= 'F') 159 digit = c - 'A' + 10; 160 else if (c == '.') 161 { 162 /* It's a float since it contains a point. */ 163 cpp_error (pfile, 164 "floating point numbers are not allowed in #if expressions"); 165 goto error; 166 } 167 else 168 { 169 /* `l' means long, and `u' means unsigned. */ 170 for (;;) 171 { 172 if (c == 'l' || c == 'L') 173 spec_long++; 174 else if (c == 'u' || c == 'U') 175 op.unsignedp++; 176 else 177 { 178 /* Decrement p here so that the error for an invalid number 179 will be generated below in the case where this is the 180 last character in the buffer. */ 181 p--; 182 break; 183 } 184 if (p == end) 185 break; 186 c = *p++; 187 } 188 /* Don't look for any more digits after the suffixes. */ 189 break; 190 } 191 192 if (largest_digit < digit) 193 largest_digit = digit; 194 nd = n * base + digit; 195 overflow |= MAX_over_base < n || nd < n; 196 n = nd; 197 } 198 199 if (p != end) 200 { 201 cpp_error (pfile, "invalid number in #if expression"); 202 goto error; 203 } 204 else if (spec_long > (CPP_OPTIONS (pfile)->c89 ? 1 : 2)) 205 { 206 cpp_error (pfile, "too many `l' suffixes in integer constant"); 207 goto error; 208 } 209 else if (op.unsignedp > 1) 210 { 211 cpp_error (pfile, "too many `u' suffixes in integer constant"); 212 goto error; 213 } 214 215 if (base <= largest_digit) 216 cpp_pedwarn (pfile, "integer constant contains digits beyond the radix"); 217 218 if (overflow) 219 cpp_pedwarn (pfile, "integer constant out of range"); 220 221 /* If too big to be signed, consider it unsigned. */ 222 else if ((HOST_WIDEST_INT) n < 0 && ! op.unsignedp) 223 { 224 if (base == 10) 225 cpp_warning (pfile, 226 "integer constant is so large that it is unsigned"); 227 op.unsignedp = 1; 228 } 229 230 op.value = n; 231 op.op = INT; 232 return op; 233 234 error: 235 op.op = ERROR; 236 return op; 237} 238 239/* Parse and convert a character constant for #if. Understands backslash 240 escapes (\n, \031) and multibyte characters (if so configured). */ 241static struct operation 242parse_charconst (pfile, start, end) 243 cpp_reader *pfile; 244 U_CHAR *start; 245 U_CHAR *end; 246{ 247 struct operation op; 248 HOST_WIDEST_INT result = 0; 249 int num_chars = 0; 250 int num_bits; 251 unsigned int width = MAX_CHAR_TYPE_SIZE, mask = MAX_CHAR_TYPE_MASK; 252 int max_chars; 253 U_CHAR *ptr = start; 254 255 /* FIXME: Should use reentrant multibyte functions. */ 256#ifdef MULTIBYTE_CHARS 257 wchar_t c = (wchar_t)-1; 258 (void) mbtowc (NULL_PTR, NULL_PTR, 0); 259#else 260 int c = -1; 261#endif 262 263 if (*ptr == 'L') 264 { 265 ++ptr; 266 width = MAX_WCHAR_TYPE_SIZE, mask = MAX_WCHAR_TYPE_MASK; 267 } 268 max_chars = MAX_LONG_TYPE_SIZE / width; 269 270 ++ptr; /* skip initial quote */ 271 272 while (ptr < end) 273 { 274#ifndef MULTIBYTE_CHARS 275 c = *ptr++; 276#else 277 ptr += mbtowc (&c, ptr, end - ptr); 278#endif 279 if (c == '\'' || c == '\0') 280 break; 281 else if (c == '\\') 282 { 283 /* Hopefully valid assumption: if mbtowc returns a backslash, 284 we are in initial shift state. No valid escape-sequence 285 character can take us out of initial shift state or begin 286 an unshifted multibyte char, so cpp_parse_escape doesn't 287 need to know about multibyte chars. */ 288 289 c = cpp_parse_escape (pfile, (char **) &ptr, mask); 290 if (width < HOST_BITS_PER_INT 291 && (unsigned int) c >= (unsigned int)(1 << width)) 292 cpp_pedwarn (pfile, "escape sequence out of range for character"); 293 } 294 295 /* Merge character into result; ignore excess chars. */ 296 if (++num_chars <= max_chars) 297 { 298 if (width < HOST_BITS_PER_INT) 299 result = (result << width) | (c & ((1 << width) - 1)); 300 else 301 result = c; 302 } 303 } 304 305 if (num_chars == 0) 306 { 307 cpp_error (pfile, "empty character constant"); 308 goto error; 309 } 310 else if (c != '\'') 311 { 312 /* cpp_get_token has already emitted an error if !traditional. */ 313 if (! CPP_TRADITIONAL (pfile)) 314 cpp_error (pfile, "malformatted character constant"); 315 goto error; 316 } 317 else if (num_chars > max_chars) 318 { 319 cpp_error (pfile, "character constant too long"); 320 goto error; 321 } 322 else if (num_chars != 1 && ! CPP_TRADITIONAL (pfile)) 323 cpp_warning (pfile, "multi-character character constant"); 324 325 /* If char type is signed, sign-extend the constant. */ 326 num_bits = num_chars * width; 327 328 if (cpp_lookup (pfile, (U_CHAR *)"__CHAR_UNSIGNED__", 329 sizeof ("__CHAR_UNSIGNED__")-1, -1) 330 || ((result >> (num_bits - 1)) & 1) == 0) 331 op.value = result & ((unsigned HOST_WIDEST_INT) ~0 332 >> (HOST_BITS_PER_WIDEST_INT - num_bits)); 333 else 334 op.value = result | ~((unsigned HOST_WIDEST_INT) ~0 335 >> (HOST_BITS_PER_WIDEST_INT - num_bits)); 336 337 /* This is always a signed type. */ 338 op.unsignedp = 0; 339 op.op = CHAR; 340 return op; 341 342 error: 343 op.op = ERROR; 344 return op; 345} 346 347 348struct token { 349 char *operator; 350 int token; 351}; 352 353static struct token tokentab2[] = { 354 {"&&", ANDAND}, 355 {"||", OROR}, 356 {"<<", LSH}, 357 {">>", RSH}, 358 {"==", EQUAL}, 359 {"!=", NOTEQUAL}, 360 {"<=", LEQ}, 361 {">=", GEQ}, 362 {"++", ERROR}, 363 {"--", ERROR}, 364 {NULL, ERROR} 365}; 366 367/* Read one token. */ 368 369static struct operation 370cpp_lex (pfile, skip_evaluation) 371 cpp_reader *pfile; 372 int skip_evaluation; 373{ 374 U_CHAR c; 375 struct token *toktab; 376 enum cpp_token token; 377 struct operation op; 378 U_CHAR *tok_start, *tok_end; 379 int old_written; 380 381 retry: 382 383 old_written = CPP_WRITTEN (pfile); 384 cpp_skip_hspace (pfile); 385 c = CPP_BUF_PEEK (CPP_BUFFER (pfile)); 386 if (c == '#') 387 { 388 op.op = INT; 389 op.value = cpp_read_check_assertion (pfile); 390 return op; 391 } 392 393 if (c == '\n') 394 { 395 op.op = 0; 396 return op; 397 } 398 399 token = cpp_get_token (pfile); 400 tok_start = pfile->token_buffer + old_written; 401 tok_end = CPP_PWRITTEN (pfile); 402 pfile->limit = tok_start; 403 switch (token) 404 { 405 case CPP_EOF: /* Should not happen ... */ 406 case CPP_VSPACE: 407 op.op = 0; 408 return op; 409 case CPP_POP: 410 if (CPP_BUFFER (pfile)->fname != NULL) 411 { 412 op.op = 0; 413 return op; 414 } 415 cpp_pop_buffer (pfile); 416 goto retry; 417 case CPP_HSPACE: 418 case CPP_COMMENT: 419 goto retry; 420 case CPP_NUMBER: 421 return parse_number (pfile, tok_start, tok_end); 422 case CPP_STRING: 423 cpp_error (pfile, "string constants not allowed in #if expressions"); 424 op.op = ERROR; 425 return op; 426 case CPP_CHAR: 427 return parse_charconst (pfile, tok_start, tok_end); 428 429 case CPP_NAME: 430 op.op = INT; 431 op.unsignedp = 0; 432 op.value = 0; 433 if (strcmp (tok_start, "defined")) 434 { 435 if (CPP_WARN_UNDEF (pfile) && !skip_evaluation) 436 cpp_warning (pfile, "`%.*s' is not defined", 437 (int) (tok_end - tok_start), tok_start); 438 } 439 else 440 { 441 int paren = 0, len; 442 cpp_buffer *ip = CPP_BUFFER (pfile); 443 U_CHAR *tok; 444 445 cpp_skip_hspace (pfile); 446 if (*ip->cur == '(') 447 { 448 paren++; 449 ip->cur++; /* Skip over the paren */ 450 cpp_skip_hspace (pfile); 451 } 452 453 if (!is_idstart[*ip->cur]) 454 goto oops; 455 if (ip->cur[0] == 'L' && (ip->cur[1] == '\'' || ip->cur[1] == '"')) 456 goto oops; 457 tok = ip->cur; 458 while (is_idchar[*ip->cur]) 459 ++ip->cur; 460 len = ip->cur - tok; 461 cpp_skip_hspace (pfile); 462 if (paren) 463 { 464 if (*ip->cur != ')') 465 goto oops; 466 ++ip->cur; 467 } 468 if (cpp_lookup (pfile, tok, len, -1)) 469 op.value = 1; 470 471 } 472 return op; 473 474 oops: 475 cpp_error (pfile, "`defined' without an identifier"); 476 return op; 477 478 case CPP_OTHER: 479 /* See if it is a special token of length 2. */ 480 if (tok_start + 2 == tok_end) 481 { 482 for (toktab = tokentab2; toktab->operator != NULL; toktab++) 483 if (tok_start[0] == toktab->operator[0] 484 && tok_start[1] == toktab->operator[1]) 485 break; 486 if (toktab->token == ERROR) 487 cpp_error (pfile, "`%s' not allowed in operand of `#if'", 488 tok_start); 489 op.op = toktab->token; 490 return op; 491 } 492 /* fall through */ 493 default: 494 op.op = *tok_start; 495 return op; 496 } 497} 498 499 500/* Parse a C escape sequence. STRING_PTR points to a variable 501 containing a pointer to the string to parse. That pointer 502 is updated past the characters we use. The value of the 503 escape sequence is returned. 504 505 A negative value means the sequence \ newline was seen, 506 which is supposed to be equivalent to nothing at all. 507 508 If \ is followed by a null character, we return a negative 509 value and leave the string pointer pointing at the null character. 510 511 If \ is followed by 000, we return 0 and leave the string pointer 512 after the zeros. A value of 0 does not mean end of string. */ 513 514HOST_WIDEST_INT 515cpp_parse_escape (pfile, string_ptr, result_mask) 516 cpp_reader *pfile; 517 char **string_ptr; 518 HOST_WIDEST_INT result_mask; 519{ 520 register int c = *(*string_ptr)++; 521 switch (c) 522 { 523 case 'a': 524 return TARGET_BELL; 525 case 'b': 526 return TARGET_BS; 527 case 'e': 528 case 'E': 529 if (CPP_OPTIONS (pfile)->pedantic) 530 cpp_pedwarn (pfile, "non-ANSI-standard escape sequence, `\\%c'", c); 531 return 033; 532 case 'f': 533 return TARGET_FF; 534 case 'n': 535 return TARGET_NEWLINE; 536 case 'r': 537 return TARGET_CR; 538 case 't': 539 return TARGET_TAB; 540 case 'v': 541 return TARGET_VT; 542 case '\n': 543 return -2; 544 case 0: 545 (*string_ptr)--; 546 return 0; 547 548 case '0': 549 case '1': 550 case '2': 551 case '3': 552 case '4': 553 case '5': 554 case '6': 555 case '7': 556 { 557 register HOST_WIDEST_INT i = c - '0'; 558 register int count = 0; 559 while (++count < 3) 560 { 561 c = *(*string_ptr)++; 562 if (c >= '0' && c <= '7') 563 i = (i << 3) + c - '0'; 564 else 565 { 566 (*string_ptr)--; 567 break; 568 } 569 } 570 if (i != (i & result_mask)) 571 { 572 i &= result_mask; 573 cpp_pedwarn (pfile, "octal escape sequence out of range"); 574 } 575 return i; 576 } 577 case 'x': 578 { 579 register unsigned HOST_WIDEST_INT i = 0, overflow = 0; 580 register int digits_found = 0, digit; 581 for (;;) 582 { 583 c = *(*string_ptr)++; 584 if (c >= '0' && c <= '9') 585 digit = c - '0'; 586 else if (c >= 'a' && c <= 'f') 587 digit = c - 'a' + 10; 588 else if (c >= 'A' && c <= 'F') 589 digit = c - 'A' + 10; 590 else 591 { 592 (*string_ptr)--; 593 break; 594 } 595 overflow |= i ^ (i << 4 >> 4); 596 i = (i << 4) + digit; 597 digits_found = 1; 598 } 599 if (!digits_found) 600 cpp_error (pfile, "\\x used with no following hex digits"); 601 if (overflow | (i != (i & result_mask))) 602 { 603 i &= result_mask; 604 cpp_pedwarn (pfile, "hex escape sequence out of range"); 605 } 606 return i; 607 } 608 default: 609 return c; 610 } 611} 612 613static void 614integer_overflow (pfile) 615 cpp_reader *pfile; 616{ 617 if (CPP_PEDANTIC (pfile)) 618 cpp_pedwarn (pfile, "integer overflow in preprocessor expression"); 619} 620 621static HOST_WIDEST_INT 622left_shift (pfile, a, unsignedp, b) 623 cpp_reader *pfile; 624 HOST_WIDEST_INT a; 625 int unsignedp; 626 unsigned HOST_WIDEST_INT b; 627{ 628 if (b >= HOST_BITS_PER_WIDEST_INT) 629 { 630 if (! unsignedp && a != 0) 631 integer_overflow (pfile); 632 return 0; 633 } 634 else if (unsignedp) 635 return (unsigned HOST_WIDEST_INT) a << b; 636 else 637 { 638 HOST_WIDEST_INT l = a << b; 639 if (l >> b != a) 640 integer_overflow (pfile); 641 return l; 642 } 643} 644 645static HOST_WIDEST_INT 646right_shift (pfile, a, unsignedp, b) 647 cpp_reader *pfile ATTRIBUTE_UNUSED; 648 HOST_WIDEST_INT a; 649 int unsignedp; 650 unsigned HOST_WIDEST_INT b; 651{ 652 if (b >= HOST_BITS_PER_WIDEST_INT) 653 return unsignedp ? 0 : a >> (HOST_BITS_PER_WIDEST_INT - 1); 654 else if (unsignedp) 655 return (unsigned HOST_WIDEST_INT) a >> b; 656 else 657 return a >> b; 658} 659 660/* These priorities are all even, so we can handle associatively. */ 661#define PAREN_INNER_PRIO 0 662#define COMMA_PRIO 4 663#define COND_PRIO (COMMA_PRIO+2) 664#define OROR_PRIO (COND_PRIO+2) 665#define ANDAND_PRIO (OROR_PRIO+2) 666#define OR_PRIO (ANDAND_PRIO+2) 667#define XOR_PRIO (OR_PRIO+2) 668#define AND_PRIO (XOR_PRIO+2) 669#define EQUAL_PRIO (AND_PRIO+2) 670#define LESS_PRIO (EQUAL_PRIO+2) 671#define SHIFT_PRIO (LESS_PRIO+2) 672#define PLUS_PRIO (SHIFT_PRIO+2) 673#define MUL_PRIO (PLUS_PRIO+2) 674#define UNARY_PRIO (MUL_PRIO+2) 675#define PAREN_OUTER_PRIO (UNARY_PRIO+2) 676 677#define COMPARE(OP) \ 678 top->unsignedp = 0;\ 679 top->value = (unsigned1 || unsigned2) \ 680 ? (unsigned HOST_WIDEST_INT) v1 OP (unsigned HOST_WIDEST_INT) v2 : (v1 OP v2) 681 682/* Parse and evaluate a C expression, reading from PFILE. 683 Returns the value of the expression. */ 684 685HOST_WIDEST_INT 686cpp_parse_expr (pfile) 687 cpp_reader *pfile; 688{ 689 /* The implementation is an operator precedence parser, 690 i.e. a bottom-up parser, using a stack for not-yet-reduced tokens. 691 692 The stack base is 'stack', and the current stack pointer is 'top'. 693 There is a stack element for each operator (only), 694 and the most recently pushed operator is 'top->op'. 695 An operand (value) is stored in the 'value' field of the stack 696 element of the operator that precedes it. 697 In that case the 'flags' field has the HAVE_VALUE flag set. */ 698 699#define INIT_STACK_SIZE 20 700 struct operation init_stack[INIT_STACK_SIZE]; 701 struct operation *stack = init_stack; 702 struct operation *limit = stack + INIT_STACK_SIZE; 703 register struct operation *top = stack; 704 int lprio, rprio = 0; 705 int skip_evaluation = 0; 706 707 top->rprio = 0; 708 top->flags = 0; 709 for (;;) 710 { 711 struct operation op; 712 char flags = 0; 713 714 /* Read a token */ 715 op = cpp_lex (pfile, skip_evaluation); 716 717 /* See if the token is an operand, in which case go to set_value. 718 If the token is an operator, figure out its left and right 719 priorities, and then goto maybe_reduce. */ 720 721 switch (op.op) 722 { 723 case NAME: 724 cpp_fatal (pfile, "internal error: cpp_lex returns a NAME"); 725 goto syntax_error; 726 case INT: case CHAR: 727 top->value = op.value; 728 top->unsignedp = op.unsignedp; 729 goto set_value; 730 case 0: 731 lprio = 0; goto maybe_reduce; 732 case '+': case '-': 733 /* Is this correct if unary ? FIXME */ 734 flags = RIGHT_OPERAND_REQUIRED; 735 lprio = PLUS_PRIO; rprio = lprio + 1; goto maybe_reduce; 736 case '!': case '~': 737 flags = RIGHT_OPERAND_REQUIRED; 738 rprio = UNARY_PRIO; lprio = rprio + 1; goto maybe_reduce; 739 case '*': case '/': case '%': 740 lprio = MUL_PRIO; goto binop; 741 case '<': case '>': case LEQ: case GEQ: 742 lprio = LESS_PRIO; goto binop; 743 case EQUAL: case NOTEQUAL: 744 lprio = EQUAL_PRIO; goto binop; 745 case LSH: case RSH: 746 lprio = SHIFT_PRIO; goto binop; 747 case '&': lprio = AND_PRIO; goto binop; 748 case '^': lprio = XOR_PRIO; goto binop; 749 case '|': lprio = OR_PRIO; goto binop; 750 case ANDAND: lprio = ANDAND_PRIO; goto binop; 751 case OROR: lprio = OROR_PRIO; goto binop; 752 case ',': 753 lprio = COMMA_PRIO; goto binop; 754 case '(': 755 lprio = PAREN_OUTER_PRIO; rprio = PAREN_INNER_PRIO; 756 goto maybe_reduce; 757 case ')': 758 lprio = PAREN_INNER_PRIO; rprio = PAREN_OUTER_PRIO; 759 goto maybe_reduce; 760 case ':': 761 lprio = COND_PRIO; rprio = COND_PRIO; 762 goto maybe_reduce; 763 case '?': 764 lprio = COND_PRIO + 1; rprio = COND_PRIO; 765 goto maybe_reduce; 766 case ERROR: 767 goto syntax_error; 768 binop: 769 flags = LEFT_OPERAND_REQUIRED|RIGHT_OPERAND_REQUIRED; 770 rprio = lprio + 1; 771 goto maybe_reduce; 772 default: 773 cpp_error (pfile, "invalid character in #if"); 774 goto syntax_error; 775 } 776 777 set_value: 778 /* Push a value onto the stack. */ 779 if (top->flags & HAVE_VALUE) 780 { 781 cpp_error (pfile, "syntax error in #if"); 782 goto syntax_error; 783 } 784 top->flags |= HAVE_VALUE; 785 continue; 786 787 maybe_reduce: 788 /* Push an operator, and check if we can reduce now. */ 789 while (top->rprio > lprio) 790 { 791 HOST_WIDEST_INT v1 = top[-1].value, v2 = top[0].value; 792 int unsigned1 = top[-1].unsignedp, unsigned2 = top[0].unsignedp; 793 top--; 794 if ((top[1].flags & LEFT_OPERAND_REQUIRED) 795 && ! (top[0].flags & HAVE_VALUE)) 796 { 797 cpp_error (pfile, "syntax error - missing left operand"); 798 goto syntax_error; 799 } 800 if ((top[1].flags & RIGHT_OPERAND_REQUIRED) 801 && ! (top[1].flags & HAVE_VALUE)) 802 { 803 cpp_error (pfile, "syntax error - missing right operand"); 804 goto syntax_error; 805 } 806 /* top[0].value = (top[1].op)(v1, v2);*/ 807 switch (top[1].op) 808 { 809 case '+': 810 if (!(top->flags & HAVE_VALUE)) 811 { /* Unary '+' */ 812 top->value = v2; 813 top->unsignedp = unsigned2; 814 top->flags |= HAVE_VALUE; 815 } 816 else 817 { 818 top->value = v1 + v2; 819 top->unsignedp = unsigned1 || unsigned2; 820 if (! top->unsignedp && ! skip_evaluation 821 && ! possible_sum_sign (v1, v2, top->value)) 822 integer_overflow (pfile); 823 } 824 break; 825 case '-': 826 if (!(top->flags & HAVE_VALUE)) 827 { /* Unary '-' */ 828 top->value = - v2; 829 if (!skip_evaluation && (top->value & v2) < 0 && !unsigned2) 830 integer_overflow (pfile); 831 top->unsignedp = unsigned2; 832 top->flags |= HAVE_VALUE; 833 } 834 else 835 { /* Binary '-' */ 836 top->value = v1 - v2; 837 top->unsignedp = unsigned1 || unsigned2; 838 if (! top->unsignedp && ! skip_evaluation 839 && ! possible_sum_sign (top->value, v2, v1)) 840 integer_overflow (pfile); 841 } 842 break; 843 case '*': 844 top->unsignedp = unsigned1 || unsigned2; 845 if (top->unsignedp) 846 top->value = (unsigned HOST_WIDEST_INT) v1 * v2; 847 else if (!skip_evaluation) 848 { 849 top->value = v1 * v2; 850 if (v1 851 && (top->value / v1 != v2 852 || (top->value & v1 & v2) < 0)) 853 integer_overflow (pfile); 854 } 855 break; 856 case '/': 857 if (skip_evaluation) 858 break; 859 if (v2 == 0) 860 { 861 cpp_error (pfile, "division by zero in #if"); 862 v2 = 1; 863 } 864 top->unsignedp = unsigned1 || unsigned2; 865 if (top->unsignedp) 866 top->value = (unsigned HOST_WIDEST_INT) v1 / v2; 867 else 868 { 869 top->value = v1 / v2; 870 if ((top->value & v1 & v2) < 0) 871 integer_overflow (pfile); 872 } 873 break; 874 case '%': 875 if (skip_evaluation) 876 break; 877 if (v2 == 0) 878 { 879 cpp_error (pfile, "division by zero in #if"); 880 v2 = 1; 881 } 882 top->unsignedp = unsigned1 || unsigned2; 883 if (top->unsignedp) 884 top->value = (unsigned HOST_WIDEST_INT) v1 % v2; 885 else 886 top->value = v1 % v2; 887 break; 888 case '!': 889 if (top->flags & HAVE_VALUE) 890 { 891 cpp_error (pfile, "syntax error"); 892 goto syntax_error; 893 } 894 top->value = ! v2; 895 top->unsignedp = 0; 896 top->flags |= HAVE_VALUE; 897 break; 898 case '~': 899 if (top->flags & HAVE_VALUE) 900 { 901 cpp_error (pfile, "syntax error"); 902 goto syntax_error; 903 } 904 top->value = ~ v2; 905 top->unsignedp = unsigned2; 906 top->flags |= HAVE_VALUE; 907 break; 908 case '<': COMPARE(<); break; 909 case '>': COMPARE(>); break; 910 case LEQ: COMPARE(<=); break; 911 case GEQ: COMPARE(>=); break; 912 case EQUAL: 913 top->value = (v1 == v2); 914 top->unsignedp = 0; 915 break; 916 case NOTEQUAL: 917 top->value = (v1 != v2); 918 top->unsignedp = 0; 919 break; 920 case LSH: 921 if (skip_evaluation) 922 break; 923 top->unsignedp = unsigned1; 924 if (v2 < 0 && ! unsigned2) 925 top->value = right_shift (pfile, v1, unsigned1, -v2); 926 else 927 top->value = left_shift (pfile, v1, unsigned1, v2); 928 break; 929 case RSH: 930 if (skip_evaluation) 931 break; 932 top->unsignedp = unsigned1; 933 if (v2 < 0 && ! unsigned2) 934 top->value = left_shift (pfile, v1, unsigned1, -v2); 935 else 936 top->value = right_shift (pfile, v1, unsigned1, v2); 937 break; 938#define LOGICAL(OP) \ 939 top->value = v1 OP v2;\ 940 top->unsignedp = unsigned1 || unsigned2; 941 case '&': LOGICAL(&); break; 942 case '^': LOGICAL(^); break; 943 case '|': LOGICAL(|); break; 944 case ANDAND: 945 top->value = v1 && v2; top->unsignedp = 0; 946 if (!v1) skip_evaluation--; 947 break; 948 case OROR: 949 top->value = v1 || v2; top->unsignedp = 0; 950 if (v1) skip_evaluation--; 951 break; 952 case ',': 953 if (CPP_PEDANTIC (pfile)) 954 cpp_pedwarn (pfile, "comma operator in operand of `#if'"); 955 top->value = v2; 956 top->unsignedp = unsigned2; 957 break; 958 case '(': case '?': 959 cpp_error (pfile, "syntax error in #if"); 960 goto syntax_error; 961 case ':': 962 if (top[0].op != '?') 963 { 964 cpp_error (pfile, 965 "syntax error ':' without preceding '?'"); 966 goto syntax_error; 967 } 968 else if (! (top[1].flags & HAVE_VALUE) 969 || !(top[-1].flags & HAVE_VALUE) 970 || !(top[0].flags & HAVE_VALUE)) 971 { 972 cpp_error (pfile, "bad syntax for ?: operator"); 973 goto syntax_error; 974 } 975 else 976 { 977 top--; 978 if (top->value) skip_evaluation--; 979 top->value = top->value ? v1 : v2; 980 top->unsignedp = unsigned1 || unsigned2; 981 } 982 break; 983 case ')': 984 if ((top[1].flags & HAVE_VALUE) 985 || ! (top[0].flags & HAVE_VALUE) 986 || top[0].op != '(' 987 || (top[-1].flags & HAVE_VALUE)) 988 { 989 cpp_error (pfile, "mismatched parentheses in #if"); 990 goto syntax_error; 991 } 992 else 993 { 994 top--; 995 top->value = v1; 996 top->unsignedp = unsigned1; 997 top->flags |= HAVE_VALUE; 998 } 999 break; 1000 default: 1001 cpp_error (pfile, 1002 (top[1].op >= ' ' && top[1].op <= '~' 1003 ? "unimplemented operator '%c'\n" 1004 : "unimplemented operator '\\%03o'\n"), 1005 top[1].op); 1006 } 1007 } 1008 if (op.op == 0) 1009 { 1010 if (top != stack) 1011 cpp_error (pfile, "internal error in #if expression"); 1012 if (stack != init_stack) 1013 free (stack); 1014 return top->value; 1015 } 1016 top++; 1017 1018 /* Check for and handle stack overflow. */ 1019 if (top == limit) 1020 { 1021 struct operation *new_stack; 1022 int old_size = (char *) limit - (char *) stack; 1023 int new_size = 2 * old_size; 1024 if (stack != init_stack) 1025 new_stack = (struct operation *) xrealloc (stack, new_size); 1026 else 1027 { 1028 new_stack = (struct operation *) xmalloc (new_size); 1029 bcopy ((char *) stack, (char *) new_stack, old_size); 1030 } 1031 stack = new_stack; 1032 top = (struct operation *) ((char *) new_stack + old_size); 1033 limit = (struct operation *) ((char *) new_stack + new_size); 1034 } 1035 1036 top->flags = flags; 1037 top->rprio = rprio; 1038 top->op = op.op; 1039 if ((op.op == OROR && top[-1].value) 1040 || (op.op == ANDAND && !top[-1].value) 1041 || (op.op == '?' && !top[-1].value)) 1042 { 1043 skip_evaluation++; 1044 } 1045 else if (op.op == ':') 1046 { 1047 if (top[-2].value) /* Was condition true? */ 1048 skip_evaluation++; 1049 else 1050 skip_evaluation--; 1051 } 1052 } 1053 syntax_error: 1054 if (stack != init_stack) 1055 free (stack); 1056 skip_rest_of_line (pfile); 1057 return 0; 1058} 1059