1 /* Parse C expressions for cpplib.
2 Copyright (C) 1987, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2001,
3 2002, 2004, 2008, 2009 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 3, 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; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
25 #define PART_PRECISION (sizeof (cpp_num_part) * CHAR_BIT)
26 #define HALF_MASK (~(cpp_num_part) 0 >> (PART_PRECISION / 2))
27 #define LOW_PART(num_part) (num_part & HALF_MASK)
28 #define HIGH_PART(num_part) (num_part >> (PART_PRECISION / 2))
32 const cpp_token *token; /* The token forming op (for diagnostics). */
33 cpp_num value; /* The value logically "right" of op. */
34 source_location loc; /* The location of this value. */
38 /* Some simple utility routines on double integers. */
39 #define num_zerop(num) ((num.low | num.high) == 0)
40 #define num_eq(num1, num2) (num1.low == num2.low && num1.high == num2.high)
41 static bool num_positive (cpp_num, size_t);
42 static bool num_greater_eq (cpp_num, cpp_num, size_t);
43 static cpp_num num_trim (cpp_num, size_t);
44 static cpp_num num_part_mul (cpp_num_part, cpp_num_part);
46 static cpp_num num_unary_op (cpp_reader *, cpp_num, enum cpp_ttype);
47 static cpp_num num_binary_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);
48 static cpp_num num_negate (cpp_num, size_t);
49 static cpp_num num_bitwise_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);
50 static cpp_num num_inequality_op (cpp_reader *, cpp_num, cpp_num,
52 static cpp_num num_equality_op (cpp_reader *, cpp_num, cpp_num,
54 static cpp_num num_mul (cpp_reader *, cpp_num, cpp_num);
55 static cpp_num num_div_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);
56 static cpp_num num_lshift (cpp_num, size_t, size_t);
57 static cpp_num num_rshift (cpp_num, size_t, size_t);
59 static cpp_num append_digit (cpp_num, int, int, size_t);
60 static cpp_num parse_defined (cpp_reader *);
61 static cpp_num eval_token (cpp_reader *, const cpp_token *);
62 static struct op *reduce (cpp_reader *, struct op *, enum cpp_ttype);
63 static unsigned int interpret_float_suffix (const uchar *, size_t);
64 static unsigned int interpret_int_suffix (const uchar *, size_t);
65 static void check_promotion (cpp_reader *, const struct op *);
67 /* Token type abuse to create unary plus and minus operators. */
68 #define CPP_UPLUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 1))
69 #define CPP_UMINUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 2))
71 /* With -O2, gcc appears to produce nice code, moving the error
72 message load and subsequent jump completely out of the main path. */
73 #define SYNTAX_ERROR(msgid) \
74 do { cpp_error (pfile, CPP_DL_ERROR, msgid); goto syntax_error; } while(0)
75 #define SYNTAX_ERROR2(msgid, arg) \
76 do { cpp_error (pfile, CPP_DL_ERROR, msgid, arg); goto syntax_error; } \
79 /* Subroutine of cpp_classify_number. S points to a float suffix of
80 length LEN, possibly zero. Returns 0 for an invalid suffix, or a
81 flag vector describing the suffix. */
83 interpret_float_suffix (const uchar *s, size_t len)
85 size_t f, l, w, q, i, d;
88 f = l = w = q = i = d = 0;
94 case 'r': case 'R': r++; break;
95 case 'k': case 'K': k++; break;
96 case 'u': case 'U': u++; break;
97 case 'h': case 'H': h++; break;
107 /* If there are two Ls, they must be adjacent and the same case. */
108 if (l == 2 && s[len] != s[len + 1])
122 case 'j': case 'J': i++; break;
123 case 'd': case 'D': d++; break;
128 if (r + k > 1 || h > 1 || l > 2 || u > 1)
133 if (f || i || d || w || q)
137 | (u ? CPP_N_UNSIGNED : 0)
139 l == 2 ? CPP_N_LARGE :
140 l == 1 ? CPP_N_MEDIUM : 0));
145 if (f || i || d || w || q)
149 | (u ? CPP_N_UNSIGNED : 0)
151 l == 2 ? CPP_N_LARGE :
152 l == 1 ? CPP_N_MEDIUM : 0));
155 if (f + l + w + q > 1 || i > 1 || h + u > 0)
158 /* Allow dd, df, dl suffixes for decimal float constants. */
159 if (d && ((d + f + l != 2) || i))
162 return ((i ? CPP_N_IMAGINARY : 0)
166 q ? CPP_N_MD_Q : CPP_N_MEDIUM)
167 | (d ? CPP_N_DFLOAT : 0));
170 /* Subroutine of cpp_classify_number. S points to an integer suffix
171 of length LEN, possibly zero. Returns 0 for an invalid suffix, or a
172 flag vector describing the suffix. */
174 interpret_int_suffix (const uchar *s, size_t len)
183 case 'u': case 'U': u++; break;
185 case 'j': case 'J': i++; break;
186 case 'l': case 'L': l++;
187 /* If there are two Ls, they must be adjacent and the same case. */
188 if (l == 2 && s[len] != s[len + 1])
195 if (l > 2 || u > 1 || i > 1)
198 return ((i ? CPP_N_IMAGINARY : 0)
199 | (u ? CPP_N_UNSIGNED : 0)
200 | ((l == 0) ? CPP_N_SMALL
201 : (l == 1) ? CPP_N_MEDIUM : CPP_N_LARGE));
204 /* Categorize numeric constants according to their field (integer,
205 floating point, or invalid), radix (decimal, octal, hexadecimal),
206 and type suffixes. */
208 cpp_classify_number (cpp_reader *pfile, const cpp_token *token)
210 const uchar *str = token->val.str.text;
212 unsigned int max_digit, result, radix;
213 enum {NOT_FLOAT = 0, AFTER_POINT, AFTER_EXPON} float_flag;
215 /* If the lexer has done its job, length one can only be a single
216 digit. Fast-path this very common case. */
217 if (token->val.str.len == 1)
218 return CPP_N_INTEGER | CPP_N_SMALL | CPP_N_DECIMAL;
220 limit = str + token->val.str.len;
221 float_flag = NOT_FLOAT;
225 /* First, interpret the radix. */
231 /* Require at least one hex digit to classify it as hex. */
232 if ((*str == 'x' || *str == 'X')
233 && (str[1] == '.' || ISXDIGIT (str[1])))
238 else if ((*str == 'b' || *str == 'B') && (str[1] == '0' || str[1] == '1'))
245 /* Now scan for a well-formed integer or float. */
248 unsigned int c = *str++;
250 if (ISDIGIT (c) || (ISXDIGIT (c) && radix == 16))
258 if (float_flag == NOT_FLOAT)
259 float_flag = AFTER_POINT;
261 SYNTAX_ERROR ("too many decimal points in number");
263 else if ((radix <= 10 && (c == 'e' || c == 'E'))
264 || (radix == 16 && (c == 'p' || c == 'P')))
266 float_flag = AFTER_EXPON;
271 /* Start of suffix. */
277 /* The suffix may be for decimal fixed-point constants without exponent. */
278 if (radix != 16 && float_flag == NOT_FLOAT)
280 result = interpret_float_suffix (str, limit - str);
281 if ((result & CPP_N_FRACT) || (result & CPP_N_ACCUM))
283 result |= CPP_N_FLOATING;
284 /* We need to restore the radix to 10, if the radix is 8. */
288 if (CPP_PEDANTIC (pfile))
289 cpp_error (pfile, CPP_DL_PEDWARN,
290 "fixed-point constants are a GCC extension");
297 if (float_flag != NOT_FLOAT && radix == 8)
300 if (max_digit >= radix)
303 SYNTAX_ERROR2 ("invalid digit \"%c\" in binary constant", '0' + max_digit);
305 SYNTAX_ERROR2 ("invalid digit \"%c\" in octal constant", '0' + max_digit);
308 if (float_flag != NOT_FLOAT)
312 cpp_error (pfile, CPP_DL_ERROR,
313 "invalid prefix \"0b\" for floating constant");
314 return CPP_N_INVALID;
317 if (radix == 16 && CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, c99))
318 cpp_error (pfile, CPP_DL_PEDWARN,
319 "use of C99 hexadecimal floating constant");
321 if (float_flag == AFTER_EXPON)
323 if (*str == '+' || *str == '-')
326 /* Exponent is decimal, even if string is a hex float. */
328 SYNTAX_ERROR ("exponent has no digits");
332 while (ISDIGIT (*str));
334 else if (radix == 16)
335 SYNTAX_ERROR ("hexadecimal floating constants require an exponent");
337 result = interpret_float_suffix (str, limit - str);
340 cpp_error (pfile, CPP_DL_ERROR,
341 "invalid suffix \"%.*s\" on floating constant",
342 (int) (limit - str), str);
343 return CPP_N_INVALID;
346 /* Traditional C didn't accept any floating suffixes. */
348 && CPP_WTRADITIONAL (pfile)
349 && ! cpp_sys_macro_p (pfile))
350 cpp_error (pfile, CPP_DL_WARNING,
351 "traditional C rejects the \"%.*s\" suffix",
352 (int) (limit - str), str);
354 /* Radix must be 10 for decimal floats. */
355 if ((result & CPP_N_DFLOAT) && radix != 10)
357 cpp_error (pfile, CPP_DL_ERROR,
358 "invalid suffix \"%.*s\" with hexadecimal floating constant",
359 (int) (limit - str), str);
360 return CPP_N_INVALID;
363 if ((result & (CPP_N_FRACT | CPP_N_ACCUM)) && CPP_PEDANTIC (pfile))
364 cpp_error (pfile, CPP_DL_PEDWARN,
365 "fixed-point constants are a GCC extension");
367 if ((result & CPP_N_DFLOAT) && CPP_PEDANTIC (pfile))
368 cpp_error (pfile, CPP_DL_PEDWARN,
369 "decimal float constants are a GCC extension");
371 result |= CPP_N_FLOATING;
375 result = interpret_int_suffix (str, limit - str);
378 cpp_error (pfile, CPP_DL_ERROR,
379 "invalid suffix \"%.*s\" on integer constant",
380 (int) (limit - str), str);
381 return CPP_N_INVALID;
384 /* Traditional C only accepted the 'L' suffix.
385 Suppress warning about 'LL' with -Wno-long-long. */
386 if (CPP_WTRADITIONAL (pfile) && ! cpp_sys_macro_p (pfile))
388 int u_or_i = (result & (CPP_N_UNSIGNED|CPP_N_IMAGINARY));
389 int large = (result & CPP_N_WIDTH) == CPP_N_LARGE;
391 if (u_or_i || (large && CPP_OPTION (pfile, warn_long_long)))
392 cpp_error (pfile, CPP_DL_WARNING,
393 "traditional C rejects the \"%.*s\" suffix",
394 (int) (limit - str), str);
397 if ((result & CPP_N_WIDTH) == CPP_N_LARGE
398 && ! CPP_OPTION (pfile, c99)
399 && CPP_OPTION (pfile, warn_long_long))
400 cpp_error (pfile, CPP_DL_PEDWARN,
401 "use of C99 long long integer constant");
403 result |= CPP_N_INTEGER;
407 if ((result & CPP_N_IMAGINARY) && CPP_PEDANTIC (pfile))
408 cpp_error (pfile, CPP_DL_PEDWARN,
409 "imaginary constants are a GCC extension");
410 if (radix == 2 && CPP_PEDANTIC (pfile))
411 cpp_error (pfile, CPP_DL_PEDWARN,
412 "binary constants are a GCC extension");
415 result |= CPP_N_DECIMAL;
416 else if (radix == 16)
419 result |= CPP_N_BINARY;
421 result |= CPP_N_OCTAL;
426 return CPP_N_INVALID;
429 /* cpp_interpret_integer converts an integer constant into a cpp_num,
430 of precision options->precision.
432 We do not provide any interface for decimal->float conversion,
433 because the preprocessor doesn't need it and we don't want to
434 drag in GCC's floating point emulator. */
436 cpp_interpret_integer (cpp_reader *pfile, const cpp_token *token,
439 const uchar *p, *end;
444 result.unsignedp = !!(type & CPP_N_UNSIGNED);
445 result.overflow = false;
447 p = token->val.str.text;
448 end = p + token->val.str.len;
450 /* Common case of a single digit. */
451 if (token->val.str.len == 1)
452 result.low = p[0] - '0';
456 size_t precision = CPP_OPTION (pfile, precision);
457 unsigned int base = 10, c = 0;
458 bool overflow = false;
460 if ((type & CPP_N_RADIX) == CPP_N_OCTAL)
465 else if ((type & CPP_N_RADIX) == CPP_N_HEX)
470 else if ((type & CPP_N_RADIX) == CPP_N_BINARY)
476 /* We can add a digit to numbers strictly less than this without
477 needing the precision and slowness of double integers. */
478 max = ~(cpp_num_part) 0;
479 if (precision < PART_PRECISION)
480 max >>= PART_PRECISION - precision;
481 max = (max - base + 1) / base + 1;
487 if (ISDIGIT (c) || (base == 16 && ISXDIGIT (c)))
492 /* Strict inequality for when max is set to zero. */
493 if (result.low < max)
494 result.low = result.low * base + c;
497 result = append_digit (result, c, base, precision);
498 overflow |= result.overflow;
504 cpp_error (pfile, CPP_DL_PEDWARN,
505 "integer constant is too large for its type");
506 /* If too big to be signed, consider it unsigned. Only warn for
507 decimal numbers. Traditional numbers were always signed (but
508 we still honor an explicit U suffix); but we only have
509 traditional semantics in directives. */
510 else if (!result.unsignedp
511 && !(CPP_OPTION (pfile, traditional)
512 && pfile->state.in_directive)
513 && !num_positive (result, precision))
516 cpp_error (pfile, CPP_DL_WARNING,
517 "integer constant is so large that it is unsigned");
518 result.unsignedp = true;
525 /* Append DIGIT to NUM, a number of PRECISION bits being read in base BASE. */
527 append_digit (cpp_num num, int digit, int base, size_t precision)
532 cpp_num_part add_high, add_low;
534 /* Multiply by 2, 8 or 16. Catching this overflow here means we don't
535 need to worry about add_high overflowing. */
549 overflow = !!(num.high >> (PART_PRECISION - shift));
550 result.high = num.high << shift;
551 result.low = num.low << shift;
552 result.high |= num.low >> (PART_PRECISION - shift);
553 result.unsignedp = num.unsignedp;
557 add_low = num.low << 1;
558 add_high = (num.high << 1) + (num.low >> (PART_PRECISION - 1));
561 add_high = add_low = 0;
563 if (add_low + digit < add_low)
567 if (result.low + add_low < result.low)
569 if (result.high + add_high < result.high)
572 result.low += add_low;
573 result.high += add_high;
574 result.overflow = overflow;
576 /* The above code catches overflow of a cpp_num type. This catches
577 overflow of the (possibly shorter) target precision. */
578 num.low = result.low;
579 num.high = result.high;
580 result = num_trim (result, precision);
581 if (!num_eq (result, num))
582 result.overflow = true;
587 /* Handle meeting "defined" in a preprocessor expression. */
589 parse_defined (cpp_reader *pfile)
593 cpp_hashnode *node = 0;
594 const cpp_token *token;
595 cpp_context *initial_context = pfile->context;
597 /* Don't expand macros. */
598 pfile->state.prevent_expansion++;
600 token = cpp_get_token (pfile);
601 if (token->type == CPP_OPEN_PAREN)
604 token = cpp_get_token (pfile);
607 if (token->type == CPP_NAME)
609 node = token->val.node;
610 if (paren && cpp_get_token (pfile)->type != CPP_CLOSE_PAREN)
612 cpp_error (pfile, CPP_DL_ERROR, "missing ')' after \"defined\"");
618 cpp_error (pfile, CPP_DL_ERROR,
619 "operator \"defined\" requires an identifier");
620 if (token->flags & NAMED_OP)
625 op.type = token->type;
626 cpp_error (pfile, CPP_DL_ERROR,
627 "(\"%s\" is an alternative token for \"%s\" in C++)",
628 cpp_token_as_text (pfile, token),
629 cpp_token_as_text (pfile, &op));
635 if (pfile->context != initial_context && CPP_PEDANTIC (pfile))
636 cpp_error (pfile, CPP_DL_WARNING,
637 "this use of \"defined\" may not be portable");
639 _cpp_mark_macro_used (node);
640 if (!(node->flags & NODE_USED))
642 node->flags |= NODE_USED;
643 if (node->type == NT_MACRO)
645 if (pfile->cb.used_define)
646 pfile->cb.used_define (pfile, pfile->directive_line, node);
650 if (pfile->cb.used_undef)
651 pfile->cb.used_undef (pfile, pfile->directive_line, node);
655 /* A possible controlling macro of the form #if !defined ().
656 _cpp_parse_expr checks there was no other junk on the line. */
657 pfile->mi_ind_cmacro = node;
660 pfile->state.prevent_expansion--;
662 result.unsignedp = false;
664 result.overflow = false;
665 result.low = node && node->type == NT_MACRO;
669 /* Convert a token into a CPP_NUMBER (an interpreted preprocessing
670 number or character constant, or the result of the "defined" or "#"
673 eval_token (cpp_reader *pfile, const cpp_token *token)
679 result.unsignedp = false;
680 result.overflow = false;
685 temp = cpp_classify_number (pfile, token);
686 switch (temp & CPP_N_CATEGORY)
689 cpp_error (pfile, CPP_DL_ERROR,
690 "floating constant in preprocessor expression");
693 if (!(temp & CPP_N_IMAGINARY))
694 return cpp_interpret_integer (pfile, token, temp);
695 cpp_error (pfile, CPP_DL_ERROR,
696 "imaginary number in preprocessor expression");
700 /* Error already issued. */
703 result.high = result.low = 0;
711 cppchar_t cc = cpp_interpret_charconst (pfile, token,
716 /* Sign-extend the result if necessary. */
717 if (!unsignedp && (cppchar_signed_t) cc < 0)
719 if (PART_PRECISION > BITS_PER_CPPCHAR_T)
720 result.low |= ~(~(cpp_num_part) 0
721 >> (PART_PRECISION - BITS_PER_CPPCHAR_T));
722 result.high = ~(cpp_num_part) 0;
723 result = num_trim (result, CPP_OPTION (pfile, precision));
729 if (token->val.node == pfile->spec_nodes.n_defined)
730 return parse_defined (pfile);
731 else if (CPP_OPTION (pfile, cplusplus)
732 && (token->val.node == pfile->spec_nodes.n_true
733 || token->val.node == pfile->spec_nodes.n_false))
736 result.low = (token->val.node == pfile->spec_nodes.n_true);
742 if (CPP_OPTION (pfile, warn_undef) && !pfile->state.skip_eval)
743 cpp_error (pfile, CPP_DL_WARNING, "\"%s\" is not defined",
744 NODE_NAME (token->val.node));
749 if (!pfile->state.skipping)
751 /* A pedantic warning takes precedence over a deprecated
753 if (CPP_PEDANTIC (pfile))
754 cpp_error (pfile, CPP_DL_PEDWARN,
755 "assertions are a GCC extension");
756 else if (CPP_OPTION (pfile, warn_deprecated))
757 cpp_error (pfile, CPP_DL_WARNING,
758 "assertions are a deprecated extension");
760 _cpp_test_assertion (pfile, &temp);
769 result.unsignedp = !!unsignedp;
773 /* Operator precedence and flags table.
775 After an operator is returned from the lexer, if it has priority less
776 than the operator on the top of the stack, we reduce the stack by one
777 operator and repeat the test. Since equal priorities do not reduce,
778 this is naturally right-associative.
780 We handle left-associative operators by decrementing the priority of
781 just-lexed operators by one, but retaining the priority of operators
782 already on the stack.
784 The remaining cases are '(' and ')'. We handle '(' by skipping the
785 reduction phase completely. ')' is given lower priority than
786 everything else, including '(', effectively forcing a reduction of the
787 parenthesized expression. If there is a matching '(', the routine
788 reduce() exits immediately. If the normal exit route sees a ')', then
789 there cannot have been a matching '(' and an error message is output.
791 The parser assumes all shifted operators require a left operand unless
792 the flag NO_L_OPERAND is set. These semantics are automatic; any
793 extra semantics need to be handled with operator-specific code. */
795 /* Flags. If CHECK_PROMOTION, we warn if the effective sign of an
796 operand changes because of integer promotions. */
797 #define NO_L_OPERAND (1 << 0)
798 #define LEFT_ASSOC (1 << 1)
799 #define CHECK_PROMOTION (1 << 2)
801 /* Operator to priority map. Must be in the same order as the first
802 N entries of enum cpp_ttype. */
803 static const struct cpp_operator
809 /* EQ */ {0, 0}, /* Shouldn't happen. */
810 /* NOT */ {16, NO_L_OPERAND},
811 /* GREATER */ {12, LEFT_ASSOC | CHECK_PROMOTION},
812 /* LESS */ {12, LEFT_ASSOC | CHECK_PROMOTION},
813 /* PLUS */ {14, LEFT_ASSOC | CHECK_PROMOTION},
814 /* MINUS */ {14, LEFT_ASSOC | CHECK_PROMOTION},
815 /* MULT */ {15, LEFT_ASSOC | CHECK_PROMOTION},
816 /* DIV */ {15, LEFT_ASSOC | CHECK_PROMOTION},
817 /* MOD */ {15, LEFT_ASSOC | CHECK_PROMOTION},
818 /* AND */ {9, LEFT_ASSOC | CHECK_PROMOTION},
819 /* OR */ {7, LEFT_ASSOC | CHECK_PROMOTION},
820 /* XOR */ {8, LEFT_ASSOC | CHECK_PROMOTION},
821 /* RSHIFT */ {13, LEFT_ASSOC},
822 /* LSHIFT */ {13, LEFT_ASSOC},
824 /* COMPL */ {16, NO_L_OPERAND},
825 /* AND_AND */ {6, LEFT_ASSOC},
826 /* OR_OR */ {5, LEFT_ASSOC},
827 /* Note that QUERY, COLON, and COMMA must have the same precedence.
828 However, there are some special cases for these in reduce(). */
830 /* COLON */ {4, LEFT_ASSOC | CHECK_PROMOTION},
831 /* COMMA */ {4, LEFT_ASSOC},
832 /* OPEN_PAREN */ {1, NO_L_OPERAND},
833 /* CLOSE_PAREN */ {0, 0},
835 /* EQ_EQ */ {11, LEFT_ASSOC},
836 /* NOT_EQ */ {11, LEFT_ASSOC},
837 /* GREATER_EQ */ {12, LEFT_ASSOC | CHECK_PROMOTION},
838 /* LESS_EQ */ {12, LEFT_ASSOC | CHECK_PROMOTION},
839 /* UPLUS */ {16, NO_L_OPERAND},
840 /* UMINUS */ {16, NO_L_OPERAND}
843 /* Parse and evaluate a C expression, reading from PFILE.
844 Returns the truth value of the expression.
846 The implementation is an operator precedence parser, i.e. a
847 bottom-up parser, using a stack for not-yet-reduced tokens.
849 The stack base is op_stack, and the current stack pointer is 'top'.
850 There is a stack element for each operator (only), and the most
851 recently pushed operator is 'top->op'. An operand (value) is
852 stored in the 'value' field of the stack element of the operator
855 _cpp_parse_expr (cpp_reader *pfile, bool is_if)
857 struct op *top = pfile->op_stack;
858 unsigned int lex_count;
859 bool saw_leading_not, want_value = true;
861 pfile->state.skip_eval = 0;
863 /* Set up detection of #if ! defined(). */
864 pfile->mi_ind_cmacro = 0;
865 saw_leading_not = false;
868 /* Lowest priority operator prevents further reductions. */
876 op.token = cpp_get_token (pfile);
877 op.op = op.token->type;
878 op.loc = op.token->src_loc;
882 /* These tokens convert into values. */
891 SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
892 cpp_token_as_text (pfile, op.token));
894 top->value = eval_token (pfile, op.token);
898 saw_leading_not = lex_count == 1;
910 if ((int) op.op <= (int) CPP_EQ || (int) op.op >= (int) CPP_PLUS_EQ)
911 SYNTAX_ERROR2 ("token \"%s\" is not valid in preprocessor expressions",
912 cpp_token_as_text (pfile, op.token));
916 /* Check we have a value or operator as appropriate. */
917 if (optab[op.op].flags & NO_L_OPERAND)
920 SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
921 cpp_token_as_text (pfile, op.token));
925 /* We want a number (or expression) and haven't got one.
926 Try to emit a specific diagnostic. */
927 if (op.op == CPP_CLOSE_PAREN && top->op == CPP_OPEN_PAREN)
928 SYNTAX_ERROR ("missing expression between '(' and ')'");
930 if (op.op == CPP_EOF && top->op == CPP_EOF)
931 SYNTAX_ERROR2 ("%s with no expression", is_if ? "#if" : "#elif");
933 if (top->op != CPP_EOF && top->op != CPP_OPEN_PAREN)
934 SYNTAX_ERROR2 ("operator '%s' has no right operand",
935 cpp_token_as_text (pfile, top->token));
936 else if (op.op == CPP_CLOSE_PAREN || op.op == CPP_EOF)
937 /* Complain about missing paren during reduction. */;
939 SYNTAX_ERROR2 ("operator '%s' has no left operand",
940 cpp_token_as_text (pfile, op.token));
943 top = reduce (pfile, top, op.op);
947 if (op.op == CPP_EOF)
952 case CPP_CLOSE_PAREN:
955 if (!num_zerop (top->value))
956 pfile->state.skip_eval++;
960 if (num_zerop (top->value))
961 pfile->state.skip_eval++;
964 if (top->op != CPP_QUERY)
965 SYNTAX_ERROR (" ':' without preceding '?'");
966 if (!num_zerop (top[-1].value)) /* Was '?' condition true? */
967 pfile->state.skip_eval++;
969 pfile->state.skip_eval--;
976 /* Check for and handle stack overflow. */
977 if (++top == pfile->op_limit)
978 top = _cpp_expand_op_stack (pfile);
981 top->token = op.token;
982 top->loc = op.token->src_loc;
985 /* The controlling macro expression is only valid if we called lex 3
986 times: <!> <defined expression> and <EOF>. push_conditional ()
987 checks that we are at top-of-file. */
988 if (pfile->mi_ind_cmacro && !(saw_leading_not && lex_count == 3))
989 pfile->mi_ind_cmacro = 0;
991 if (top != pfile->op_stack)
993 cpp_error (pfile, CPP_DL_ICE, "unbalanced stack in %s",
994 is_if ? "#if" : "#elif");
996 return false; /* Return false on syntax error. */
999 return !num_zerop (top->value);
1002 /* Reduce the operator / value stack if possible, in preparation for
1003 pushing operator OP. Returns NULL on error, otherwise the top of
1006 reduce (cpp_reader *pfile, struct op *top, enum cpp_ttype op)
1010 if (top->op <= CPP_EQ || top->op > CPP_LAST_CPP_OP + 2)
1013 cpp_error (pfile, CPP_DL_ICE, "impossible operator '%u'", top->op);
1017 if (op == CPP_OPEN_PAREN)
1020 /* Decrement the priority of left-associative operators to force a
1021 reduction with operators of otherwise equal priority. */
1022 prio = optab[op].prio - ((optab[op].flags & LEFT_ASSOC) != 0);
1023 while (prio < optab[top->op].prio)
1025 if (CPP_OPTION (pfile, warn_num_sign_change)
1026 && optab[top->op].flags & CHECK_PROMOTION)
1027 check_promotion (pfile, top);
1035 top[-1].value = num_unary_op (pfile, top->value, top->op);
1036 top[-1].loc = top->loc;
1044 top[-1].value = num_binary_op (pfile, top[-1].value,
1045 top->value, top->op);
1046 top[-1].loc = top->loc;
1051 case CPP_GREATER_EQ:
1054 = num_inequality_op (pfile, top[-1].value, top->value, top->op);
1055 top[-1].loc = top->loc;
1061 = num_equality_op (pfile, top[-1].value, top->value, top->op);
1062 top[-1].loc = top->loc;
1069 = num_bitwise_op (pfile, top[-1].value, top->value, top->op);
1070 top[-1].loc = top->loc;
1074 top[-1].value = num_mul (pfile, top[-1].value, top->value);
1075 top[-1].loc = top->loc;
1080 top[-1].value = num_div_op (pfile, top[-1].value,
1081 top->value, top->op);
1082 top[-1].loc = top->loc;
1087 if (!num_zerop (top->value))
1088 pfile->state.skip_eval--;
1089 top->value.low = (!num_zerop (top->value)
1090 || !num_zerop (top[1].value));
1091 top->value.high = 0;
1092 top->value.unsignedp = false;
1093 top->value.overflow = false;
1094 top->loc = top[1].loc;
1099 if (num_zerop (top->value))
1100 pfile->state.skip_eval--;
1101 top->value.low = (!num_zerop (top->value)
1102 && !num_zerop (top[1].value));
1103 top->value.high = 0;
1104 top->value.unsignedp = false;
1105 top->value.overflow = false;
1106 top->loc = top[1].loc;
1109 case CPP_OPEN_PAREN:
1110 if (op != CPP_CLOSE_PAREN)
1112 cpp_error_with_line (pfile, CPP_DL_ERROR,
1113 top->token->src_loc,
1114 0, "missing ')' in expression");
1118 top->value = top[1].value;
1119 top->loc = top[1].loc;
1124 if (!num_zerop (top->value))
1126 pfile->state.skip_eval--;
1127 top->value = top[1].value;
1128 top->loc = top[1].loc;
1132 top->value = top[2].value;
1133 top->loc = top[2].loc;
1135 top->value.unsignedp = (top[1].value.unsignedp
1136 || top[2].value.unsignedp);
1140 /* COMMA and COLON should not reduce a QUERY operator. */
1141 if (op == CPP_COMMA || op == CPP_COLON)
1143 cpp_error (pfile, CPP_DL_ERROR, "'?' without following ':'");
1151 if (top->value.overflow && !pfile->state.skip_eval)
1152 cpp_error (pfile, CPP_DL_PEDWARN,
1153 "integer overflow in preprocessor expression");
1156 if (op == CPP_CLOSE_PAREN)
1158 cpp_error (pfile, CPP_DL_ERROR, "missing '(' in expression");
1165 /* Returns the position of the old top of stack after expansion. */
1167 _cpp_expand_op_stack (cpp_reader *pfile)
1169 size_t old_size = (size_t) (pfile->op_limit - pfile->op_stack);
1170 size_t new_size = old_size * 2 + 20;
1172 pfile->op_stack = XRESIZEVEC (struct op, pfile->op_stack, new_size);
1173 pfile->op_limit = pfile->op_stack + new_size;
1175 return pfile->op_stack + old_size;
1178 /* Emits a warning if the effective sign of either operand of OP
1179 changes because of integer promotions. */
1181 check_promotion (cpp_reader *pfile, const struct op *op)
1183 if (op->value.unsignedp == op[-1].value.unsignedp)
1186 if (op->value.unsignedp)
1188 if (!num_positive (op[-1].value, CPP_OPTION (pfile, precision)))
1189 cpp_error_with_line (pfile, CPP_DL_WARNING, op[-1].loc, 0,
1190 "the left operand of \"%s\" changes sign when promoted",
1191 cpp_token_as_text (pfile, op->token));
1193 else if (!num_positive (op->value, CPP_OPTION (pfile, precision)))
1194 cpp_error_with_line (pfile, CPP_DL_WARNING, op->loc, 0,
1195 "the right operand of \"%s\" changes sign when promoted",
1196 cpp_token_as_text (pfile, op->token));
1199 /* Clears the unused high order bits of the number pointed to by PNUM. */
1201 num_trim (cpp_num num, size_t precision)
1203 if (precision > PART_PRECISION)
1205 precision -= PART_PRECISION;
1206 if (precision < PART_PRECISION)
1207 num.high &= ((cpp_num_part) 1 << precision) - 1;
1211 if (precision < PART_PRECISION)
1212 num.low &= ((cpp_num_part) 1 << precision) - 1;
1219 /* True iff A (presumed signed) >= 0. */
1221 num_positive (cpp_num num, size_t precision)
1223 if (precision > PART_PRECISION)
1225 precision -= PART_PRECISION;
1226 return (num.high & (cpp_num_part) 1 << (precision - 1)) == 0;
1229 return (num.low & (cpp_num_part) 1 << (precision - 1)) == 0;
1232 /* Sign extend a number, with PRECISION significant bits and all
1233 others assumed clear, to fill out a cpp_num structure. */
1235 cpp_num_sign_extend (cpp_num num, size_t precision)
1239 if (precision > PART_PRECISION)
1241 precision -= PART_PRECISION;
1242 if (precision < PART_PRECISION
1243 && (num.high & (cpp_num_part) 1 << (precision - 1)))
1244 num.high |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1246 else if (num.low & (cpp_num_part) 1 << (precision - 1))
1248 if (precision < PART_PRECISION)
1249 num.low |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1250 num.high = ~(cpp_num_part) 0;
1257 /* Returns the negative of NUM. */
1259 num_negate (cpp_num num, size_t precision)
1264 num.high = ~num.high;
1268 num = num_trim (num, precision);
1269 num.overflow = (!num.unsignedp && num_eq (num, copy) && !num_zerop (num));
1274 /* Returns true if A >= B. */
1276 num_greater_eq (cpp_num pa, cpp_num pb, size_t precision)
1280 unsignedp = pa.unsignedp || pb.unsignedp;
1284 /* Both numbers have signed type. If they are of different
1285 sign, the answer is the sign of A. */
1286 unsignedp = num_positive (pa, precision);
1288 if (unsignedp != num_positive (pb, precision))
1291 /* Otherwise we can do an unsigned comparison. */
1294 return (pa.high > pb.high) || (pa.high == pb.high && pa.low >= pb.low);
1297 /* Returns LHS OP RHS, where OP is a bit-wise operation. */
1299 num_bitwise_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1300 cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1302 lhs.overflow = false;
1303 lhs.unsignedp = lhs.unsignedp || rhs.unsignedp;
1305 /* As excess precision is zeroed, there is no need to num_trim () as
1306 these operations cannot introduce a set bit there. */
1310 lhs.high &= rhs.high;
1312 else if (op == CPP_OR)
1315 lhs.high |= rhs.high;
1320 lhs.high ^= rhs.high;
1326 /* Returns LHS OP RHS, where OP is an inequality. */
1328 num_inequality_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs,
1331 bool gte = num_greater_eq (lhs, rhs, CPP_OPTION (pfile, precision));
1333 if (op == CPP_GREATER_EQ)
1335 else if (op == CPP_LESS)
1337 else if (op == CPP_GREATER)
1338 lhs.low = gte && !num_eq (lhs, rhs);
1339 else /* CPP_LESS_EQ. */
1340 lhs.low = !gte || num_eq (lhs, rhs);
1343 lhs.overflow = false;
1344 lhs.unsignedp = false;
1348 /* Returns LHS OP RHS, where OP is == or !=. */
1350 num_equality_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1351 cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1353 /* Work around a 3.0.4 bug; see PR 6950. */
1354 bool eq = num_eq (lhs, rhs);
1355 if (op == CPP_NOT_EQ)
1359 lhs.overflow = false;
1360 lhs.unsignedp = false;
1364 /* Shift NUM, of width PRECISION, right by N bits. */
1366 num_rshift (cpp_num num, size_t precision, size_t n)
1368 cpp_num_part sign_mask;
1369 bool x = num_positive (num, precision);
1371 if (num.unsignedp || x)
1374 sign_mask = ~(cpp_num_part) 0;
1377 num.high = num.low = sign_mask;
1381 if (precision < PART_PRECISION)
1382 num.high = sign_mask, num.low |= sign_mask << precision;
1383 else if (precision < 2 * PART_PRECISION)
1384 num.high |= sign_mask << (precision - PART_PRECISION);
1386 if (n >= PART_PRECISION)
1388 n -= PART_PRECISION;
1390 num.high = sign_mask;
1395 num.low = (num.low >> n) | (num.high << (PART_PRECISION - n));
1396 num.high = (num.high >> n) | (sign_mask << (PART_PRECISION - n));
1400 num = num_trim (num, precision);
1401 num.overflow = false;
1405 /* Shift NUM, of width PRECISION, left by N bits. */
1407 num_lshift (cpp_num num, size_t precision, size_t n)
1411 num.overflow = !num.unsignedp && !num_zerop (num);
1412 num.high = num.low = 0;
1416 cpp_num orig, maybe_orig;
1420 if (m >= PART_PRECISION)
1422 m -= PART_PRECISION;
1428 num.high = (num.high << m) | (num.low >> (PART_PRECISION - m));
1431 num = num_trim (num, precision);
1434 num.overflow = false;
1437 maybe_orig = num_rshift (num, precision, n);
1438 num.overflow = !num_eq (orig, maybe_orig);
1445 /* The four unary operators: +, -, ! and ~. */
1447 num_unary_op (cpp_reader *pfile, cpp_num num, enum cpp_ttype op)
1452 if (CPP_WTRADITIONAL (pfile) && !pfile->state.skip_eval)
1453 cpp_error (pfile, CPP_DL_WARNING,
1454 "traditional C rejects the unary plus operator");
1455 num.overflow = false;
1459 num = num_negate (num, CPP_OPTION (pfile, precision));
1463 num.high = ~num.high;
1465 num = num_trim (num, CPP_OPTION (pfile, precision));
1466 num.overflow = false;
1469 default: /* case CPP_NOT: */
1470 num.low = num_zerop (num);
1472 num.overflow = false;
1473 num.unsignedp = false;
1480 /* The various binary operators. */
1482 num_binary_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1485 size_t precision = CPP_OPTION (pfile, precision);
1493 if (!rhs.unsignedp && !num_positive (rhs, precision))
1495 /* A negative shift is a positive shift the other way. */
1496 if (op == CPP_LSHIFT)
1500 rhs = num_negate (rhs, precision);
1503 n = ~0; /* Maximal. */
1506 if (op == CPP_LSHIFT)
1507 lhs = num_lshift (lhs, precision, n);
1509 lhs = num_rshift (lhs, precision, n);
1514 rhs = num_negate (rhs, precision);
1516 result.low = lhs.low + rhs.low;
1517 result.high = lhs.high + rhs.high;
1518 if (result.low < lhs.low)
1520 result.unsignedp = lhs.unsignedp || rhs.unsignedp;
1521 result.overflow = false;
1523 result = num_trim (result, precision);
1524 if (!result.unsignedp)
1526 bool lhsp = num_positive (lhs, precision);
1527 result.overflow = (lhsp == num_positive (rhs, precision)
1528 && lhsp != num_positive (result, precision));
1533 default: /* case CPP_COMMA: */
1534 if (CPP_PEDANTIC (pfile) && (!CPP_OPTION (pfile, c99)
1535 || !pfile->state.skip_eval))
1536 cpp_error (pfile, CPP_DL_PEDWARN,
1537 "comma operator in operand of #if");
1545 /* Multiplies two unsigned cpp_num_parts to give a cpp_num. This
1548 num_part_mul (cpp_num_part lhs, cpp_num_part rhs)
1551 cpp_num_part middle[2], temp;
1553 result.low = LOW_PART (lhs) * LOW_PART (rhs);
1554 result.high = HIGH_PART (lhs) * HIGH_PART (rhs);
1556 middle[0] = LOW_PART (lhs) * HIGH_PART (rhs);
1557 middle[1] = HIGH_PART (lhs) * LOW_PART (rhs);
1560 result.low += LOW_PART (middle[0]) << (PART_PRECISION / 2);
1561 if (result.low < temp)
1565 result.low += LOW_PART (middle[1]) << (PART_PRECISION / 2);
1566 if (result.low < temp)
1569 result.high += HIGH_PART (middle[0]);
1570 result.high += HIGH_PART (middle[1]);
1571 result.unsignedp = true;
1572 result.overflow = false;
1577 /* Multiply two preprocessing numbers. */
1579 num_mul (cpp_reader *pfile, cpp_num lhs, cpp_num rhs)
1581 cpp_num result, temp;
1582 bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1583 bool overflow, negate = false;
1584 size_t precision = CPP_OPTION (pfile, precision);
1586 /* Prepare for unsigned multiplication. */
1589 if (!num_positive (lhs, precision))
1590 negate = !negate, lhs = num_negate (lhs, precision);
1591 if (!num_positive (rhs, precision))
1592 negate = !negate, rhs = num_negate (rhs, precision);
1595 overflow = lhs.high && rhs.high;
1596 result = num_part_mul (lhs.low, rhs.low);
1598 temp = num_part_mul (lhs.high, rhs.low);
1599 result.high += temp.low;
1603 temp = num_part_mul (lhs.low, rhs.high);
1604 result.high += temp.low;
1608 temp.low = result.low, temp.high = result.high;
1609 result = num_trim (result, precision);
1610 if (!num_eq (result, temp))
1614 result = num_negate (result, precision);
1617 result.overflow = false;
1619 result.overflow = overflow || (num_positive (result, precision) ^ !negate
1620 && !num_zerop (result));
1621 result.unsignedp = unsignedp;
1626 /* Divide two preprocessing numbers, returning the answer or the
1627 remainder depending upon OP. */
1629 num_div_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1631 cpp_num result, sub;
1633 bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1634 bool negate = false, lhs_neg = false;
1635 size_t i, precision = CPP_OPTION (pfile, precision);
1637 /* Prepare for unsigned division. */
1640 if (!num_positive (lhs, precision))
1641 negate = !negate, lhs_neg = true, lhs = num_negate (lhs, precision);
1642 if (!num_positive (rhs, precision))
1643 negate = !negate, rhs = num_negate (rhs, precision);
1646 /* Find the high bit. */
1650 mask = (cpp_num_part) 1 << (i - PART_PRECISION);
1651 for (; ; i--, mask >>= 1)
1652 if (rhs.high & mask)
1657 if (precision > PART_PRECISION)
1658 i = precision - PART_PRECISION - 1;
1661 mask = (cpp_num_part) 1 << i;
1662 for (; ; i--, mask >>= 1)
1668 if (!pfile->state.skip_eval)
1669 cpp_error (pfile, CPP_DL_ERROR, "division by zero in #if");
1673 /* First nonzero bit of RHS is bit I. Do naive division by
1674 shifting the RHS fully left, and subtracting from LHS if LHS is
1675 at least as big, and then repeating but with one less shift.
1676 This is not very efficient, but is easy to understand. */
1678 rhs.unsignedp = true;
1679 lhs.unsignedp = true;
1680 i = precision - i - 1;
1681 sub = num_lshift (rhs, precision, i);
1683 result.high = result.low = 0;
1686 if (num_greater_eq (lhs, sub, precision))
1688 lhs = num_binary_op (pfile, lhs, sub, CPP_MINUS);
1689 if (i >= PART_PRECISION)
1690 result.high |= (cpp_num_part) 1 << (i - PART_PRECISION);
1692 result.low |= (cpp_num_part) 1 << i;
1696 sub.low = (sub.low >> 1) | (sub.high << (PART_PRECISION - 1));
1700 /* We divide so that the remainder has the sign of the LHS. */
1703 result.unsignedp = unsignedp;
1704 result.overflow = false;
1708 result = num_negate (result, precision);
1709 result.overflow = (num_positive (result, precision) ^ !negate
1710 && !num_zerop (result));
1717 lhs.unsignedp = unsignedp;
1718 lhs.overflow = false;
1720 lhs = num_negate (lhs, precision);