1 /* Parse C expressions for cpplib.
2 Copyright (C) 1987, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2001,
3 2002, 2004, 2008 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, 51 Franklin Street, Fifth Floor,
19 Boston, MA 02110-1301, USA. */
26 #define PART_PRECISION (sizeof (cpp_num_part) * CHAR_BIT)
27 #define HALF_MASK (~(cpp_num_part) 0 >> (PART_PRECISION / 2))
28 #define LOW_PART(num_part) (num_part & HALF_MASK)
29 #define HIGH_PART(num_part) (num_part >> (PART_PRECISION / 2))
33 const cpp_token
*token
; /* The token forming op (for diagnostics). */
34 cpp_num value
; /* The value logically "right" of op. */
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
)
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
;
881 /* These tokens convert into values. */
890 SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
891 cpp_token_as_text (pfile
, op
.token
));
893 top
->value
= eval_token (pfile
, op
.token
);
897 saw_leading_not
= lex_count
== 1;
909 if ((int) op
.op
<= (int) CPP_EQ
|| (int) op
.op
>= (int) CPP_PLUS_EQ
)
910 SYNTAX_ERROR2 ("token \"%s\" is not valid in preprocessor expressions",
911 cpp_token_as_text (pfile
, op
.token
));
915 /* Check we have a value or operator as appropriate. */
916 if (optab
[op
.op
].flags
& NO_L_OPERAND
)
919 SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
920 cpp_token_as_text (pfile
, op
.token
));
924 /* We want a number (or expression) and haven't got one.
925 Try to emit a specific diagnostic. */
926 if (op
.op
== CPP_CLOSE_PAREN
&& top
->op
== CPP_OPEN_PAREN
)
927 SYNTAX_ERROR ("missing expression between '(' and ')'");
929 if (op
.op
== CPP_EOF
&& top
->op
== CPP_EOF
)
930 SYNTAX_ERROR ("#if with no expression");
932 if (top
->op
!= CPP_EOF
&& top
->op
!= CPP_OPEN_PAREN
)
933 SYNTAX_ERROR2 ("operator '%s' has no right operand",
934 cpp_token_as_text (pfile
, top
->token
));
935 else if (op
.op
== CPP_CLOSE_PAREN
|| op
.op
== CPP_EOF
)
936 /* Complain about missing paren during reduction. */;
938 SYNTAX_ERROR2 ("operator '%s' has no left operand",
939 cpp_token_as_text (pfile
, op
.token
));
942 top
= reduce (pfile
, top
, op
.op
);
946 if (op
.op
== CPP_EOF
)
951 case CPP_CLOSE_PAREN
:
954 if (!num_zerop (top
->value
))
955 pfile
->state
.skip_eval
++;
959 if (num_zerop (top
->value
))
960 pfile
->state
.skip_eval
++;
963 if (top
->op
!= CPP_QUERY
)
964 SYNTAX_ERROR (" ':' without preceding '?'");
965 if (!num_zerop (top
[-1].value
)) /* Was '?' condition true? */
966 pfile
->state
.skip_eval
++;
968 pfile
->state
.skip_eval
--;
975 /* Check for and handle stack overflow. */
976 if (++top
== pfile
->op_limit
)
977 top
= _cpp_expand_op_stack (pfile
);
980 top
->token
= op
.token
;
983 /* The controlling macro expression is only valid if we called lex 3
984 times: <!> <defined expression> and <EOF>. push_conditional ()
985 checks that we are at top-of-file. */
986 if (pfile
->mi_ind_cmacro
&& !(saw_leading_not
&& lex_count
== 3))
987 pfile
->mi_ind_cmacro
= 0;
989 if (top
!= pfile
->op_stack
)
991 cpp_error (pfile
, CPP_DL_ICE
, "unbalanced stack in #if");
993 return false; /* Return false on syntax error. */
996 return !num_zerop (top
->value
);
999 /* Reduce the operator / value stack if possible, in preparation for
1000 pushing operator OP. Returns NULL on error, otherwise the top of
1003 reduce (cpp_reader
*pfile
, struct op
*top
, enum cpp_ttype op
)
1007 if (top
->op
<= CPP_EQ
|| top
->op
> CPP_LAST_CPP_OP
+ 2)
1010 cpp_error (pfile
, CPP_DL_ICE
, "impossible operator '%u'", top
->op
);
1014 if (op
== CPP_OPEN_PAREN
)
1017 /* Decrement the priority of left-associative operators to force a
1018 reduction with operators of otherwise equal priority. */
1019 prio
= optab
[op
].prio
- ((optab
[op
].flags
& LEFT_ASSOC
) != 0);
1020 while (prio
< optab
[top
->op
].prio
)
1022 if (CPP_OPTION (pfile
, warn_num_sign_change
)
1023 && optab
[top
->op
].flags
& CHECK_PROMOTION
)
1024 check_promotion (pfile
, top
);
1032 top
[-1].value
= num_unary_op (pfile
, top
->value
, top
->op
);
1040 top
[-1].value
= num_binary_op (pfile
, top
[-1].value
,
1041 top
->value
, top
->op
);
1046 case CPP_GREATER_EQ
:
1049 = num_inequality_op (pfile
, top
[-1].value
, top
->value
, top
->op
);
1055 = num_equality_op (pfile
, top
[-1].value
, top
->value
, top
->op
);
1062 = num_bitwise_op (pfile
, top
[-1].value
, top
->value
, top
->op
);
1066 top
[-1].value
= num_mul (pfile
, top
[-1].value
, top
->value
);
1071 top
[-1].value
= num_div_op (pfile
, top
[-1].value
,
1072 top
->value
, top
->op
);
1077 if (!num_zerop (top
->value
))
1078 pfile
->state
.skip_eval
--;
1079 top
->value
.low
= (!num_zerop (top
->value
)
1080 || !num_zerop (top
[1].value
));
1081 top
->value
.high
= 0;
1082 top
->value
.unsignedp
= false;
1083 top
->value
.overflow
= false;
1088 if (num_zerop (top
->value
))
1089 pfile
->state
.skip_eval
--;
1090 top
->value
.low
= (!num_zerop (top
->value
)
1091 && !num_zerop (top
[1].value
));
1092 top
->value
.high
= 0;
1093 top
->value
.unsignedp
= false;
1094 top
->value
.overflow
= false;
1097 case CPP_OPEN_PAREN
:
1098 if (op
!= CPP_CLOSE_PAREN
)
1100 cpp_error (pfile
, CPP_DL_ERROR
, "missing ')' in expression");
1104 top
->value
= top
[1].value
;
1109 if (!num_zerop (top
->value
))
1111 pfile
->state
.skip_eval
--;
1112 top
->value
= top
[1].value
;
1115 top
->value
= top
[2].value
;
1116 top
->value
.unsignedp
= (top
[1].value
.unsignedp
1117 || top
[2].value
.unsignedp
);
1121 /* COMMA and COLON should not reduce a QUERY operator. */
1122 if (op
== CPP_COMMA
|| op
== CPP_COLON
)
1124 cpp_error (pfile
, CPP_DL_ERROR
, "'?' without following ':'");
1132 if (top
->value
.overflow
&& !pfile
->state
.skip_eval
)
1133 cpp_error (pfile
, CPP_DL_PEDWARN
,
1134 "integer overflow in preprocessor expression");
1137 if (op
== CPP_CLOSE_PAREN
)
1139 cpp_error (pfile
, CPP_DL_ERROR
, "missing '(' in expression");
1146 /* Returns the position of the old top of stack after expansion. */
1148 _cpp_expand_op_stack (cpp_reader
*pfile
)
1150 size_t old_size
= (size_t) (pfile
->op_limit
- pfile
->op_stack
);
1151 size_t new_size
= old_size
* 2 + 20;
1153 pfile
->op_stack
= XRESIZEVEC (struct op
, pfile
->op_stack
, new_size
);
1154 pfile
->op_limit
= pfile
->op_stack
+ new_size
;
1156 return pfile
->op_stack
+ old_size
;
1159 /* Emits a warning if the effective sign of either operand of OP
1160 changes because of integer promotions. */
1162 check_promotion (cpp_reader
*pfile
, const struct op
*op
)
1164 if (op
->value
.unsignedp
== op
[-1].value
.unsignedp
)
1167 if (op
->value
.unsignedp
)
1169 if (!num_positive (op
[-1].value
, CPP_OPTION (pfile
, precision
)))
1170 cpp_error (pfile
, CPP_DL_WARNING
,
1171 "the left operand of \"%s\" changes sign when promoted",
1172 cpp_token_as_text (pfile
, op
->token
));
1174 else if (!num_positive (op
->value
, CPP_OPTION (pfile
, precision
)))
1175 cpp_error (pfile
, CPP_DL_WARNING
,
1176 "the right operand of \"%s\" changes sign when promoted",
1177 cpp_token_as_text (pfile
, op
->token
));
1180 /* Clears the unused high order bits of the number pointed to by PNUM. */
1182 num_trim (cpp_num num
, size_t precision
)
1184 if (precision
> PART_PRECISION
)
1186 precision
-= PART_PRECISION
;
1187 if (precision
< PART_PRECISION
)
1188 num
.high
&= ((cpp_num_part
) 1 << precision
) - 1;
1192 if (precision
< PART_PRECISION
)
1193 num
.low
&= ((cpp_num_part
) 1 << precision
) - 1;
1200 /* True iff A (presumed signed) >= 0. */
1202 num_positive (cpp_num num
, size_t precision
)
1204 if (precision
> PART_PRECISION
)
1206 precision
-= PART_PRECISION
;
1207 return (num
.high
& (cpp_num_part
) 1 << (precision
- 1)) == 0;
1210 return (num
.low
& (cpp_num_part
) 1 << (precision
- 1)) == 0;
1213 /* Sign extend a number, with PRECISION significant bits and all
1214 others assumed clear, to fill out a cpp_num structure. */
1216 cpp_num_sign_extend (cpp_num num
, size_t precision
)
1220 if (precision
> PART_PRECISION
)
1222 precision
-= PART_PRECISION
;
1223 if (precision
< PART_PRECISION
1224 && (num
.high
& (cpp_num_part
) 1 << (precision
- 1)))
1225 num
.high
|= ~(~(cpp_num_part
) 0 >> (PART_PRECISION
- precision
));
1227 else if (num
.low
& (cpp_num_part
) 1 << (precision
- 1))
1229 if (precision
< PART_PRECISION
)
1230 num
.low
|= ~(~(cpp_num_part
) 0 >> (PART_PRECISION
- precision
));
1231 num
.high
= ~(cpp_num_part
) 0;
1238 /* Returns the negative of NUM. */
1240 num_negate (cpp_num num
, size_t precision
)
1245 num
.high
= ~num
.high
;
1249 num
= num_trim (num
, precision
);
1250 num
.overflow
= (!num
.unsignedp
&& num_eq (num
, copy
) && !num_zerop (num
));
1255 /* Returns true if A >= B. */
1257 num_greater_eq (cpp_num pa
, cpp_num pb
, size_t precision
)
1261 unsignedp
= pa
.unsignedp
|| pb
.unsignedp
;
1265 /* Both numbers have signed type. If they are of different
1266 sign, the answer is the sign of A. */
1267 unsignedp
= num_positive (pa
, precision
);
1269 if (unsignedp
!= num_positive (pb
, precision
))
1272 /* Otherwise we can do an unsigned comparison. */
1275 return (pa
.high
> pb
.high
) || (pa
.high
== pb
.high
&& pa
.low
>= pb
.low
);
1278 /* Returns LHS OP RHS, where OP is a bit-wise operation. */
1280 num_bitwise_op (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1281 cpp_num lhs
, cpp_num rhs
, enum cpp_ttype op
)
1283 lhs
.overflow
= false;
1284 lhs
.unsignedp
= lhs
.unsignedp
|| rhs
.unsignedp
;
1286 /* As excess precision is zeroed, there is no need to num_trim () as
1287 these operations cannot introduce a set bit there. */
1291 lhs
.high
&= rhs
.high
;
1293 else if (op
== CPP_OR
)
1296 lhs
.high
|= rhs
.high
;
1301 lhs
.high
^= rhs
.high
;
1307 /* Returns LHS OP RHS, where OP is an inequality. */
1309 num_inequality_op (cpp_reader
*pfile
, cpp_num lhs
, cpp_num rhs
,
1312 bool gte
= num_greater_eq (lhs
, rhs
, CPP_OPTION (pfile
, precision
));
1314 if (op
== CPP_GREATER_EQ
)
1316 else if (op
== CPP_LESS
)
1318 else if (op
== CPP_GREATER
)
1319 lhs
.low
= gte
&& !num_eq (lhs
, rhs
);
1320 else /* CPP_LESS_EQ. */
1321 lhs
.low
= !gte
|| num_eq (lhs
, rhs
);
1324 lhs
.overflow
= false;
1325 lhs
.unsignedp
= false;
1329 /* Returns LHS OP RHS, where OP is == or !=. */
1331 num_equality_op (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1332 cpp_num lhs
, cpp_num rhs
, enum cpp_ttype op
)
1334 /* Work around a 3.0.4 bug; see PR 6950. */
1335 bool eq
= num_eq (lhs
, rhs
);
1336 if (op
== CPP_NOT_EQ
)
1340 lhs
.overflow
= false;
1341 lhs
.unsignedp
= false;
1345 /* Shift NUM, of width PRECISION, right by N bits. */
1347 num_rshift (cpp_num num
, size_t precision
, size_t n
)
1349 cpp_num_part sign_mask
;
1350 bool x
= num_positive (num
, precision
);
1352 if (num
.unsignedp
|| x
)
1355 sign_mask
= ~(cpp_num_part
) 0;
1358 num
.high
= num
.low
= sign_mask
;
1362 if (precision
< PART_PRECISION
)
1363 num
.high
= sign_mask
, num
.low
|= sign_mask
<< precision
;
1364 else if (precision
< 2 * PART_PRECISION
)
1365 num
.high
|= sign_mask
<< (precision
- PART_PRECISION
);
1367 if (n
>= PART_PRECISION
)
1369 n
-= PART_PRECISION
;
1371 num
.high
= sign_mask
;
1376 num
.low
= (num
.low
>> n
) | (num
.high
<< (PART_PRECISION
- n
));
1377 num
.high
= (num
.high
>> n
) | (sign_mask
<< (PART_PRECISION
- n
));
1381 num
= num_trim (num
, precision
);
1382 num
.overflow
= false;
1386 /* Shift NUM, of width PRECISION, left by N bits. */
1388 num_lshift (cpp_num num
, size_t precision
, size_t n
)
1392 num
.overflow
= !num
.unsignedp
&& !num_zerop (num
);
1393 num
.high
= num
.low
= 0;
1397 cpp_num orig
, maybe_orig
;
1401 if (m
>= PART_PRECISION
)
1403 m
-= PART_PRECISION
;
1409 num
.high
= (num
.high
<< m
) | (num
.low
>> (PART_PRECISION
- m
));
1412 num
= num_trim (num
, precision
);
1415 num
.overflow
= false;
1418 maybe_orig
= num_rshift (num
, precision
, n
);
1419 num
.overflow
= !num_eq (orig
, maybe_orig
);
1426 /* The four unary operators: +, -, ! and ~. */
1428 num_unary_op (cpp_reader
*pfile
, cpp_num num
, enum cpp_ttype op
)
1433 if (CPP_WTRADITIONAL (pfile
) && !pfile
->state
.skip_eval
)
1434 cpp_error (pfile
, CPP_DL_WARNING
,
1435 "traditional C rejects the unary plus operator");
1436 num
.overflow
= false;
1440 num
= num_negate (num
, CPP_OPTION (pfile
, precision
));
1444 num
.high
= ~num
.high
;
1446 num
= num_trim (num
, CPP_OPTION (pfile
, precision
));
1447 num
.overflow
= false;
1450 default: /* case CPP_NOT: */
1451 num
.low
= num_zerop (num
);
1453 num
.overflow
= false;
1454 num
.unsignedp
= false;
1461 /* The various binary operators. */
1463 num_binary_op (cpp_reader
*pfile
, cpp_num lhs
, cpp_num rhs
, enum cpp_ttype op
)
1466 size_t precision
= CPP_OPTION (pfile
, precision
);
1474 if (!rhs
.unsignedp
&& !num_positive (rhs
, precision
))
1476 /* A negative shift is a positive shift the other way. */
1477 if (op
== CPP_LSHIFT
)
1481 rhs
= num_negate (rhs
, precision
);
1484 n
= ~0; /* Maximal. */
1487 if (op
== CPP_LSHIFT
)
1488 lhs
= num_lshift (lhs
, precision
, n
);
1490 lhs
= num_rshift (lhs
, precision
, n
);
1495 rhs
= num_negate (rhs
, precision
);
1497 result
.low
= lhs
.low
+ rhs
.low
;
1498 result
.high
= lhs
.high
+ rhs
.high
;
1499 if (result
.low
< lhs
.low
)
1501 result
.unsignedp
= lhs
.unsignedp
|| rhs
.unsignedp
;
1502 result
.overflow
= false;
1504 result
= num_trim (result
, precision
);
1505 if (!result
.unsignedp
)
1507 bool lhsp
= num_positive (lhs
, precision
);
1508 result
.overflow
= (lhsp
== num_positive (rhs
, precision
)
1509 && lhsp
!= num_positive (result
, precision
));
1514 default: /* case CPP_COMMA: */
1515 if (CPP_PEDANTIC (pfile
) && (!CPP_OPTION (pfile
, c99
)
1516 || !pfile
->state
.skip_eval
))
1517 cpp_error (pfile
, CPP_DL_PEDWARN
,
1518 "comma operator in operand of #if");
1526 /* Multiplies two unsigned cpp_num_parts to give a cpp_num. This
1529 num_part_mul (cpp_num_part lhs
, cpp_num_part rhs
)
1532 cpp_num_part middle
[2], temp
;
1534 result
.low
= LOW_PART (lhs
) * LOW_PART (rhs
);
1535 result
.high
= HIGH_PART (lhs
) * HIGH_PART (rhs
);
1537 middle
[0] = LOW_PART (lhs
) * HIGH_PART (rhs
);
1538 middle
[1] = HIGH_PART (lhs
) * LOW_PART (rhs
);
1541 result
.low
+= LOW_PART (middle
[0]) << (PART_PRECISION
/ 2);
1542 if (result
.low
< temp
)
1546 result
.low
+= LOW_PART (middle
[1]) << (PART_PRECISION
/ 2);
1547 if (result
.low
< temp
)
1550 result
.high
+= HIGH_PART (middle
[0]);
1551 result
.high
+= HIGH_PART (middle
[1]);
1552 result
.unsignedp
= true;
1553 result
.overflow
= false;
1558 /* Multiply two preprocessing numbers. */
1560 num_mul (cpp_reader
*pfile
, cpp_num lhs
, cpp_num rhs
)
1562 cpp_num result
, temp
;
1563 bool unsignedp
= lhs
.unsignedp
|| rhs
.unsignedp
;
1564 bool overflow
, negate
= false;
1565 size_t precision
= CPP_OPTION (pfile
, precision
);
1567 /* Prepare for unsigned multiplication. */
1570 if (!num_positive (lhs
, precision
))
1571 negate
= !negate
, lhs
= num_negate (lhs
, precision
);
1572 if (!num_positive (rhs
, precision
))
1573 negate
= !negate
, rhs
= num_negate (rhs
, precision
);
1576 overflow
= lhs
.high
&& rhs
.high
;
1577 result
= num_part_mul (lhs
.low
, rhs
.low
);
1579 temp
= num_part_mul (lhs
.high
, rhs
.low
);
1580 result
.high
+= temp
.low
;
1584 temp
= num_part_mul (lhs
.low
, rhs
.high
);
1585 result
.high
+= temp
.low
;
1589 temp
.low
= result
.low
, temp
.high
= result
.high
;
1590 result
= num_trim (result
, precision
);
1591 if (!num_eq (result
, temp
))
1595 result
= num_negate (result
, precision
);
1598 result
.overflow
= false;
1600 result
.overflow
= overflow
|| (num_positive (result
, precision
) ^ !negate
1601 && !num_zerop (result
));
1602 result
.unsignedp
= unsignedp
;
1607 /* Divide two preprocessing numbers, returning the answer or the
1608 remainder depending upon OP. */
1610 num_div_op (cpp_reader
*pfile
, cpp_num lhs
, cpp_num rhs
, enum cpp_ttype op
)
1612 cpp_num result
, sub
;
1614 bool unsignedp
= lhs
.unsignedp
|| rhs
.unsignedp
;
1615 bool negate
= false, lhs_neg
= false;
1616 size_t i
, precision
= CPP_OPTION (pfile
, precision
);
1618 /* Prepare for unsigned division. */
1621 if (!num_positive (lhs
, precision
))
1622 negate
= !negate
, lhs_neg
= true, lhs
= num_negate (lhs
, precision
);
1623 if (!num_positive (rhs
, precision
))
1624 negate
= !negate
, rhs
= num_negate (rhs
, precision
);
1627 /* Find the high bit. */
1631 mask
= (cpp_num_part
) 1 << (i
- PART_PRECISION
);
1632 for (; ; i
--, mask
>>= 1)
1633 if (rhs
.high
& mask
)
1638 if (precision
> PART_PRECISION
)
1639 i
= precision
- PART_PRECISION
- 1;
1642 mask
= (cpp_num_part
) 1 << i
;
1643 for (; ; i
--, mask
>>= 1)
1649 if (!pfile
->state
.skip_eval
)
1650 cpp_error (pfile
, CPP_DL_ERROR
, "division by zero in #if");
1654 /* First nonzero bit of RHS is bit I. Do naive division by
1655 shifting the RHS fully left, and subtracting from LHS if LHS is
1656 at least as big, and then repeating but with one less shift.
1657 This is not very efficient, but is easy to understand. */
1659 rhs
.unsignedp
= true;
1660 lhs
.unsignedp
= true;
1661 i
= precision
- i
- 1;
1662 sub
= num_lshift (rhs
, precision
, i
);
1664 result
.high
= result
.low
= 0;
1667 if (num_greater_eq (lhs
, sub
, precision
))
1669 lhs
= num_binary_op (pfile
, lhs
, sub
, CPP_MINUS
);
1670 if (i
>= PART_PRECISION
)
1671 result
.high
|= (cpp_num_part
) 1 << (i
- PART_PRECISION
);
1673 result
.low
|= (cpp_num_part
) 1 << i
;
1677 sub
.low
= (sub
.low
>> 1) | (sub
.high
<< (PART_PRECISION
- 1));
1681 /* We divide so that the remainder has the sign of the LHS. */
1684 result
.unsignedp
= unsignedp
;
1685 result
.overflow
= false;
1689 result
= num_negate (result
, precision
);
1690 result
.overflow
= (num_positive (result
, precision
) ^ !negate
1691 && !num_zerop (result
));
1698 lhs
.unsignedp
= unsignedp
;
1699 lhs
.overflow
= false;
1701 lhs
= num_negate (lhs
, precision
);