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. */
23 #include "coretypes.h"
28 #define PART_PRECISION (sizeof (cpp_num_part) * CHAR_BIT)
29 #define HALF_MASK (~(cpp_num_part) 0 >> (PART_PRECISION / 2))
30 #define LOW_PART(num_part) (num_part & HALF_MASK)
31 #define HIGH_PART(num_part) (num_part >> (PART_PRECISION / 2))
35 const cpp_token *token; /* The token forming op (for diagnostics). */
36 cpp_num value; /* The value logically "right" of op. */
40 /* Some simple utility routines on double integers. */
41 #define num_zerop(num) ((num.low | num.high) == 0)
42 #define num_eq(num1, num2) (num1.low == num2.low && num1.high == num2.high)
43 static bool num_positive (cpp_num, size_t);
44 static bool num_greater_eq (cpp_num, cpp_num, size_t);
45 static cpp_num num_trim (cpp_num, size_t);
46 static cpp_num num_part_mul (cpp_num_part, cpp_num_part);
48 static cpp_num num_unary_op (cpp_reader *, cpp_num, enum cpp_ttype);
49 static cpp_num num_binary_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);
50 static cpp_num num_negate (cpp_num, size_t);
51 static cpp_num num_bitwise_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);
52 static cpp_num num_inequality_op (cpp_reader *, cpp_num, cpp_num,
54 static cpp_num num_equality_op (cpp_reader *, cpp_num, cpp_num,
56 static cpp_num num_mul (cpp_reader *, cpp_num, cpp_num);
57 static cpp_num num_div_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);
58 static cpp_num num_lshift (cpp_num, size_t, size_t);
59 static cpp_num num_rshift (cpp_num, size_t, size_t);
61 static cpp_num append_digit (cpp_num, int, int, size_t);
62 static cpp_num parse_defined (cpp_reader *);
63 static cpp_num eval_token (cpp_reader *, const cpp_token *);
64 static struct op *reduce (cpp_reader *, struct op *, enum cpp_ttype);
65 static unsigned int interpret_float_suffix (const uchar *, size_t);
66 static unsigned int interpret_int_suffix (const uchar *, size_t);
67 static void check_promotion (cpp_reader *, const struct op *);
69 /* Token type abuse to create unary plus and minus operators. */
70 #define CPP_UPLUS (CPP_LAST_CPP_OP + 1)
71 #define CPP_UMINUS (CPP_LAST_CPP_OP + 2)
73 /* With -O2, gcc appears to produce nice code, moving the error
74 message load and subsequent jump completely out of the main path. */
75 #define SYNTAX_ERROR(msgid) \
76 do { cpp_error (pfile, DL_ERROR, msgid); goto syntax_error; } while(0)
77 #define SYNTAX_ERROR2(msgid, arg) \
78 do { cpp_error (pfile, DL_ERROR, msgid, arg); goto syntax_error; } while(0)
80 /* Subroutine of cpp_classify_number. S points to a float suffix of
81 length LEN, possibly zero. Returns 0 for an invalid suffix, or a
82 flag vector describing the suffix. */
84 interpret_float_suffix (const uchar *s, size_t len)
86 size_t f = 0, l = 0, i = 0;
91 case 'f': case 'F': f++; break;
92 case 'l': case 'L': l++; break;
94 case 'j': case 'J': i++; break;
99 if (f + l > 1 || i > 1)
102 return ((i ? CPP_N_IMAGINARY : 0)
104 l ? CPP_N_LARGE : CPP_N_MEDIUM));
107 /* Subroutine of cpp_classify_number. S points to an integer suffix
108 of length LEN, possibly zero. Returns 0 for an invalid suffix, or a
109 flag vector describing the suffix. */
111 interpret_int_suffix (const uchar *s, size_t len)
120 case 'u': case 'U': u++; break;
122 case 'j': case 'J': i++; break;
123 case 'l': case 'L': l++;
124 /* If there are two Ls, they must be adjacent and the same case. */
125 if (l == 2 && s[len] != s[len + 1])
132 if (l > 2 || u > 1 || i > 1)
135 return ((i ? CPP_N_IMAGINARY : 0)
136 | (u ? CPP_N_UNSIGNED : 0)
137 | ((l == 0) ? CPP_N_SMALL
138 : (l == 1) ? CPP_N_MEDIUM : CPP_N_LARGE));
141 /* Categorize numeric constants according to their field (integer,
142 floating point, or invalid), radix (decimal, octal, hexadecimal),
143 and type suffixes. */
145 cpp_classify_number (cpp_reader *pfile, const cpp_token *token)
147 const uchar *str = token->val.str.text;
149 unsigned int max_digit, result, radix;
150 enum {NOT_FLOAT = 0, AFTER_POINT, AFTER_EXPON} float_flag;
152 /* If the lexer has done its job, length one can only be a single
153 digit. Fast-path this very common case. */
154 if (token->val.str.len == 1)
155 return CPP_N_INTEGER | CPP_N_SMALL | CPP_N_DECIMAL;
157 limit = str + token->val.str.len;
158 float_flag = NOT_FLOAT;
162 /* First, interpret the radix. */
168 /* Require at least one hex digit to classify it as hex. */
169 if ((*str == 'x' || *str == 'X')
170 && (str[1] == '.' || ISXDIGIT (str[1])))
177 /* Now scan for a well-formed integer or float. */
180 unsigned int c = *str++;
182 if (ISDIGIT (c) || (ISXDIGIT (c) && radix == 16))
190 if (float_flag == NOT_FLOAT)
191 float_flag = AFTER_POINT;
193 SYNTAX_ERROR ("too many decimal points in number");
195 else if ((radix <= 10 && (c == 'e' || c == 'E'))
196 || (radix == 16 && (c == 'p' || c == 'P')))
198 float_flag = AFTER_EXPON;
203 /* Start of suffix. */
209 if (float_flag != NOT_FLOAT && radix == 8)
212 if (max_digit >= radix)
213 SYNTAX_ERROR2 ("invalid digit \"%c\" in octal constant", '0' + max_digit);
215 if (float_flag != NOT_FLOAT)
217 if (radix == 16 && CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, c99))
218 cpp_error (pfile, DL_PEDWARN,
219 "use of C99 hexadecimal floating constant");
221 if (float_flag == AFTER_EXPON)
223 if (*str == '+' || *str == '-')
226 /* Exponent is decimal, even if string is a hex float. */
228 SYNTAX_ERROR ("exponent has no digits");
232 while (ISDIGIT (*str));
234 else if (radix == 16)
235 SYNTAX_ERROR ("hexadecimal floating constants require an exponent");
237 result = interpret_float_suffix (str, limit - str);
240 cpp_error (pfile, DL_ERROR,
241 "invalid suffix \"%.*s\" on floating constant",
242 (int) (limit - str), str);
243 return CPP_N_INVALID;
246 /* Traditional C didn't accept any floating suffixes. */
248 && CPP_WTRADITIONAL (pfile)
249 && ! cpp_sys_macro_p (pfile))
250 cpp_error (pfile, DL_WARNING,
251 "traditional C rejects the \"%.*s\" suffix",
252 (int) (limit - str), str);
254 result |= CPP_N_FLOATING;
258 result = interpret_int_suffix (str, limit - str);
261 cpp_error (pfile, DL_ERROR,
262 "invalid suffix \"%.*s\" on integer constant",
263 (int) (limit - str), str);
264 return CPP_N_INVALID;
267 /* Traditional C only accepted the 'L' suffix.
268 Suppress warning about 'LL' with -Wno-long-long. */
269 if (CPP_WTRADITIONAL (pfile) && ! cpp_sys_macro_p (pfile))
271 int u_or_i = (result & (CPP_N_UNSIGNED|CPP_N_IMAGINARY));
272 int large = (result & CPP_N_WIDTH) == CPP_N_LARGE;
274 if (u_or_i || (large && CPP_OPTION (pfile, warn_long_long)))
275 cpp_error (pfile, DL_WARNING,
276 "traditional C rejects the \"%.*s\" suffix",
277 (int) (limit - str), str);
280 if ((result & CPP_N_WIDTH) == CPP_N_LARGE
281 && ! CPP_OPTION (pfile, c99)
282 && CPP_OPTION (pfile, warn_long_long))
283 cpp_error (pfile, DL_PEDWARN, "use of C99 long long integer constant");
285 result |= CPP_N_INTEGER;
288 if ((result & CPP_N_IMAGINARY) && CPP_PEDANTIC (pfile))
289 cpp_error (pfile, DL_PEDWARN, "imaginary constants are a GCC extension");
292 result |= CPP_N_DECIMAL;
293 else if (radix == 16)
296 result |= CPP_N_OCTAL;
301 return CPP_N_INVALID;
304 /* cpp_interpret_integer converts an integer constant into a cpp_num,
305 of precision options->precision.
307 We do not provide any interface for decimal->float conversion,
308 because the preprocessor doesn't need it and we don't want to
309 drag in GCC's floating point emulator. */
311 cpp_interpret_integer (cpp_reader *pfile, const cpp_token *token,
314 const uchar *p, *end;
319 result.unsignedp = !!(type & CPP_N_UNSIGNED);
320 result.overflow = false;
322 p = token->val.str.text;
323 end = p + token->val.str.len;
325 /* Common case of a single digit. */
326 if (token->val.str.len == 1)
327 result.low = p[0] - '0';
331 size_t precision = CPP_OPTION (pfile, precision);
332 unsigned int base = 10, c = 0;
333 bool overflow = false;
335 if ((type & CPP_N_RADIX) == CPP_N_OCTAL)
340 else if ((type & CPP_N_RADIX) == CPP_N_HEX)
346 /* We can add a digit to numbers strictly less than this without
347 needing the precision and slowness of double integers. */
348 max = ~(cpp_num_part) 0;
349 if (precision < PART_PRECISION)
350 max >>= PART_PRECISION - precision;
351 max = (max - base + 1) / base + 1;
357 if (ISDIGIT (c) || (base == 16 && ISXDIGIT (c)))
362 /* Strict inequality for when max is set to zero. */
363 if (result.low < max)
364 result.low = result.low * base + c;
367 result = append_digit (result, c, base, precision);
368 overflow |= result.overflow;
374 cpp_error (pfile, DL_PEDWARN,
375 "integer constant is too large for its type");
376 /* If too big to be signed, consider it unsigned. Only warn for
377 decimal numbers. Traditional numbers were always signed (but
378 we still honor an explicit U suffix); but we only have
379 traditional semantics in directives. */
380 else if (!result.unsignedp
381 && !(CPP_OPTION (pfile, traditional)
382 && pfile->state.in_directive)
383 && !num_positive (result, precision))
386 cpp_error (pfile, DL_WARNING,
387 "integer constant is so large that it is unsigned");
388 result.unsignedp = true;
395 /* Append DIGIT to NUM, a number of PRECISION bits being read in base BASE. */
397 append_digit (cpp_num num, int digit, int base, size_t precision)
400 unsigned int shift = 3 + (base == 16);
402 cpp_num_part add_high, add_low;
404 /* Multiply by 8 or 16. Catching this overflow here means we don't
405 need to worry about add_high overflowing. */
406 overflow = !!(num.high >> (PART_PRECISION - shift));
407 result.high = num.high << shift;
408 result.low = num.low << shift;
409 result.high |= num.low >> (PART_PRECISION - shift);
413 add_low = num.low << 1;
414 add_high = (num.high << 1) + (num.low >> (PART_PRECISION - 1));
417 add_high = add_low = 0;
419 if (add_low + digit < add_low)
423 if (result.low + add_low < result.low)
425 if (result.high + add_high < result.high)
428 result.low += add_low;
429 result.high += add_high;
431 /* The above code catches overflow of a cpp_num type. This catches
432 overflow of the (possibly shorter) target precision. */
433 num.low = result.low;
434 num.high = result.high;
435 result = num_trim (result, precision);
436 if (!num_eq (result, num))
439 result.unsignedp = num.unsignedp;
440 result.overflow = overflow;
444 /* Handle meeting "defined" in a preprocessor expression. */
446 parse_defined (cpp_reader *pfile)
450 cpp_hashnode *node = 0;
451 const cpp_token *token;
452 cpp_context *initial_context = pfile->context;
454 /* Don't expand macros. */
455 pfile->state.prevent_expansion++;
457 token = cpp_get_token (pfile);
458 if (token->type == CPP_OPEN_PAREN)
461 token = cpp_get_token (pfile);
464 if (token->type == CPP_NAME)
466 node = token->val.node;
467 if (paren && cpp_get_token (pfile)->type != CPP_CLOSE_PAREN)
469 cpp_error (pfile, DL_ERROR, "missing ')' after \"defined\"");
475 cpp_error (pfile, DL_ERROR,
476 "operator \"defined\" requires an identifier");
477 if (token->flags & NAMED_OP)
482 op.type = token->type;
483 cpp_error (pfile, DL_ERROR,
484 "(\"%s\" is an alternative token for \"%s\" in C++)",
485 cpp_token_as_text (pfile, token),
486 cpp_token_as_text (pfile, &op));
492 if (pfile->context != initial_context)
493 cpp_error (pfile, DL_WARNING,
494 "this use of \"defined\" may not be portable");
496 _cpp_mark_macro_used (node);
498 /* A possible controlling macro of the form #if !defined ().
499 _cpp_parse_expr checks there was no other junk on the line. */
500 pfile->mi_ind_cmacro = node;
503 pfile->state.prevent_expansion--;
505 result.unsignedp = false;
507 result.overflow = false;
508 result.low = node && node->type == NT_MACRO;
512 /* Convert a token into a CPP_NUMBER (an interpreted preprocessing
513 number or character constant, or the result of the "defined" or "#"
516 eval_token (cpp_reader *pfile, const cpp_token *token)
525 temp = cpp_classify_number (pfile, token);
526 switch (temp & CPP_N_CATEGORY)
529 cpp_error (pfile, DL_ERROR,
530 "floating constant in preprocessor expression");
533 if (!(temp & CPP_N_IMAGINARY))
534 return cpp_interpret_integer (pfile, token, temp);
535 cpp_error (pfile, DL_ERROR,
536 "imaginary number in preprocessor expression");
540 /* Error already issued. */
543 result.high = result.low = 0;
549 cppchar_t cc = cpp_interpret_charconst (pfile, token,
554 /* Sign-extend the result if necessary. */
555 if (!unsignedp && (cppchar_signed_t) cc < 0)
557 if (PART_PRECISION > BITS_PER_CPPCHAR_T)
558 result.low |= ~(~(cpp_num_part) 0
559 >> (PART_PRECISION - BITS_PER_CPPCHAR_T));
560 result.high = ~(cpp_num_part) 0;
561 result = num_trim (result, CPP_OPTION (pfile, precision));
567 if (token->val.node == pfile->spec_nodes.n_defined)
568 return parse_defined (pfile);
569 else if (CPP_OPTION (pfile, cplusplus)
570 && (token->val.node == pfile->spec_nodes.n_true
571 || token->val.node == pfile->spec_nodes.n_false))
574 result.low = (token->val.node == pfile->spec_nodes.n_true);
580 if (CPP_OPTION (pfile, warn_undef) && !pfile->state.skip_eval)
581 cpp_error (pfile, DL_WARNING, "\"%s\" is not defined",
582 NODE_NAME (token->val.node));
586 default: /* CPP_HASH */
587 _cpp_test_assertion (pfile, &temp);
592 result.unsignedp = !!unsignedp;
593 result.overflow = false;
597 /* Operator precedence and flags table.
599 After an operator is returned from the lexer, if it has priority less
600 than the operator on the top of the stack, we reduce the stack by one
601 operator and repeat the test. Since equal priorities do not reduce,
602 this is naturally right-associative.
604 We handle left-associative operators by decrementing the priority of
605 just-lexed operators by one, but retaining the priority of operators
606 already on the stack.
608 The remaining cases are '(' and ')'. We handle '(' by skipping the
609 reduction phase completely. ')' is given lower priority than
610 everything else, including '(', effectively forcing a reduction of the
611 parenthesized expression. If there is a matching '(', the routine
612 reduce() exits immediately. If the normal exit route sees a ')', then
613 there cannot have been a matching '(' and an error message is output.
615 The parser assumes all shifted operators require a left operand unless
616 the flag NO_L_OPERAND is set. These semantics are automatic; any
617 extra semantics need to be handled with operator-specific code. */
619 /* Flags. If CHECK_PROMOTION, we warn if the effective sign of an
620 operand changes because of integer promotions. */
621 #define NO_L_OPERAND (1 << 0)
622 #define LEFT_ASSOC (1 << 1)
623 #define CHECK_PROMOTION (1 << 2)
625 /* Operator to priority map. Must be in the same order as the first
626 N entries of enum cpp_ttype. */
627 static const struct operator
633 /* EQ */ {0, 0}, /* Shouldn't happen. */
634 /* NOT */ {16, NO_L_OPERAND},
635 /* GREATER */ {12, LEFT_ASSOC | CHECK_PROMOTION},
636 /* LESS */ {12, LEFT_ASSOC | CHECK_PROMOTION},
637 /* PLUS */ {14, LEFT_ASSOC | CHECK_PROMOTION},
638 /* MINUS */ {14, LEFT_ASSOC | CHECK_PROMOTION},
639 /* MULT */ {15, LEFT_ASSOC | CHECK_PROMOTION},
640 /* DIV */ {15, LEFT_ASSOC | CHECK_PROMOTION},
641 /* MOD */ {15, LEFT_ASSOC | CHECK_PROMOTION},
642 /* AND */ {9, LEFT_ASSOC | CHECK_PROMOTION},
643 /* OR */ {7, LEFT_ASSOC | CHECK_PROMOTION},
644 /* XOR */ {8, LEFT_ASSOC | CHECK_PROMOTION},
645 /* RSHIFT */ {13, LEFT_ASSOC},
646 /* LSHIFT */ {13, LEFT_ASSOC},
648 /* MIN */ {10, LEFT_ASSOC | CHECK_PROMOTION},
649 /* MAX */ {10, LEFT_ASSOC | CHECK_PROMOTION},
651 /* COMPL */ {16, NO_L_OPERAND},
652 /* AND_AND */ {6, LEFT_ASSOC},
653 /* OR_OR */ {5, LEFT_ASSOC},
655 /* COLON */ {4, LEFT_ASSOC | CHECK_PROMOTION},
656 /* COMMA */ {2, LEFT_ASSOC},
657 /* OPEN_PAREN */ {1, NO_L_OPERAND},
658 /* CLOSE_PAREN */ {0, 0},
660 /* EQ_EQ */ {11, LEFT_ASSOC},
661 /* NOT_EQ */ {11, LEFT_ASSOC},
662 /* GREATER_EQ */ {12, LEFT_ASSOC | CHECK_PROMOTION},
663 /* LESS_EQ */ {12, LEFT_ASSOC | CHECK_PROMOTION},
664 /* UPLUS */ {16, NO_L_OPERAND},
665 /* UMINUS */ {16, NO_L_OPERAND}
668 /* Parse and evaluate a C expression, reading from PFILE.
669 Returns the truth value of the expression.
671 The implementation is an operator precedence parser, i.e. a
672 bottom-up parser, using a stack for not-yet-reduced tokens.
674 The stack base is op_stack, and the current stack pointer is 'top'.
675 There is a stack element for each operator (only), and the most
676 recently pushed operator is 'top->op'. An operand (value) is
677 stored in the 'value' field of the stack element of the operator
680 _cpp_parse_expr (cpp_reader *pfile)
682 struct op *top = pfile->op_stack;
683 unsigned int lex_count;
684 bool saw_leading_not, want_value = true;
686 pfile->state.skip_eval = 0;
688 /* Set up detection of #if ! defined(). */
689 pfile->mi_ind_cmacro = 0;
690 saw_leading_not = false;
693 /* Lowest priority operator prevents further reductions. */
701 op.token = cpp_get_token (pfile);
702 op.op = op.token->type;
706 /* These tokens convert into values. */
713 SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
714 cpp_token_as_text (pfile, op.token));
716 top->value = eval_token (pfile, op.token);
720 saw_leading_not = lex_count == 1;
732 if ((int) op.op <= (int) CPP_EQ || (int) op.op >= (int) CPP_PLUS_EQ)
733 SYNTAX_ERROR2 ("token \"%s\" is not valid in preprocessor expressions",
734 cpp_token_as_text (pfile, op.token));
738 /* Check we have a value or operator as appropriate. */
739 if (optab[op.op].flags & NO_L_OPERAND)
742 SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
743 cpp_token_as_text (pfile, op.token));
747 /* Ordering here is subtle and intended to favor the
748 missing parenthesis diagnostics over alternatives. */
749 if (op.op == CPP_CLOSE_PAREN)
751 if (top->op == CPP_OPEN_PAREN)
752 SYNTAX_ERROR ("void expression between '(' and ')'");
754 else if (top->op == CPP_EOF)
755 SYNTAX_ERROR ("#if with no expression");
756 if (top->op != CPP_EOF && top->op != CPP_OPEN_PAREN)
757 SYNTAX_ERROR2 ("operator '%s' has no right operand",
758 cpp_token_as_text (pfile, top->token));
761 top = reduce (pfile, top, op.op);
765 if (op.op == CPP_EOF)
770 case CPP_CLOSE_PAREN:
773 if (!num_zerop (top->value))
774 pfile->state.skip_eval++;
778 if (num_zerop (top->value))
779 pfile->state.skip_eval++;
782 if (top->op != CPP_QUERY)
783 SYNTAX_ERROR (" ':' without preceding '?'");
784 if (!num_zerop (top[-1].value)) /* Was '?' condition true? */
785 pfile->state.skip_eval++;
787 pfile->state.skip_eval--;
794 /* Check for and handle stack overflow. */
795 if (++top == pfile->op_limit)
796 top = _cpp_expand_op_stack (pfile);
799 top->token = op.token;
802 /* The controlling macro expression is only valid if we called lex 3
803 times: <!> <defined expression> and <EOF>. push_conditional ()
804 checks that we are at top-of-file. */
805 if (pfile->mi_ind_cmacro && !(saw_leading_not && lex_count == 3))
806 pfile->mi_ind_cmacro = 0;
808 if (top != pfile->op_stack)
810 cpp_error (pfile, DL_ICE, "unbalanced stack in #if");
812 return false; /* Return false on syntax error. */
815 return !num_zerop (top->value);
818 /* Reduce the operator / value stack if possible, in preparation for
819 pushing operator OP. Returns NULL on error, otherwise the top of
822 reduce (cpp_reader *pfile, struct op *top, enum cpp_ttype op)
826 if (top->op <= CPP_EQ || top->op > CPP_LAST_CPP_OP + 2)
829 cpp_error (pfile, DL_ICE, "impossible operator '%u'", top->op);
833 if (op == CPP_OPEN_PAREN)
836 /* Decrement the priority of left-associative operators to force a
837 reduction with operators of otherwise equal priority. */
838 prio = optab[op].prio - ((optab[op].flags & LEFT_ASSOC) != 0);
839 while (prio < optab[top->op].prio)
841 if (CPP_OPTION (pfile, warn_num_sign_change)
842 && optab[top->op].flags & CHECK_PROMOTION)
843 check_promotion (pfile, top);
851 top[-1].value = num_unary_op (pfile, top->value, top->op);
861 top[-1].value = num_binary_op (pfile, top[-1].value,
862 top->value, top->op);
870 = num_inequality_op (pfile, top[-1].value, top->value, top->op);
876 = num_equality_op (pfile, top[-1].value, top->value, top->op);
883 = num_bitwise_op (pfile, top[-1].value, top->value, top->op);
887 top[-1].value = num_mul (pfile, top[-1].value, top->value);
892 top[-1].value = num_div_op (pfile, top[-1].value,
893 top->value, top->op);
898 if (!num_zerop (top->value))
899 pfile->state.skip_eval--;
900 top->value.low = (!num_zerop (top->value)
901 || !num_zerop (top[1].value));
903 top->value.unsignedp = false;
904 top->value.overflow = false;
909 if (num_zerop (top->value))
910 pfile->state.skip_eval--;
911 top->value.low = (!num_zerop (top->value)
912 && !num_zerop (top[1].value));
914 top->value.unsignedp = false;
915 top->value.overflow = false;
919 if (op != CPP_CLOSE_PAREN)
921 cpp_error (pfile, DL_ERROR, "missing ')' in expression");
925 top->value = top[1].value;
930 if (!num_zerop (top->value))
932 pfile->state.skip_eval--;
933 top->value = top[1].value;
936 top->value = top[2].value;
937 top->value.unsignedp = (top[1].value.unsignedp
938 || top[2].value.unsignedp);
942 cpp_error (pfile, DL_ERROR, "'?' without following ':'");
950 if (top->value.overflow && !pfile->state.skip_eval)
951 cpp_error (pfile, DL_PEDWARN,
952 "integer overflow in preprocessor expression");
955 if (op == CPP_CLOSE_PAREN)
957 cpp_error (pfile, DL_ERROR, "missing '(' in expression");
964 /* Returns the position of the old top of stack after expansion. */
966 _cpp_expand_op_stack (cpp_reader *pfile)
968 size_t old_size = (size_t) (pfile->op_limit - pfile->op_stack);
969 size_t new_size = old_size * 2 + 20;
971 pfile->op_stack = (struct op *) xrealloc (pfile->op_stack,
972 new_size * sizeof (struct op));
973 pfile->op_limit = pfile->op_stack + new_size;
975 return pfile->op_stack + old_size;
978 /* Emits a warning if the effective sign of either operand of OP
979 changes because of integer promotions. */
981 check_promotion (cpp_reader *pfile, const struct op *op)
983 if (op->value.unsignedp == op[-1].value.unsignedp)
986 if (op->value.unsignedp)
988 if (!num_positive (op[-1].value, CPP_OPTION (pfile, precision)))
989 cpp_error (pfile, DL_WARNING,
990 "the left operand of \"%s\" changes sign when promoted",
991 cpp_token_as_text (pfile, op->token));
993 else if (!num_positive (op->value, CPP_OPTION (pfile, precision)))
994 cpp_error (pfile, DL_WARNING,
995 "the right operand of \"%s\" changes sign when promoted",
996 cpp_token_as_text (pfile, op->token));
999 /* Clears the unused high order bits of the number pointed to by PNUM. */
1001 num_trim (cpp_num num, size_t precision)
1003 if (precision > PART_PRECISION)
1005 precision -= PART_PRECISION;
1006 if (precision < PART_PRECISION)
1007 num.high &= ((cpp_num_part) 1 << precision) - 1;
1011 if (precision < PART_PRECISION)
1012 num.low &= ((cpp_num_part) 1 << precision) - 1;
1019 /* True iff A (presumed signed) >= 0. */
1021 num_positive (cpp_num num, size_t precision)
1023 if (precision > PART_PRECISION)
1025 precision -= PART_PRECISION;
1026 return (num.high & (cpp_num_part) 1 << (precision - 1)) == 0;
1029 return (num.low & (cpp_num_part) 1 << (precision - 1)) == 0;
1032 /* Sign extend a number, with PRECISION significant bits and all
1033 others assumed clear, to fill out a cpp_num structure. */
1035 cpp_num_sign_extend (cpp_num num, size_t precision)
1039 if (precision > PART_PRECISION)
1041 precision -= PART_PRECISION;
1042 if (precision < PART_PRECISION
1043 && (num.high & (cpp_num_part) 1 << (precision - 1)))
1044 num.high |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1046 else if (num.low & (cpp_num_part) 1 << (precision - 1))
1048 if (precision < PART_PRECISION)
1049 num.low |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1050 num.high = ~(cpp_num_part) 0;
1057 /* Returns the negative of NUM. */
1059 num_negate (cpp_num num, size_t precision)
1064 num.high = ~num.high;
1068 num = num_trim (num, precision);
1069 num.overflow = (!num.unsignedp && num_eq (num, copy) && !num_zerop (num));
1074 /* Returns true if A >= B. */
1076 num_greater_eq (cpp_num pa, cpp_num pb, size_t precision)
1080 unsignedp = pa.unsignedp || pb.unsignedp;
1084 /* Both numbers have signed type. If they are of different
1085 sign, the answer is the sign of A. */
1086 unsignedp = num_positive (pa, precision);
1088 if (unsignedp != num_positive (pb, precision))
1091 /* Otherwise we can do an unsigned comparison. */
1094 return (pa.high > pb.high) || (pa.high == pb.high && pa.low >= pb.low);
1097 /* Returns LHS OP RHS, where OP is a bit-wise operation. */
1099 num_bitwise_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1100 cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1102 lhs.overflow = false;
1103 lhs.unsignedp = lhs.unsignedp || rhs.unsignedp;
1105 /* As excess precision is zeroed, there is no need to num_trim () as
1106 these operations cannot introduce a set bit there. */
1110 lhs.high &= rhs.high;
1112 else if (op == CPP_OR)
1115 lhs.high |= rhs.high;
1120 lhs.high ^= rhs.high;
1126 /* Returns LHS OP RHS, where OP is an inequality. */
1128 num_inequality_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs,
1131 bool gte = num_greater_eq (lhs, rhs, CPP_OPTION (pfile, precision));
1133 if (op == CPP_GREATER_EQ)
1135 else if (op == CPP_LESS)
1137 else if (op == CPP_GREATER)
1138 lhs.low = gte && !num_eq (lhs, rhs);
1139 else /* CPP_LESS_EQ. */
1140 lhs.low = !gte || num_eq (lhs, rhs);
1143 lhs.overflow = false;
1144 lhs.unsignedp = false;
1148 /* Returns LHS OP RHS, where OP is == or !=. */
1150 num_equality_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1151 cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1153 /* Work around a 3.0.4 bug; see PR 6950. */
1154 bool eq = num_eq (lhs, rhs);
1155 if (op == CPP_NOT_EQ)
1159 lhs.overflow = false;
1160 lhs.unsignedp = false;
1164 /* Shift NUM, of width PRECISION, right by N bits. */
1166 num_rshift (cpp_num num, size_t precision, size_t n)
1168 cpp_num_part sign_mask;
1170 if (num.unsignedp || num_positive (num, precision))
1173 sign_mask = ~(cpp_num_part) 0;
1176 num.high = num.low = sign_mask;
1180 if (precision < PART_PRECISION)
1181 num.high = sign_mask, num.low |= sign_mask << precision;
1182 else if (precision < 2 * PART_PRECISION)
1183 num.high |= sign_mask << (precision - PART_PRECISION);
1185 if (n >= PART_PRECISION)
1187 n -= PART_PRECISION;
1189 num.high = sign_mask;
1194 num.low = (num.low >> n) | (num.high << (PART_PRECISION - n));
1195 num.high = (num.high >> n) | (sign_mask << (PART_PRECISION - n));
1199 num = num_trim (num, precision);
1200 num.overflow = false;
1204 /* Shift NUM, of width PRECISION, left by N bits. */
1206 num_lshift (cpp_num num, size_t precision, size_t n)
1210 num.overflow = !num.unsignedp && !num_zerop (num);
1211 num.high = num.low = 0;
1215 cpp_num orig, maybe_orig;
1219 if (m >= PART_PRECISION)
1221 m -= PART_PRECISION;
1227 num.high = (num.high << m) | (num.low >> (PART_PRECISION - m));
1230 num = num_trim (num, precision);
1233 num.overflow = false;
1236 maybe_orig = num_rshift (num, precision, n);
1237 num.overflow = !num_eq (orig, maybe_orig);
1244 /* The four unary operators: +, -, ! and ~. */
1246 num_unary_op (cpp_reader *pfile, cpp_num num, enum cpp_ttype op)
1251 if (CPP_WTRADITIONAL (pfile) && !pfile->state.skip_eval)
1252 cpp_error (pfile, DL_WARNING,
1253 "traditional C rejects the unary plus operator");
1254 num.overflow = false;
1258 num = num_negate (num, CPP_OPTION (pfile, precision));
1262 num.high = ~num.high;
1264 num = num_trim (num, CPP_OPTION (pfile, precision));
1265 num.overflow = false;
1268 default: /* case CPP_NOT: */
1269 num.low = num_zerop (num);
1271 num.overflow = false;
1272 num.unsignedp = false;
1279 /* The various binary operators. */
1281 num_binary_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1284 size_t precision = CPP_OPTION (pfile, precision);
1293 if (!rhs.unsignedp && !num_positive (rhs, precision))
1295 /* A negative shift is a positive shift the other way. */
1296 if (op == CPP_LSHIFT)
1300 rhs = num_negate (rhs, precision);
1303 n = ~0; /* Maximal. */
1306 if (op == CPP_LSHIFT)
1307 lhs = num_lshift (lhs, precision, n);
1309 lhs = num_rshift (lhs, precision, n);
1316 bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1318 gte = num_greater_eq (lhs, rhs, precision);
1323 lhs.unsignedp = unsignedp;
1329 rhs = num_negate (rhs, precision);
1331 result.low = lhs.low + rhs.low;
1332 result.high = lhs.high + rhs.high;
1333 if (result.low < lhs.low)
1336 result = num_trim (result, precision);
1337 result.unsignedp = lhs.unsignedp || rhs.unsignedp;
1338 if (result.unsignedp)
1339 result.overflow = false;
1342 bool lhsp = num_positive (lhs, precision);
1343 result.overflow = (lhsp == num_positive (rhs, precision)
1344 && lhsp != num_positive (result, precision));
1349 default: /* case CPP_COMMA: */
1350 if (CPP_PEDANTIC (pfile) && !pfile->state.skip_eval)
1351 cpp_error (pfile, DL_PEDWARN,
1352 "comma operator in operand of #if");
1360 /* Multiplies two unsigned cpp_num_parts to give a cpp_num. This
1363 num_part_mul (cpp_num_part lhs, cpp_num_part rhs)
1366 cpp_num_part middle[2], temp;
1368 result.low = LOW_PART (lhs) * LOW_PART (rhs);
1369 result.high = HIGH_PART (lhs) * HIGH_PART (rhs);
1371 middle[0] = LOW_PART (lhs) * HIGH_PART (rhs);
1372 middle[1] = HIGH_PART (lhs) * LOW_PART (rhs);
1375 result.low += LOW_PART (middle[0]) << (PART_PRECISION / 2);
1376 if (result.low < temp)
1380 result.low += LOW_PART (middle[1]) << (PART_PRECISION / 2);
1381 if (result.low < temp)
1384 result.high += HIGH_PART (middle[0]);
1385 result.high += HIGH_PART (middle[1]);
1386 result.unsignedp = 1;
1391 /* Multiply two preprocessing numbers. */
1393 num_mul (cpp_reader *pfile, cpp_num lhs, cpp_num rhs)
1395 cpp_num result, temp;
1396 bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1397 bool overflow, negate = false;
1398 size_t precision = CPP_OPTION (pfile, precision);
1400 /* Prepare for unsigned multiplication. */
1403 if (!num_positive (lhs, precision))
1404 negate = !negate, lhs = num_negate (lhs, precision);
1405 if (!num_positive (rhs, precision))
1406 negate = !negate, rhs = num_negate (rhs, precision);
1409 overflow = lhs.high && rhs.high;
1410 result = num_part_mul (lhs.low, rhs.low);
1412 temp = num_part_mul (lhs.high, rhs.low);
1413 result.high += temp.low;
1417 temp = num_part_mul (lhs.low, rhs.high);
1418 result.high += temp.low;
1422 temp.low = result.low, temp.high = result.high;
1423 result = num_trim (result, precision);
1424 if (!num_eq (result, temp))
1428 result = num_negate (result, precision);
1431 result.overflow = false;
1433 result.overflow = overflow || (num_positive (result, precision) ^ !negate
1434 && !num_zerop (result));
1435 result.unsignedp = unsignedp;
1440 /* Divide two preprocessing numbers, returning the answer or the
1441 remainder depending upon OP. */
1443 num_div_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1445 cpp_num result, sub;
1447 bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1448 bool negate = false, lhs_neg = false;
1449 size_t i, precision = CPP_OPTION (pfile, precision);
1451 /* Prepare for unsigned division. */
1454 if (!num_positive (lhs, precision))
1455 negate = !negate, lhs_neg = true, lhs = num_negate (lhs, precision);
1456 if (!num_positive (rhs, precision))
1457 negate = !negate, rhs = num_negate (rhs, precision);
1460 /* Find the high bit. */
1464 mask = (cpp_num_part) 1 << (i - PART_PRECISION);
1465 for (; ; i--, mask >>= 1)
1466 if (rhs.high & mask)
1471 if (precision > PART_PRECISION)
1472 i = precision - PART_PRECISION - 1;
1475 mask = (cpp_num_part) 1 << i;
1476 for (; ; i--, mask >>= 1)
1482 if (!pfile->state.skip_eval)
1483 cpp_error (pfile, DL_ERROR, "division by zero in #if");
1487 /* First nonzero bit of RHS is bit I. Do naive division by
1488 shifting the RHS fully left, and subtracting from LHS if LHS is
1489 at least as big, and then repeating but with one less shift.
1490 This is not very efficient, but is easy to understand. */
1492 rhs.unsignedp = true;
1493 lhs.unsignedp = true;
1494 i = precision - i - 1;
1495 sub = num_lshift (rhs, precision, i);
1497 result.high = result.low = 0;
1500 if (num_greater_eq (lhs, sub, precision))
1502 lhs = num_binary_op (pfile, lhs, sub, CPP_MINUS);
1503 if (i >= PART_PRECISION)
1504 result.high |= (cpp_num_part) 1 << (i - PART_PRECISION);
1506 result.low |= (cpp_num_part) 1 << i;
1510 sub.low = (sub.low >> 1) | (sub.high << (PART_PRECISION - 1));
1514 /* We divide so that the remainder has the sign of the LHS. */
1517 result.unsignedp = unsignedp;
1519 result.overflow = false;
1523 result = num_negate (result, precision);
1524 result.overflow = num_positive (result, precision) ^ !negate;
1531 lhs.unsignedp = unsignedp;
1532 lhs.overflow = false;
1534 lhs = num_negate (lhs, precision);