1 /* Parse C expressions for cpplib.
2 Copyright (C) 1987, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2001,
3 2002 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. */
26 /* Yield nonzero if adding two numbers with A's and B's signs can yield a
27 number with SUM's sign, where A, B, and SUM are all C integers. */
28 #define possible_sum_sign(a, b, sum) ((((a) ^ (b)) | ~ ((a) ^ (sum))) < 0)
30 static void integer_overflow
PARAMS ((cpp_reader
*));
31 static HOST_WIDEST_INT left_shift
PARAMS ((cpp_reader
*, HOST_WIDEST_INT
,
33 unsigned HOST_WIDEST_INT
));
34 static HOST_WIDEST_INT right_shift
PARAMS ((cpp_reader
*, HOST_WIDEST_INT
,
36 unsigned HOST_WIDEST_INT
));
37 static struct op parse_number
PARAMS ((cpp_reader
*, const cpp_token
*));
38 static struct op parse_defined
PARAMS ((cpp_reader
*));
39 static struct op lex
PARAMS ((cpp_reader
*, int));
40 static const unsigned char *op_as_text
PARAMS ((cpp_reader
*, enum cpp_ttype
));
45 U_CHAR prio
; /* Priority of op. */
47 U_CHAR unsignedp
; /* True if value should be treated as unsigned. */
48 HOST_WIDEST_INT value
; /* The value logically "right" of op. */
51 /* There is no "error" token, but we can't get comments in #if, so we can
52 abuse that token type. */
53 #define CPP_ERROR CPP_COMMENT
55 /* With -O2, gcc appears to produce nice code, moving the error
56 message load and subsequent jump completely out of the main path. */
57 #define CPP_ICE(msgid) \
58 do { cpp_ice (pfile, msgid); goto syntax_error; } while(0)
59 #define SYNTAX_ERROR(msgid) \
60 do { cpp_error (pfile, msgid); goto syntax_error; } while(0)
61 #define SYNTAX_ERROR2(msgid, arg) \
62 do { cpp_error (pfile, msgid, arg); goto syntax_error; } while(0)
66 const unsigned char s
[4];
67 const unsigned char u
;
68 const unsigned char l
;
71 static const struct suffix vsuf_1
[] = {
72 { "u", 1, 0 }, { "U", 1, 0 },
73 { "l", 0, 1 }, { "L", 0, 1 }
76 static const struct suffix vsuf_2
[] = {
77 { "ul", 1, 1 }, { "UL", 1, 1 }, { "uL", 1, 1 }, { "Ul", 1, 1 },
78 { "lu", 1, 1 }, { "LU", 1, 1 }, { "Lu", 1, 1 }, { "lU", 1, 1 },
79 { "ll", 0, 2 }, { "LL", 0, 2 }
82 static const struct suffix vsuf_3
[] = {
83 { "ull", 1, 2 }, { "ULL", 1, 2 }, { "uLL", 1, 2 }, { "Ull", 1, 2 },
84 { "llu", 1, 2 }, { "LLU", 1, 2 }, { "LLu", 1, 2 }, { "llU", 1, 2 }
86 #define Nsuff(tab) (sizeof tab / sizeof (struct suffix))
88 /* Parse and convert what is presumably an integer in TOK. Accepts
89 decimal, hex, or octal with or without size suffixes. Returned op
90 is CPP_ERROR on error, otherwise it is a CPP_NUMBER. */
92 parse_number (pfile
, tok
)
97 const U_CHAR
*start
= tok
->val
.str
.text
;
98 const U_CHAR
*end
= start
+ tok
->val
.str
.len
;
99 const U_CHAR
*p
= start
;
101 unsigned HOST_WIDEST_INT n
= 0, nd
, MAX_over_base
;
104 int digit
, largest_digit
= 0;
105 const struct suffix
*sufftab
;
111 if (end
- start
>= 3 && (p
[1] == 'x' || p
[1] == 'X'))
123 /* Some buggy compilers (e.g. MPW C) seem to need both casts. */
124 MAX_over_base
= (((unsigned HOST_WIDEST_INT
) -1)
125 / ((unsigned HOST_WIDEST_INT
) base
));
132 || (base
== 16 && ISXDIGIT (c
)))
133 digit
= hex_value (c
);
137 if (largest_digit
< digit
)
138 largest_digit
= digit
;
139 nd
= n
* base
+ digit
;
140 overflow
|= MAX_over_base
< n
|| nd
< n
;
146 /* Check for a floating point constant. Note that float constants
147 with an exponent or suffix but no decimal point are technically
148 invalid (C99 6.4.4.2) but accepted elsewhere. */
149 if ((c
== '.' || c
== 'F' || c
== 'f')
150 || (base
== 10 && (c
== 'E' || c
== 'e')
151 && p
+1 < end
&& (p
[1] == '+' || p
[1] == '-'))
152 || (base
== 16 && (c
== 'P' || c
== 'p')
153 && p
+1 < end
&& (p
[1] == '+' || p
[1] == '-')))
154 SYNTAX_ERROR ("floating point numbers are not valid in #if");
156 /* Determine the suffix. l means long, and u means unsigned.
157 See the suffix tables, above. */
160 case 1: sufftab
= vsuf_1
; nsuff
= Nsuff(vsuf_1
); break;
161 case 2: sufftab
= vsuf_2
; nsuff
= Nsuff(vsuf_2
); break;
162 case 3: sufftab
= vsuf_3
; nsuff
= Nsuff(vsuf_3
); break;
163 default: goto invalid_suffix
;
166 for (i
= 0; i
< nsuff
; i
++)
167 if (memcmp (p
, sufftab
[i
].s
, end
- p
) == 0)
171 op
.unsignedp
= sufftab
[i
].u
;
173 if (CPP_WTRADITIONAL (pfile
)
175 && ! cpp_sys_macro_p (pfile
))
176 cpp_warning (pfile
, "traditional C rejects the `U' suffix");
177 if (sufftab
[i
].l
== 2 && CPP_OPTION (pfile
, pedantic
)
178 && ! CPP_OPTION (pfile
, c99
))
179 cpp_pedwarn (pfile
, "too many 'l' suffixes in integer constant");
182 if (base
<= largest_digit
)
183 cpp_pedwarn (pfile
, "integer constant contains digits beyond the radix");
186 cpp_pedwarn (pfile
, "integer constant out of range");
188 /* If too big to be signed, consider it unsigned. */
189 else if ((HOST_WIDEST_INT
) n
< 0 && ! op
.unsignedp
)
192 cpp_warning (pfile
, "integer constant is so large that it is unsigned");
201 cpp_error (pfile
, "invalid suffix '%.*s' on integer constant",
208 /* Handle meeting "defined" in a preprocessor expression. */
210 parse_defined (pfile
)
214 cpp_hashnode
*node
= 0;
215 const cpp_token
*token
;
217 cpp_context
*initial_context
= pfile
->context
;
219 /* Don't expand macros. */
220 pfile
->state
.prevent_expansion
++;
222 token
= cpp_get_token (pfile
);
223 if (token
->type
== CPP_OPEN_PAREN
)
226 token
= cpp_get_token (pfile
);
229 if (token
->type
== CPP_NAME
)
231 node
= token
->val
.node
;
232 if (paren
&& cpp_get_token (pfile
)->type
!= CPP_CLOSE_PAREN
)
234 cpp_error (pfile
, "missing ')' after \"defined\"");
240 cpp_error (pfile
, "operator \"defined\" requires an identifier");
241 if (token
->flags
& NAMED_OP
)
246 op
.type
= token
->type
;
248 "(\"%s\" is an alternative token for \"%s\" in C++)",
249 cpp_token_as_text (pfile
, token
),
250 cpp_token_as_text (pfile
, &op
));
258 if (pfile
->context
!= initial_context
)
259 cpp_warning (pfile
, "this use of \"defined\" may not be portable");
261 op
.value
= node
->type
== NT_MACRO
;
265 /* A possible controlling macro of the form #if !defined ().
266 _cpp_parse_expr checks there was no other junk on the line. */
267 pfile
->mi_ind_cmacro
= node
;
270 pfile
->state
.prevent_expansion
--;
274 /* Read a token. The returned type is CPP_NUMBER for a valid number
275 (an interpreted preprocessing number or character constant, or the
276 result of the "defined" or "#" operators), CPP_ERROR on error,
277 CPP_EOF, or the type of an operator token. */
279 lex (pfile
, skip_evaluation
)
284 const cpp_token
*token
= cpp_get_token (pfile
);
289 return parse_number (pfile
, token
);
294 unsigned int chars_seen
;
296 if (token
->type
== CPP_CHAR
)
299 op
.unsignedp
= WCHAR_UNSIGNED
;
301 op
.value
= cpp_interpret_charconst (pfile
, token
, 1, 0, &chars_seen
);
307 SYNTAX_ERROR ("string constants are not valid in #if");
310 if (ISGRAPH (token
->val
.c
))
311 SYNTAX_ERROR2 ("invalid character '%c' in #if", token
->val
.c
);
313 SYNTAX_ERROR2 ("invalid character '\\%03o' in #if", token
->val
.c
);
316 if (token
->val
.node
== pfile
->spec_nodes
.n_defined
)
317 return parse_defined (pfile
);
318 else if (CPP_OPTION (pfile
, cplusplus
)
319 && (token
->val
.node
== pfile
->spec_nodes
.n_true
320 || token
->val
.node
== pfile
->spec_nodes
.n_false
))
324 op
.value
= (token
->val
.node
== pfile
->spec_nodes
.n_true
);
326 /* Warn about use of true or false in #if when pedantic
327 and stdbool.h has not been included. */
328 if (CPP_PEDANTIC (pfile
)
329 && ! cpp_defined (pfile
, DSC("__bool_true_false_are_defined")))
330 cpp_pedwarn (pfile
, "ISO C++ does not permit \"%s\" in #if",
331 NODE_NAME (token
->val
.node
));
340 if (CPP_OPTION (pfile
, warn_undef
) && !skip_evaluation
)
341 cpp_warning (pfile
, "\"%s\" is not defined",
342 NODE_NAME (token
->val
.node
));
351 if (_cpp_test_assertion (pfile
, &temp
))
359 if (((int) token
->type
> (int) CPP_EQ
360 && (int) token
->type
< (int) CPP_PLUS_EQ
)
361 || token
->type
== CPP_EOF
)
367 SYNTAX_ERROR2 ("\"%s\" is not valid in #if expressions",
368 cpp_token_as_text (pfile
, token
));
376 /* Warn if appropriate on overflow. */
378 integer_overflow (pfile
)
381 if (CPP_PEDANTIC (pfile
))
382 cpp_pedwarn (pfile
, "integer overflow in preprocessor expression");
385 /* Handle shifting A left by B bits. UNSIGNEDP is non-zero if A is
387 static HOST_WIDEST_INT
388 left_shift (pfile
, a
, unsignedp
, b
)
391 unsigned int unsignedp
;
392 unsigned HOST_WIDEST_INT b
;
394 if (b
>= HOST_BITS_PER_WIDEST_INT
)
396 if (! unsignedp
&& a
!= 0)
397 integer_overflow (pfile
);
401 return (unsigned HOST_WIDEST_INT
) a
<< b
;
404 HOST_WIDEST_INT l
= a
<< b
;
406 integer_overflow (pfile
);
411 /* Handle shifting A right by B bits. UNSIGNEDP is non-zero if A is
413 static HOST_WIDEST_INT
414 right_shift (pfile
, a
, unsignedp
, b
)
415 cpp_reader
*pfile ATTRIBUTE_UNUSED
;
417 unsigned int unsignedp
;
418 unsigned HOST_WIDEST_INT b
;
420 if (b
>= HOST_BITS_PER_WIDEST_INT
)
421 return unsignedp
? 0 : a
>> (HOST_BITS_PER_WIDEST_INT
- 1);
423 return (unsigned HOST_WIDEST_INT
) a
>> b
;
428 /* Operator precedence and flags table.
430 After an operator is returned from the lexer, if it has priority less
431 than or equal to the operator on the top of the stack, we reduce the
432 stack by one operator and repeat the test. Since equal priorities
433 reduce, this is naturally left-associative.
435 We handle right-associative operators by clearing the lower bit of all
436 left-associative operators, and setting it for right-associative ones.
437 After the reduction phase of a new operator, just before it is pushed
438 onto the stack, its RIGHT_ASSOC bit is cleared. The effect is that
439 during the reduction phase, the current right-associative operator has
440 a priority one greater than any other operator of otherwise equal
441 precedence that has been pushed on the top of the stack. This avoids
442 a reduction pass, and effectively makes the logic right-associative.
444 The remaining cases are '(' and ')'. We handle '(' by skipping the
445 reduction phase completely. ')' is given lower priority than
446 everything else, including '(', effectively forcing a reduction of the
447 parenthesised expression. If there is no matching '(', the stack will
448 be reduced all the way to the beginning, exiting the parser in the
449 same way as the ultra-low priority end-of-expression dummy operator.
450 The exit code checks to see if the operator that caused it is ')', and
451 if so outputs an appropriate error message.
453 The parser assumes all shifted operators require a right operand
454 unless the flag NO_R_OPERAND is set, and similarly for NO_L_OPERAND.
455 These semantics are automatically checked, any extra semantics need to
456 be handled with operator-specific code. */
459 #define FLAG_MASK ((1 << FLAG_BITS) - 1)
460 #define PRIO_SHIFT (FLAG_BITS + 1)
461 #define EXTRACT_PRIO(CNST) ((CNST) >> FLAG_BITS)
462 #define EXTRACT_FLAGS(CNST) ((CNST) & FLAG_MASK)
465 #define HAVE_VALUE (1 << 0)
466 #define NO_L_OPERAND (1 << 1)
467 #define NO_R_OPERAND (1 << 2)
468 #define SHORT_CIRCUIT (1 << 3)
470 /* Priority and flag combinations. */
471 #define RIGHT_ASSOC (1 << FLAG_BITS)
472 #define FORCE_REDUCE_PRIO (0 << PRIO_SHIFT)
473 #define CLOSE_PAREN_PRIO (1 << PRIO_SHIFT)
474 #define OPEN_PAREN_PRIO ((2 << PRIO_SHIFT) | NO_L_OPERAND)
475 #define COMMA_PRIO (3 << PRIO_SHIFT)
476 #define COND_PRIO ((4 << PRIO_SHIFT) | RIGHT_ASSOC | SHORT_CIRCUIT)
477 #define COLON_PRIO ((5 << PRIO_SHIFT) | SHORT_CIRCUIT)
478 #define OROR_PRIO ((6 << PRIO_SHIFT) | SHORT_CIRCUIT)
479 #define ANDAND_PRIO ((7 << PRIO_SHIFT) | SHORT_CIRCUIT)
480 #define OR_PRIO (8 << PRIO_SHIFT)
481 #define XOR_PRIO (9 << PRIO_SHIFT)
482 #define AND_PRIO (10 << PRIO_SHIFT)
483 #define MINMAX_PRIO (11 << PRIO_SHIFT)
484 #define EQUAL_PRIO (12 << PRIO_SHIFT)
485 #define LESS_PRIO (13 << PRIO_SHIFT)
486 #define SHIFT_PRIO (14 << PRIO_SHIFT)
487 #define PLUS_PRIO (15 << PRIO_SHIFT)
488 #define MUL_PRIO (16 << PRIO_SHIFT)
489 #define UNARY_PRIO ((17 << PRIO_SHIFT) | RIGHT_ASSOC | NO_L_OPERAND)
491 /* Operator to priority map. Must be in the same order as the first
492 N entries of enum cpp_ttype. */
496 /* EQ */ 0, /* dummy entry - can't happen */
497 /* NOT */ UNARY_PRIO
,
498 /* GREATER */ LESS_PRIO
,
499 /* LESS */ LESS_PRIO
,
500 /* PLUS */ UNARY_PRIO
, /* note these two can be unary */
501 /* MINUS */ UNARY_PRIO
, /* or binary */
508 /* RSHIFT */ SHIFT_PRIO
,
509 /* LSHIFT */ SHIFT_PRIO
,
510 /* MIN */ MINMAX_PRIO
, /* C++ specific */
511 /* MAX */ MINMAX_PRIO
, /* extensions */
513 /* COMPL */ UNARY_PRIO
,
514 /* AND_AND */ ANDAND_PRIO
,
515 /* OR_OR */ OROR_PRIO
,
516 /* QUERY */ COND_PRIO
,
517 /* COLON */ COLON_PRIO
,
518 /* COMMA */ COMMA_PRIO
,
519 /* OPEN_PAREN */ OPEN_PAREN_PRIO
,
520 /* CLOSE_PAREN */ CLOSE_PAREN_PRIO
,
521 /* EQ_EQ */ EQUAL_PRIO
,
522 /* NOT_EQ */ EQUAL_PRIO
,
523 /* GREATER_EQ */ LESS_PRIO
,
524 /* LESS_EQ */ LESS_PRIO
527 #define COMPARE(OP) \
528 top->unsignedp = 0; \
529 top->value = (unsigned1 | unsigned2) \
530 ? (unsigned HOST_WIDEST_INT) v1 OP (unsigned HOST_WIDEST_INT) v2 \
532 #define EQUALITY(OP) \
533 top->value = v1 OP v2; \
535 #define BITWISE(OP) \
536 top->value = v1 OP v2; \
537 top->unsignedp = unsigned1 | unsigned2;
539 top->value = (v1 OP v2) ? v1 : v2; \
540 top->unsignedp = unsigned1 | unsigned2;
542 top->value = OP v2; \
543 top->unsignedp = unsigned2; \
544 top->flags |= HAVE_VALUE;
545 #define SHIFT(PSH, MSH) \
546 if (skip_evaluation) \
548 top->unsignedp = unsigned1; \
549 if (v2 < 0 && ! unsigned2) \
550 top->value = MSH (pfile, v1, unsigned1, -v2); \
552 top->value = PSH (pfile, v1, unsigned1, v2);
554 /* Parse and evaluate a C expression, reading from PFILE.
555 Returns the truth value of the expression. */
557 _cpp_parse_expr (pfile
)
560 /* The implementation is an operator precedence parser, i.e. a
561 bottom-up parser, using a stack for not-yet-reduced tokens.
563 The stack base is 'stack', and the current stack pointer is 'top'.
564 There is a stack element for each operator (only),
565 and the most recently pushed operator is 'top->op'.
566 An operand (value) is stored in the 'value' field of the stack
567 element of the operator that precedes it.
568 In that case the 'flags' field has the HAVE_VALUE flag set. */
570 #define INIT_STACK_SIZE 20
571 struct op init_stack
[INIT_STACK_SIZE
];
572 struct op
*stack
= init_stack
;
573 struct op
*limit
= stack
+ INIT_STACK_SIZE
;
574 struct op
*top
= stack
+ 1;
575 int skip_evaluation
= 0;
577 unsigned int lex_count
, saw_leading_not
;
579 /* Set up detection of #if ! defined(). */
580 pfile
->mi_ind_cmacro
= 0;
584 /* We've finished when we try to reduce this. */
586 /* Nifty way to catch missing '('. */
587 top
->prio
= EXTRACT_PRIO(CLOSE_PAREN_PRIO
);
588 /* Avoid missing right operand checks. */
589 top
->flags
= NO_R_OPERAND
;
598 op
= lex (pfile
, skip_evaluation
);
601 /* If the token is an operand, push its value and get next
602 token. If it is an operator, get its priority and flags, and
603 try to reduce the expression on the stack. */
610 /* Push a value onto the stack. */
611 if (top
->flags
& HAVE_VALUE
)
612 SYNTAX_ERROR ("missing binary operator");
613 top
->value
= op
.value
;
614 top
->unsignedp
= op
.unsignedp
;
615 top
->flags
|= HAVE_VALUE
;
618 case CPP_EOF
: prio
= FORCE_REDUCE_PRIO
; break;
621 saw_leading_not
= lex_count
== 1;
622 prio
= op_to_prio
[op
.op
];
625 case CPP_MINUS
: prio
= PLUS_PRIO
; if (top
->flags
& HAVE_VALUE
) break;
626 /* else unary; fall through */
627 default: prio
= op_to_prio
[op
.op
]; break;
630 /* Separate the operator's code into priority and flags. */
631 flags
= EXTRACT_FLAGS(prio
);
632 prio
= EXTRACT_PRIO(prio
);
633 if (prio
== EXTRACT_PRIO(OPEN_PAREN_PRIO
))
636 /* Check for reductions. Then push the operator. */
637 while (prio
<= top
->prio
)
639 HOST_WIDEST_INT v1
, v2
;
640 unsigned int unsigned1
, unsigned2
;
642 /* Most operators that can appear on the stack require a
643 right operand. Check this before trying to reduce. */
644 if ((top
->flags
& (HAVE_VALUE
| NO_R_OPERAND
)) == 0)
646 if (top
->op
== CPP_OPEN_PAREN
)
647 SYNTAX_ERROR ("void expression between '(' and ')'");
649 SYNTAX_ERROR2 ("operator '%s' has no right operand",
650 op_as_text (pfile
, top
->op
));
653 unsigned2
= top
->unsignedp
, v2
= top
->value
;
655 unsigned1
= top
->unsignedp
, v1
= top
->value
;
657 /* Now set top->value = (top[1].op)(v1, v2); */
661 cpp_ice (pfile
, "impossible operator '%s'",
662 op_as_text (pfile
, top
[1].op
));
665 case CPP_NOT
: UNARY(!); break;
666 case CPP_COMPL
: UNARY(~); break;
667 case CPP_LESS
: COMPARE(<); break;
668 case CPP_GREATER
: COMPARE(>); break;
669 case CPP_LESS_EQ
: COMPARE(<=); break;
670 case CPP_GREATER_EQ
: COMPARE(>=); break;
671 case CPP_EQ_EQ
: EQUALITY(==); break;
672 case CPP_NOT_EQ
: EQUALITY(!=); break;
673 case CPP_AND
: BITWISE(&); break;
674 case CPP_XOR
: BITWISE(^); break;
675 case CPP_OR
: BITWISE(|); break;
676 case CPP_LSHIFT
: SHIFT(left_shift
, right_shift
); break;
677 case CPP_RSHIFT
: SHIFT(right_shift
, left_shift
); break;
678 case CPP_MIN
: MINMAX(<); break;
679 case CPP_MAX
: MINMAX(>); break;
682 if (!(top
->flags
& HAVE_VALUE
))
684 /* Can't use UNARY(+) because K+R C did not have unary
685 plus. Can't use UNARY() because some compilers object
686 to the empty argument. */
688 top
->unsignedp
= unsigned2
;
689 top
->flags
|= HAVE_VALUE
;
691 if (CPP_WTRADITIONAL (pfile
))
693 "traditional C rejects the unary plus operator");
697 top
->value
= v1
+ v2
;
698 top
->unsignedp
= unsigned1
| unsigned2
;
699 if (! top
->unsignedp
&& ! skip_evaluation
700 && ! possible_sum_sign (v1
, v2
, top
->value
))
701 integer_overflow (pfile
);
705 if (!(top
->flags
& HAVE_VALUE
))
708 if (!skip_evaluation
&& (top
->value
& v2
) < 0 && !unsigned2
)
709 integer_overflow (pfile
);
713 top
->value
= v1
- v2
;
714 top
->unsignedp
= unsigned1
| unsigned2
;
715 if (! top
->unsignedp
&& ! skip_evaluation
716 && ! possible_sum_sign (top
->value
, v2
, v1
))
717 integer_overflow (pfile
);
721 top
->unsignedp
= unsigned1
| unsigned2
;
723 top
->value
= (unsigned HOST_WIDEST_INT
) v1
* v2
;
724 else if (!skip_evaluation
)
726 top
->value
= v1
* v2
;
727 if (v1
&& (top
->value
/ v1
!= v2
728 || (top
->value
& v1
& v2
) < 0))
729 integer_overflow (pfile
);
737 SYNTAX_ERROR ("division by zero in #if");
738 top
->unsignedp
= unsigned1
| unsigned2
;
739 if (top
[1].op
== CPP_DIV
)
742 top
->value
= (unsigned HOST_WIDEST_INT
) v1
/ v2
;
745 top
->value
= v1
/ v2
;
746 if ((top
->value
& v1
& v2
) < 0)
747 integer_overflow (pfile
);
753 top
->value
= (unsigned HOST_WIDEST_INT
) v1
% v2
;
755 top
->value
= v1
% v2
;
760 top
->value
= v1
|| v2
;
762 if (v1
) skip_evaluation
--;
765 top
->value
= v1
&& v2
;
767 if (!v1
) skip_evaluation
--;
770 if (CPP_PEDANTIC (pfile
))
771 cpp_pedwarn (pfile
, "comma operator in operand of #if");
773 top
->unsignedp
= unsigned2
;
776 SYNTAX_ERROR ("syntax error '?' without following ':'");
778 if (top
[0].op
!= CPP_QUERY
)
779 SYNTAX_ERROR ("syntax error ':' without preceding '?'");
781 if (top
->value
) skip_evaluation
--;
782 top
->value
= top
->value
? v1
: v2
;
783 top
->unsignedp
= unsigned1
| unsigned2
;
786 if (op
.op
!= CPP_CLOSE_PAREN
)
787 SYNTAX_ERROR ("missing ')' in expression");
789 op
.unsignedp
= unsigned2
;
792 /* Reducing this dummy operator indicates we've finished. */
793 if (op
.op
== CPP_CLOSE_PAREN
)
794 SYNTAX_ERROR ("missing '(' in expression");
799 /* Handle short-circuit evaluations. */
800 if (flags
& SHORT_CIRCUIT
)
803 case CPP_OR_OR
: if (top
->value
) skip_evaluation
++; break;
805 case CPP_QUERY
: if (!top
->value
) skip_evaluation
++; break;
807 if (top
[-1].value
) /* Was '?' condition true? */
816 /* Check we have a left operand iff we need one. */
817 if (flags
& NO_L_OPERAND
)
819 if (top
->flags
& HAVE_VALUE
)
820 SYNTAX_ERROR2 ("missing binary operator before '%s'",
821 op_as_text (pfile
, op
.op
));
825 if (!(top
->flags
& HAVE_VALUE
))
826 SYNTAX_ERROR2 ("operator '%s' has no left operand",
827 op_as_text (pfile
, op
.op
));
830 /* Check for and handle stack overflow. */
834 struct op
*new_stack
;
835 int old_size
= (char *) limit
- (char *) stack
;
836 int new_size
= 2 * old_size
;
837 if (stack
!= init_stack
)
838 new_stack
= (struct op
*) xrealloc (stack
, new_size
);
841 new_stack
= (struct op
*) xmalloc (new_size
);
842 memcpy (new_stack
, stack
, old_size
);
845 top
= (struct op
*) ((char *) new_stack
+ old_size
);
846 limit
= (struct op
*) ((char *) new_stack
+ new_size
);
850 top
->prio
= prio
& ~EXTRACT_PRIO(RIGHT_ASSOC
);
855 /* The controlling macro expression is only valid if we called lex 3
856 times: <!> <defined expression> and <EOF>. push_conditional ()
857 checks that we are at top-of-file. */
858 if (pfile
->mi_ind_cmacro
&& !(saw_leading_not
&& lex_count
== 3))
859 pfile
->mi_ind_cmacro
= 0;
861 result
= (top
[1].value
!= 0);
864 CPP_ICE ("unbalanced stack in #if");
865 else if (!(top
[1].flags
& HAVE_VALUE
))
867 SYNTAX_ERROR ("#if with no expression");
869 result
= 0; /* Return 0 on syntax error. */
872 /* Free dynamic stack if we allocated one. */
873 if (stack
!= init_stack
)
878 /* Output OP as text for diagnostics. */
879 static const unsigned char *
880 op_as_text (pfile
, op
)
888 return cpp_token_as_text (pfile
, &token
);