1 /* Parse C expressions for cpplib.
2 Copyright (C) 1987, 1992, 1994, 1995, 1997, 1998, 1999, 2000
3 Free Software Foundation.
4 Contributed by Per Bothner, 1994.
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
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.
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, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* Parse a C expression from text in a string */
29 #ifndef MAX_CHAR_TYPE_SIZE
30 #define MAX_CHAR_TYPE_SIZE CHAR_TYPE_SIZE
33 #ifndef MAX_INT_TYPE_SIZE
34 #define MAX_INT_TYPE_SIZE INT_TYPE_SIZE
37 #ifndef MAX_LONG_TYPE_SIZE
38 #define MAX_LONG_TYPE_SIZE LONG_TYPE_SIZE
41 #ifndef MAX_WCHAR_TYPE_SIZE
42 #define MAX_WCHAR_TYPE_SIZE WCHAR_TYPE_SIZE
45 #define MAX_CHAR_TYPE_MASK (MAX_CHAR_TYPE_SIZE < HOST_BITS_PER_WIDEST_INT \
46 ? (~(~(HOST_WIDEST_INT) 0 << MAX_CHAR_TYPE_SIZE)) \
47 : ~ (HOST_WIDEST_INT) 0)
49 #define MAX_WCHAR_TYPE_MASK (MAX_WCHAR_TYPE_SIZE < HOST_BITS_PER_WIDEST_INT \
50 ? ~(~(HOST_WIDEST_INT) 0 << MAX_WCHAR_TYPE_SIZE) \
51 : ~ (HOST_WIDEST_INT) 0)
53 /* Yield nonzero if adding two numbers with A's and B's signs can yield a
54 number with SUM's sign, where A, B, and SUM are all C integers. */
55 #define possible_sum_sign(a, b, sum) ((((a) ^ (b)) | ~ ((a) ^ (sum))) < 0)
57 static void integer_overflow PARAMS ((cpp_reader *));
58 static HOST_WIDEST_INT left_shift PARAMS ((cpp_reader *, HOST_WIDEST_INT,
60 unsigned HOST_WIDEST_INT));
61 static HOST_WIDEST_INT right_shift PARAMS ((cpp_reader *, HOST_WIDEST_INT,
63 unsigned HOST_WIDEST_INT));
64 static struct op parse_number PARAMS ((cpp_reader *, const cpp_token *));
65 static struct op parse_charconst PARAMS ((cpp_reader *, const cpp_token *));
66 static struct op parse_defined PARAMS ((cpp_reader *));
67 static HOST_WIDEST_INT parse_escape PARAMS ((cpp_reader *, const U_CHAR **,
68 const U_CHAR *, HOST_WIDEST_INT));
69 static struct op lex PARAMS ((cpp_reader *, int, cpp_token *));
70 static const unsigned char *op_as_text PARAMS ((cpp_reader *, enum cpp_ttype));
75 U_CHAR prio; /* Priority of op. */
77 U_CHAR unsignedp; /* True if value should be treated as unsigned. */
78 HOST_WIDEST_INT value; /* The value logically "right" of op. */
81 /* There is no "error" token, but we can't get comments in #if, so we can
82 abuse that token type. */
83 #define CPP_ERROR CPP_COMMENT
85 /* With -O2, gcc appears to produce nice code, moving the error
86 message load and subsequent jump completely out of the main path. */
87 #define CPP_ICE(msgid) \
88 do { cpp_ice (pfile, msgid); goto syntax_error; } while(0)
89 #define SYNTAX_ERROR(msgid) \
90 do { cpp_error (pfile, msgid); goto syntax_error; } while(0)
91 #define SYNTAX_ERROR2(msgid, arg) \
92 do { cpp_error (pfile, msgid, arg); goto syntax_error; } while(0)
94 /* Parse and convert an integer for #if. Accepts decimal, hex, or octal
95 with or without size suffixes. */
103 const struct suffix vsuf_1[] = {
104 { "u", 1, 0 }, { "U", 1, 0 },
105 { "l", 0, 1 }, { "L", 0, 1 }
108 const struct suffix vsuf_2[] = {
109 { "ul", 1, 1 }, { "UL", 1, 1 }, { "uL", 1, 1 }, { "Ul", 1, 1 },
110 { "lu", 1, 1 }, { "LU", 1, 1 }, { "Lu", 1, 1 }, { "lU", 1, 1 },
111 { "ll", 0, 2 }, { "LL", 0, 2 }
114 const struct suffix vsuf_3[] = {
115 { "ull", 1, 2 }, { "ULL", 1, 2 }, { "uLL", 1, 2 }, { "Ull", 1, 2 },
116 { "llu", 1, 2 }, { "LLU", 1, 2 }, { "LLu", 1, 2 }, { "llU", 1, 2 }
118 #define Nsuff(tab) (sizeof tab / sizeof (struct suffix))
121 parse_number (pfile, tok)
123 const cpp_token *tok;
126 const U_CHAR *start = tok->val.str.text;
127 const U_CHAR *end = start + tok->val.str.len;
128 const U_CHAR *p = start;
130 unsigned HOST_WIDEST_INT n = 0, nd, MAX_over_base;
133 int digit, largest_digit = 0;
134 const struct suffix *sufftab;
140 if (end - start >= 3 && (p[1] == 'x' || p[1] == 'X'))
152 /* Some buggy compilers (e.g. MPW C) seem to need both casts. */
153 MAX_over_base = (((unsigned HOST_WIDEST_INT) -1)
154 / ((unsigned HOST_WIDEST_INT) base));
160 if (c >= '0' && c <= '9')
162 /* We believe that in all live character sets, a-f are
163 consecutive, and so are A-F. */
164 else if (base == 16 && c >= 'a' && c <= 'f')
165 digit = c - 'a' + 10;
166 else if (base == 16 && c >= 'A' && c <= 'F')
167 digit = c - 'A' + 10;
171 if (largest_digit < digit)
172 largest_digit = digit;
173 nd = n * base + digit;
174 overflow |= MAX_over_base < n || nd < n;
180 /* Check for a floating point constant. Note that float constants
181 with an exponent or suffix but no decimal point are technically
182 invalid (C99 6.4.4.2) but accepted elsewhere. */
183 if ((c == '.' || c == 'F' || c == 'f')
184 || (base == 10 && (c == 'E' || c == 'e')
185 && p+1 < end && (p[1] == '+' || p[1] == '-'))
186 || (base == 16 && (c == 'P' || c == 'p')
187 && p+1 < end && (p[1] == '+' || p[1] == '-')))
188 SYNTAX_ERROR ("floating point numbers are not valid in #if");
190 /* Determine the suffix. l means long, and u means unsigned.
191 See the suffix tables, above. */
194 case 1: sufftab = vsuf_1; nsuff = Nsuff(vsuf_1); break;
195 case 2: sufftab = vsuf_2; nsuff = Nsuff(vsuf_2); break;
196 case 3: sufftab = vsuf_3; nsuff = Nsuff(vsuf_3); break;
197 default: goto invalid_suffix;
200 for (i = 0; i < nsuff; i++)
201 if (memcmp (p, sufftab[i].s, end - p) == 0)
205 op.unsignedp = sufftab[i].u;
207 if (CPP_WTRADITIONAL (pfile) && sufftab[i].u)
208 cpp_warning (pfile, "traditional C rejects the `U' suffix");
209 if (sufftab[i].l == 2 && CPP_OPTION (pfile, pedantic)
210 && ! CPP_OPTION (pfile, c99))
211 cpp_pedwarn (pfile, "too many 'l' suffixes in integer constant");
214 if (base <= largest_digit)
215 cpp_pedwarn (pfile, "integer constant contains digits beyond the radix");
218 cpp_pedwarn (pfile, "integer constant out of range");
220 /* If too big to be signed, consider it unsigned. */
221 else if ((HOST_WIDEST_INT) n < 0 && ! op.unsignedp)
224 cpp_warning (pfile, "integer constant is so large that it is unsigned");
233 cpp_error (pfile, "invalid suffix '%.*s' on integer constant",
240 /* Parse and convert a character constant for #if. Understands backslash
241 escapes (\n, \031) and multibyte characters (if so configured). */
243 parse_charconst (pfile, tok)
245 const cpp_token *tok;
248 HOST_WIDEST_INT result = 0;
251 unsigned int width = MAX_CHAR_TYPE_SIZE, mask = MAX_CHAR_TYPE_MASK;
253 const U_CHAR *ptr = tok->val.str.text;
254 const U_CHAR *end = ptr + tok->val.str.len;
258 if (tok->type == CPP_WCHAR)
259 width = MAX_WCHAR_TYPE_SIZE, mask = MAX_WCHAR_TYPE_MASK;
260 max_chars = MAX_LONG_TYPE_SIZE / width;
266 CPP_ICE ("unescaped ' in character constant");
269 c = parse_escape (pfile, &ptr, end, mask);
270 if (width < HOST_BITS_PER_INT
271 && (unsigned int) c >= (unsigned int)(1 << width))
273 "escape sequence out of range for character");
276 /* Merge character into result; ignore excess chars. */
277 if (++num_chars <= max_chars)
279 if (width < HOST_BITS_PER_INT)
280 result = (result << width) | (c & ((1 << width) - 1));
287 SYNTAX_ERROR ("empty character constant");
288 else if (num_chars > max_chars)
289 SYNTAX_ERROR ("character constant too long");
290 else if (num_chars != 1)
291 cpp_warning (pfile, "multi-character character constant");
293 /* If char type is signed, sign-extend the constant. */
294 num_bits = num_chars * width;
296 if (pfile->spec_nodes.n__CHAR_UNSIGNED__->type == NT_MACRO
297 || ((result >> (num_bits - 1)) & 1) == 0)
298 op.value = result & ((unsigned HOST_WIDEST_INT) ~0
299 >> (HOST_BITS_PER_WIDEST_INT - num_bits));
301 op.value = result | ~((unsigned HOST_WIDEST_INT) ~0
302 >> (HOST_BITS_PER_WIDEST_INT - num_bits));
304 /* This is always a signed type. */
315 parse_defined (pfile)
319 cpp_hashnode *node = 0;
323 /* Don't expand macros. */
324 pfile->state.prevent_expansion++;
326 cpp_get_token (pfile, &token);
327 if (token.type == CPP_OPEN_PAREN)
330 cpp_get_token (pfile, &token);
333 if (token.type == CPP_NAME)
335 node = token.val.node;
338 cpp_get_token (pfile, &token);
339 if (token.type != CPP_CLOSE_PAREN)
341 cpp_error (pfile, "missing ')' after \"defined\"");
347 cpp_error (pfile, "\"defined\" without an identifier");
353 op.value = node->type == NT_MACRO;
357 /* No macros? At top of file? */
358 if (pfile->mi_state == MI_OUTSIDE && pfile->mi_cmacro == 0
359 && pfile->mi_if_not_defined == MI_IND_NOT && pfile->mi_lexed == 1)
361 cpp_start_lookahead (pfile);
362 cpp_get_token (pfile, &token);
363 if (token.type == CPP_EOF)
364 pfile->mi_ind_cmacro = node;
365 cpp_stop_lookahead (pfile, 0);
369 pfile->state.prevent_expansion--;
373 /* Read one token. */
376 lex (pfile, skip_evaluation, token)
383 cpp_get_token (pfile, token);
389 return parse_number (pfile, token);
393 return parse_charconst (pfile, token);
397 SYNTAX_ERROR ("string constants are not valid in #if");
400 SYNTAX_ERROR ("floating point numbers are not valid in #if");
403 if (ISGRAPH (token->val.c))
404 SYNTAX_ERROR2 ("invalid character '%c' in #if", token->val.c);
406 SYNTAX_ERROR2 ("invalid character '\\%03o' in #if", token->val.c);
409 if (token->val.node == pfile->spec_nodes.n_defined)
411 if (pfile->context->prev && CPP_PEDANTIC (pfile))
412 cpp_pedwarn (pfile, "\"defined\" operator appears during macro expansion");
414 return parse_defined (pfile);
416 /* Controlling #if expressions cannot contain identifiers (they
417 could become macros in the future). */
418 pfile->mi_state = MI_FAILED;
424 if (CPP_OPTION (pfile, warn_undef) && !skip_evaluation)
425 cpp_warning (pfile, "\"%s\" is not defined", token->val.node->name);
434 if (_cpp_test_assertion (pfile, &temp))
442 /* We don't worry about its position here. */
443 pfile->mi_if_not_defined = MI_IND_NOT;
447 if ((token->type > CPP_EQ && token->type < CPP_PLUS_EQ)
448 || token->type == CPP_EOF)
454 SYNTAX_ERROR2 ("\"%s\" is not valid in #if expressions",
455 cpp_token_as_text (pfile, token));
463 /* Parse a C escape sequence. STRING_PTR points to a variable
464 containing a pointer to the string to parse. That pointer
465 is updated past the characters we use. The value of the
466 escape sequence is returned.
468 If \ is followed by 000, we return 0 and leave the string pointer
469 after the zeros. A value of 0 does not mean end of string. */
471 static HOST_WIDEST_INT
472 parse_escape (pfile, string_ptr, limit, result_mask)
474 const U_CHAR **string_ptr;
476 HOST_WIDEST_INT result_mask;
478 const U_CHAR *ptr = *string_ptr;
479 /* We know we have at least one following character. */
483 case 'a': c = TARGET_BELL; break;
484 case 'b': c = TARGET_BS; break;
485 case 'f': c = TARGET_FF; break;
486 case 'n': c = TARGET_NEWLINE; break;
487 case 'r': c = TARGET_CR; break;
488 case 't': c = TARGET_TAB; break;
489 case 'v': c = TARGET_VT; break;
492 if (CPP_PEDANTIC (pfile))
493 cpp_pedwarn (pfile, "non-ISO-standard escape sequence, '\\%c'", c);
497 case '0': case '1': case '2': case '3':
498 case '4': case '5': case '6': case '7':
500 unsigned int i = c - '0';
508 if (c < '0' || c > '7')
511 i = (i << 3) + c - '0';
513 if (i != (i & result_mask))
516 cpp_pedwarn (pfile, "octal escape sequence out of range");
524 unsigned int i = 0, overflow = 0;
525 int digits_found = 0, digit;
531 if (c >= '0' && c <= '9')
533 else if (c >= 'a' && c <= 'f')
534 digit = c - 'a' + 10;
535 else if (c >= 'A' && c <= 'F')
536 digit = c - 'A' + 10;
540 overflow |= i ^ (i << 4 >> 4);
541 i = (i << 4) + digit;
545 cpp_error (pfile, "\\x used with no following hex digits");
546 if (overflow | (i != (i & result_mask)))
549 cpp_pedwarn (pfile, "hex escape sequence out of range");
560 integer_overflow (pfile)
563 if (CPP_PEDANTIC (pfile))
564 cpp_pedwarn (pfile, "integer overflow in preprocessor expression");
567 static HOST_WIDEST_INT
568 left_shift (pfile, a, unsignedp, b)
571 unsigned int unsignedp;
572 unsigned HOST_WIDEST_INT b;
574 if (b >= HOST_BITS_PER_WIDEST_INT)
576 if (! unsignedp && a != 0)
577 integer_overflow (pfile);
581 return (unsigned HOST_WIDEST_INT) a << b;
584 HOST_WIDEST_INT l = a << b;
586 integer_overflow (pfile);
591 static HOST_WIDEST_INT
592 right_shift (pfile, a, unsignedp, b)
593 cpp_reader *pfile ATTRIBUTE_UNUSED;
595 unsigned int unsignedp;
596 unsigned HOST_WIDEST_INT b;
598 if (b >= HOST_BITS_PER_WIDEST_INT)
599 return unsignedp ? 0 : a >> (HOST_BITS_PER_WIDEST_INT - 1);
601 return (unsigned HOST_WIDEST_INT) a >> b;
606 /* Operator precedence and flags table.
608 After an operator is returned from the lexer, if it has priority less
609 than or equal to the operator on the top of the stack, we reduce the
610 stack by one operator and repeat the test. Since equal priorities
611 reduce, this is naturally left-associative.
613 We handle right-associative operators by clearing the lower bit of all
614 left-associative operators, and setting it for right-associative ones.
615 After the reduction phase of a new operator, just before it is pushed
616 onto the stack, its RIGHT_ASSOC bit is cleared. The effect is that
617 during the reduction phase, the current right-associative operator has
618 a priority one greater than any other operator of otherwise equal
619 precedence that has been pushed on the top of the stack. This avoids
620 a reduction pass, and effectively makes the logic right-associative.
622 The remaining cases are '(' and ')'. We handle '(' by skipping the
623 reduction phase completely. ')' is given lower priority than
624 everything else, including '(', effectively forcing a reduction of the
625 parenthesised expression. If there is no matching '(', the stack will
626 be reduced all the way to the beginning, exiting the parser in the
627 same way as the ultra-low priority end-of-expression dummy operator.
628 The exit code checks to see if the operator that caused it is ')', and
629 if so outputs an appropriate error message.
631 The parser assumes all shifted operators require a right operand
632 unless the flag NO_R_OPERAND is set, and similarly for NO_L_OPERAND.
633 These semantics are automatically checked, any extra semantics need to
634 be handled with operator-specific code. */
637 #define FLAG_MASK ((1 << FLAG_BITS) - 1)
638 #define PRIO_SHIFT (FLAG_BITS + 1)
639 #define EXTRACT_PRIO(cnst) (cnst >> FLAG_BITS)
640 #define EXTRACT_FLAGS(cnst) (cnst & FLAG_MASK)
643 #define HAVE_VALUE (1 << 0)
644 #define NO_L_OPERAND (1 << 1)
645 #define NO_R_OPERAND (1 << 2)
646 #define SHORT_CIRCUIT (1 << 3)
648 /* Priority and flag combinations. */
649 #define RIGHT_ASSOC (1 << FLAG_BITS)
650 #define FORCE_REDUCE_PRIO (0 << PRIO_SHIFT)
651 #define CLOSE_PAREN_PRIO (1 << PRIO_SHIFT)
652 #define OPEN_PAREN_PRIO ((2 << PRIO_SHIFT) | NO_L_OPERAND)
653 #define COMMA_PRIO (3 << PRIO_SHIFT)
654 #define COND_PRIO ((4 << PRIO_SHIFT) | RIGHT_ASSOC | SHORT_CIRCUIT)
655 #define COLON_PRIO ((5 << PRIO_SHIFT) | SHORT_CIRCUIT)
656 #define OROR_PRIO ((6 << PRIO_SHIFT) | SHORT_CIRCUIT)
657 #define ANDAND_PRIO ((7 << PRIO_SHIFT) | SHORT_CIRCUIT)
658 #define OR_PRIO (8 << PRIO_SHIFT)
659 #define XOR_PRIO (9 << PRIO_SHIFT)
660 #define AND_PRIO (10 << PRIO_SHIFT)
661 #define MINMAX_PRIO (11 << PRIO_SHIFT)
662 #define EQUAL_PRIO (12 << PRIO_SHIFT)
663 #define LESS_PRIO (13 << PRIO_SHIFT)
664 #define SHIFT_PRIO (14 << PRIO_SHIFT)
665 #define PLUS_PRIO (15 << PRIO_SHIFT)
666 #define MUL_PRIO (16 << PRIO_SHIFT)
667 #define UNARY_PRIO ((17 << PRIO_SHIFT) | RIGHT_ASSOC | NO_L_OPERAND)
669 /* Operator to priority map. Must be in the same order as the first
670 N entries of enum cpp_ttype. */
674 /* EQ */ 0, /* dummy entry - can't happen */
675 /* NOT */ UNARY_PRIO,
676 /* GREATER */ LESS_PRIO,
677 /* LESS */ LESS_PRIO,
678 /* PLUS */ UNARY_PRIO, /* note these two can be unary */
679 /* MINUS */ UNARY_PRIO, /* or binary */
686 /* RSHIFT */ SHIFT_PRIO,
687 /* LSHIFT */ SHIFT_PRIO,
688 /* MIN */ MINMAX_PRIO, /* C++ specific */
689 /* MAX */ MINMAX_PRIO, /* extensions */
691 /* COMPL */ UNARY_PRIO,
692 /* AND_AND */ ANDAND_PRIO,
693 /* OR_OR */ OROR_PRIO,
694 /* QUERY */ COND_PRIO,
695 /* COLON */ COLON_PRIO,
696 /* COMMA */ COMMA_PRIO,
697 /* OPEN_PAREN */ OPEN_PAREN_PRIO,
698 /* CLOSE_PAREN */ CLOSE_PAREN_PRIO,
699 /* EQ_EQ */ EQUAL_PRIO,
700 /* NOT_EQ */ EQUAL_PRIO,
701 /* GREATER_EQ */ LESS_PRIO,
702 /* LESS_EQ */ LESS_PRIO
705 #define COMPARE(OP) \
706 top->unsignedp = 0; \
707 top->value = (unsigned1 | unsigned2) \
708 ? (unsigned HOST_WIDEST_INT) v1 OP (unsigned HOST_WIDEST_INT) v2 \
710 #define EQUALITY(OP) \
711 top->value = v1 OP v2; \
713 #define BITWISE(OP) \
714 top->value = v1 OP v2; \
715 top->unsignedp = unsigned1 | unsigned2;
717 top->value = (v1 OP v2) ? v1 : v2; \
718 top->unsignedp = unsigned1 | unsigned2;
720 top->value = OP v2; \
721 top->unsignedp = unsigned2; \
722 top->flags |= HAVE_VALUE;
723 #define SHIFT(PSH, MSH) \
724 if (skip_evaluation) \
726 top->unsignedp = unsigned1; \
727 if (v2 < 0 && ! unsigned2) \
728 top->value = MSH (pfile, v1, unsigned1, -v2); \
730 top->value = PSH (pfile, v1, unsigned1, v2);
732 /* Parse and evaluate a C expression, reading from PFILE.
733 Returns the truth value of the expression. */
736 _cpp_parse_expr (pfile)
739 /* The implementation is an operator precedence parser, i.e. a
740 bottom-up parser, using a stack for not-yet-reduced tokens.
742 The stack base is 'stack', and the current stack pointer is 'top'.
743 There is a stack element for each operator (only),
744 and the most recently pushed operator is 'top->op'.
745 An operand (value) is stored in the 'value' field of the stack
746 element of the operator that precedes it.
747 In that case the 'flags' field has the HAVE_VALUE flag set. */
749 #define INIT_STACK_SIZE 20
750 struct op init_stack[INIT_STACK_SIZE];
751 struct op *stack = init_stack;
752 struct op *limit = stack + INIT_STACK_SIZE;
754 register struct op *top = stack + 1;
755 int skip_evaluation = 0;
758 /* Set up detection of #if ! defined(). */
760 pfile->mi_if_not_defined = MI_IND_NONE;
762 /* We've finished when we try to reduce this. */
764 /* Nifty way to catch missing '('. */
765 top->prio = EXTRACT_PRIO(CLOSE_PAREN_PRIO);
766 /* Avoid missing right operand checks. */
767 top->flags = NO_R_OPERAND;
776 op = lex (pfile, skip_evaluation, &token);
779 /* If the token is an operand, push its value and get next
780 token. If it is an operator, get its priority and flags, and
781 try to reduce the expression on the stack. */
788 /* Push a value onto the stack. */
789 if (top->flags & HAVE_VALUE)
790 SYNTAX_ERROR ("missing binary operator");
791 top->value = op.value;
792 top->unsignedp = op.unsignedp;
793 top->flags |= HAVE_VALUE;
796 case CPP_EOF: prio = FORCE_REDUCE_PRIO; break;
798 case CPP_MINUS: prio = PLUS_PRIO; if (top->flags & HAVE_VALUE) break;
799 /* else unary; fall through */
800 default: prio = op_to_prio[op.op]; break;
803 /* Separate the operator's code into priority and flags. */
804 flags = EXTRACT_FLAGS(prio);
805 prio = EXTRACT_PRIO(prio);
806 if (prio == EXTRACT_PRIO(OPEN_PAREN_PRIO))
809 /* Check for reductions. Then push the operator. */
810 while (prio <= top->prio)
812 HOST_WIDEST_INT v1, v2;
813 unsigned int unsigned1, unsigned2;
815 /* Most operators that can appear on the stack require a
816 right operand. Check this before trying to reduce. */
817 if ((top->flags & (HAVE_VALUE | NO_R_OPERAND)) == 0)
819 if (top->op == CPP_OPEN_PAREN)
820 SYNTAX_ERROR ("void expression between '(' and ')'");
822 SYNTAX_ERROR2 ("operator '%s' has no right operand",
823 op_as_text (pfile, top->op));
826 unsigned2 = top->unsignedp, v2 = top->value;
828 unsigned1 = top->unsignedp, v1 = top->value;
830 /* Now set top->value = (top[1].op)(v1, v2); */
834 cpp_ice (pfile, "impossible operator '%s'",
835 op_as_text (pfile, top[1].op));
838 case CPP_NOT: UNARY(!); break;
839 case CPP_COMPL: UNARY(~); break;
840 case CPP_LESS: COMPARE(<); break;
841 case CPP_GREATER: COMPARE(>); break;
842 case CPP_LESS_EQ: COMPARE(<=); break;
843 case CPP_GREATER_EQ: COMPARE(>=); break;
844 case CPP_EQ_EQ: EQUALITY(==); break;
845 case CPP_NOT_EQ: EQUALITY(!=); break;
846 case CPP_AND: BITWISE(&); break;
847 case CPP_XOR: BITWISE(^); break;
848 case CPP_OR: BITWISE(|); break;
849 case CPP_LSHIFT: SHIFT(left_shift, right_shift); break;
850 case CPP_RSHIFT: SHIFT(right_shift, left_shift); break;
851 case CPP_MIN: MINMAX(<); break;
852 case CPP_MAX: MINMAX(>); break;
855 if (!(top->flags & HAVE_VALUE))
857 /* Can't use UNARY(+) because K+R C did not have unary
858 plus. Can't use UNARY() because some compilers object
859 to the empty argument. */
861 top->unsignedp = unsigned2;
862 top->flags |= HAVE_VALUE;
864 if (CPP_WTRADITIONAL (pfile))
866 "traditional C rejects the unary plus operator");
870 top->value = v1 + v2;
871 top->unsignedp = unsigned1 | unsigned2;
872 if (! top->unsignedp && ! skip_evaluation
873 && ! possible_sum_sign (v1, v2, top->value))
874 integer_overflow (pfile);
878 if (!(top->flags & HAVE_VALUE))
881 if (!skip_evaluation && (top->value & v2) < 0 && !unsigned2)
882 integer_overflow (pfile);
886 top->value = v1 - v2;
887 top->unsignedp = unsigned1 | unsigned2;
888 if (! top->unsignedp && ! skip_evaluation
889 && ! possible_sum_sign (top->value, v2, v1))
890 integer_overflow (pfile);
894 top->unsignedp = unsigned1 | unsigned2;
896 top->value = (unsigned HOST_WIDEST_INT) v1 * v2;
897 else if (!skip_evaluation)
899 top->value = v1 * v2;
900 if (v1 && (top->value / v1 != v2
901 || (top->value & v1 & v2) < 0))
902 integer_overflow (pfile);
910 SYNTAX_ERROR ("division by zero in #if");
911 top->unsignedp = unsigned1 | unsigned2;
912 if (top[1].op == CPP_DIV)
915 top->value = (unsigned HOST_WIDEST_INT) v1 / v2;
918 top->value = v1 / v2;
919 if ((top->value & v1 & v2) < 0)
920 integer_overflow (pfile);
926 top->value = (unsigned HOST_WIDEST_INT) v1 % v2;
928 top->value = v1 % v2;
933 top->value = v1 || v2;
935 if (v1) skip_evaluation--;
938 top->value = v1 && v2;
940 if (!v1) skip_evaluation--;
943 if (CPP_PEDANTIC (pfile))
944 cpp_pedwarn (pfile, "comma operator in operand of #if");
946 top->unsignedp = unsigned2;
949 SYNTAX_ERROR ("syntax error '?' without following ':'");
951 if (top[0].op != CPP_QUERY)
952 SYNTAX_ERROR ("syntax error ':' without preceding '?'");
954 if (top->value) skip_evaluation--;
955 top->value = top->value ? v1 : v2;
956 top->unsignedp = unsigned1 | unsigned2;
959 if (op.op != CPP_CLOSE_PAREN)
960 SYNTAX_ERROR ("missing ')' in expression");
962 op.unsignedp = unsigned2;
965 /* Reducing this dummy operator indicates we've finished. */
966 if (op.op == CPP_CLOSE_PAREN)
967 SYNTAX_ERROR ("missing '(' in expression");
972 /* Handle short-circuit evaluations. */
973 if (flags & SHORT_CIRCUIT)
976 case CPP_OR_OR: if (top->value) skip_evaluation++; break;
978 case CPP_QUERY: if (!top->value) skip_evaluation++; break;
980 if (top[-1].value) /* Was '?' condition true? */
989 /* Check we have a left operand iff we need one. */
990 if (flags & NO_L_OPERAND)
992 if (top->flags & HAVE_VALUE)
993 SYNTAX_ERROR2 ("missing binary operator before '%s'",
994 op_as_text (pfile, top->op));
998 if (!(top->flags & HAVE_VALUE))
999 SYNTAX_ERROR2 ("operator '%s' has no left operand",
1000 op_as_text (pfile, top->op));
1003 /* Check for and handle stack overflow. */
1007 struct op *new_stack;
1008 int old_size = (char *) limit - (char *) stack;
1009 int new_size = 2 * old_size;
1010 if (stack != init_stack)
1011 new_stack = (struct op *) xrealloc (stack, new_size);
1014 new_stack = (struct op *) xmalloc (new_size);
1015 memcpy (new_stack, stack, old_size);
1018 top = (struct op *) ((char *) new_stack + old_size);
1019 limit = (struct op *) ((char *) new_stack + new_size);
1023 top->prio = prio & ~EXTRACT_PRIO(RIGHT_ASSOC);
1028 result = (top[1].value != 0);
1030 CPP_ICE ("unbalanced stack in #if");
1031 else if (!(top[1].flags & HAVE_VALUE))
1033 SYNTAX_ERROR ("#if with no expression");
1035 result = 0; /* Return 0 on syntax error. */
1038 /* Free dynamic stack if we allocated one. */
1039 if (stack != init_stack)
1044 static const unsigned char *
1045 op_as_text (pfile, op)
1053 return cpp_token_as_text (pfile, &token);