1 /* Parse C expressions for cpplib.
2 Copyright (C) 1987-2019 Free Software Foundation, Inc.
3 Contributed by Per Bothner, 1994.
5 This program is free software; you can redistribute it and/or modify it
6 under the terms of the GNU General Public License as published by the
7 Free Software Foundation; either version 3, or (at your option) any
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; see the file COPYING3. If not see
17 <http://www.gnu.org/licenses/>. */
24 #define PART_PRECISION (sizeof (cpp_num_part) * CHAR_BIT)
25 #define HALF_MASK (~(cpp_num_part) 0 >> (PART_PRECISION / 2))
26 #define LOW_PART(num_part) (num_part & HALF_MASK)
27 #define HIGH_PART(num_part) (num_part >> (PART_PRECISION / 2))
31 const cpp_token
*token
; /* The token forming op (for diagnostics). */
32 cpp_num value
; /* The value logically "right" of op. */
33 location_t loc
; /* The location of this value. */
37 /* Some simple utility routines on double integers. */
38 #define num_zerop(num) ((num.low | num.high) == 0)
39 #define num_eq(num1, num2) (num1.low == num2.low && num1.high == num2.high)
40 static bool num_positive (cpp_num
, size_t);
41 static bool num_greater_eq (cpp_num
, cpp_num
, size_t);
42 static cpp_num
num_trim (cpp_num
, size_t);
43 static cpp_num
num_part_mul (cpp_num_part
, cpp_num_part
);
45 static cpp_num
num_unary_op (cpp_reader
*, cpp_num
, enum cpp_ttype
);
46 static cpp_num
num_binary_op (cpp_reader
*, cpp_num
, cpp_num
, enum cpp_ttype
);
47 static cpp_num
num_negate (cpp_num
, size_t);
48 static cpp_num
num_bitwise_op (cpp_reader
*, cpp_num
, cpp_num
, enum cpp_ttype
);
49 static cpp_num
num_inequality_op (cpp_reader
*, cpp_num
, cpp_num
,
51 static cpp_num
num_equality_op (cpp_reader
*, cpp_num
, cpp_num
,
53 static cpp_num
num_mul (cpp_reader
*, cpp_num
, cpp_num
);
54 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
*, location_t
);
62 static struct op
*reduce (cpp_reader
*, struct op
*, enum cpp_ttype
);
63 static unsigned int interpret_float_suffix (cpp_reader
*, const uchar
*, size_t);
64 static unsigned int interpret_int_suffix (cpp_reader
*, const uchar
*, size_t);
65 static void check_promotion (cpp_reader
*, const struct op
*);
67 static cpp_num
parse_has_include (cpp_reader
*, enum include_type
);
69 /* Token type abuse to create unary plus and minus operators. */
70 #define CPP_UPLUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 1))
71 #define CPP_UMINUS ((enum cpp_ttype) (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, CPP_DL_ERROR, msgid); goto syntax_error; } while(0)
77 #define SYNTAX_ERROR2(msgid, arg) \
78 do { cpp_error (pfile, CPP_DL_ERROR, msgid, arg); goto syntax_error; } \
80 #define SYNTAX_ERROR_AT(loc, msgid) \
81 do { cpp_error_with_line (pfile, CPP_DL_ERROR, (loc), 0, msgid); goto syntax_error; } \
83 #define SYNTAX_ERROR2_AT(loc, msgid, arg) \
84 do { cpp_error_with_line (pfile, CPP_DL_ERROR, (loc), 0, msgid, arg); goto syntax_error; } \
87 /* Subroutine of cpp_classify_number. S points to a float suffix of
88 length LEN, possibly zero. Returns 0 for an invalid suffix, or a
89 flag vector (of CPP_N_* bits) describing the suffix. */
91 interpret_float_suffix (cpp_reader
*pfile
, const uchar
*s
, size_t len
)
93 size_t orig_len
= len
;
94 const uchar
*orig_s
= s
;
96 size_t f
, d
, l
, w
, q
, i
, fn
, fnx
, fn_bits
;
99 f
= d
= l
= w
= q
= i
= fn
= fnx
= fn_bits
= 0;
101 /* The following decimal float suffixes, from TR 24732:2009 and TS
102 18661-2:2015, are supported:
106 dl, DL - _Decimal128.
108 The dN and DN suffixes for _DecimalN, and dNx and DNx for
109 _DecimalNx, defined in TS 18661-3:2015, are not supported.
111 Fixed-point suffixes, from TR 18037:2008, are supported. They
112 consist of three parts, in order:
114 (i) An optional u or U, for unsigned types.
116 (ii) An optional h or H, for short types, or l or L, for long
117 types, or ll or LL, for long long types. Use of ll or LL is a
120 (iii) r or R, for _Fract types, or k or K, for _Accum types.
122 Otherwise the suffix is for a binary or standard floating-point
123 type. Such a suffix, or the absence of a suffix, may be preceded
124 or followed by i, I, j or J, to indicate an imaginary number with
125 the corresponding complex type. The following suffixes for
126 binary or standard floating-point types are supported:
128 f, F - float (ISO C and C++).
129 l, L - long double (ISO C and C++).
130 d, D - double, even with the FLOAT_CONST_DECIMAL64 pragma in
131 operation (from TR 24732:2009; the pragma and the suffix
132 are not included in TS 18661-2:2015).
133 w, W - machine-specific type such as __float80 (GNU extension).
134 q, Q - machine-specific type such as __float128 (GNU extension).
135 fN, FN - _FloatN (TS 18661-3:2015).
136 fNx, FNx - _FloatNx (TS 18661-3:2015). */
138 /* Process decimal float suffixes, which are two letters starting
139 with d or D. Order and case are significant. */
140 if (len
== 2 && (*s
== 'd' || *s
== 'D'))
142 bool uppercase
= (*s
== 'D');
145 case 'f': return (!uppercase
? (CPP_N_DFLOAT
| CPP_N_SMALL
): 0); break;
146 case 'F': return (uppercase
? (CPP_N_DFLOAT
| CPP_N_SMALL
) : 0); break;
147 case 'd': return (!uppercase
? (CPP_N_DFLOAT
| CPP_N_MEDIUM
): 0); break;
148 case 'D': return (uppercase
? (CPP_N_DFLOAT
| CPP_N_MEDIUM
) : 0); break;
149 case 'l': return (!uppercase
? (CPP_N_DFLOAT
| CPP_N_LARGE
) : 0); break;
150 case 'L': return (uppercase
? (CPP_N_DFLOAT
| CPP_N_LARGE
) : 0); break;
152 /* Additional two-character suffixes beginning with D are not
153 for decimal float constants. */
158 if (CPP_OPTION (pfile
, ext_numeric_literals
))
160 /* Recognize a fixed-point suffix. */
164 case 'k': case 'K': flags
= CPP_N_ACCUM
; break;
165 case 'r': case 'R': flags
= CPP_N_FRACT
; break;
169 /* Continue processing a fixed-point suffix. The suffix is case
170 insensitive except for ll or LL. Order is significant. */
177 if (*s
== 'u' || *s
== 'U')
179 flags
|= CPP_N_UNSIGNED
;
190 return flags
|= CPP_N_SMALL
;
194 return flags
|= CPP_N_MEDIUM
;
195 if (len
== 2 && s
[1] == 'l')
196 return flags
|= CPP_N_LARGE
;
200 return flags
|= CPP_N_MEDIUM
;
201 if (len
== 2 && s
[1] == 'L')
202 return flags
|= CPP_N_LARGE
;
207 /* Anything left at this point is invalid. */
212 /* In any remaining valid suffix, the case and order don't matter. */
220 && !CPP_OPTION (pfile
, cplusplus
)
229 && fn_bits
< CPP_FLOATN_MAX
)
231 fn_bits
= fn_bits
* 10 + (s
[1] - '0');
235 if (len
> 0 && s
[1] == 'x')
245 case 'd': case 'D': d
++; break;
246 case 'l': case 'L': l
++; break;
247 case 'w': case 'W': w
++; break;
248 case 'q': case 'Q': q
++; break;
250 case 'j': case 'J': i
++; break;
257 /* Reject any case of multiple suffixes specifying types, multiple
258 suffixes specifying an imaginary constant, _FloatN or _FloatNx
259 suffixes for invalid values of N, and _FloatN suffixes for values
260 of N larger than can be represented in the return value. The
261 caller is responsible for rejecting _FloatN suffixes where
262 _FloatN is not supported on the chosen target. */
263 if (f
+ d
+ l
+ w
+ q
+ fn
+ fnx
> 1 || i
> 1)
265 if (fn_bits
> CPP_FLOATN_MAX
)
267 if (fnx
&& fn_bits
!= 32 && fn_bits
!= 64 && fn_bits
!= 128)
269 if (fn
&& fn_bits
!= 16 && fn_bits
% 32 != 0)
271 if (fn
&& fn_bits
== 96)
276 if (!CPP_OPTION (pfile
, ext_numeric_literals
))
279 /* In C++14 and up these suffixes are in the standard library, so treat
280 them as user-defined literals. */
281 if (CPP_OPTION (pfile
, cplusplus
)
282 && CPP_OPTION (pfile
, lang
) > CLK_CXX11
286 && (orig_s
[1] == 'f' || orig_s
[1] == 'l'))))
290 if ((w
|| q
) && !CPP_OPTION (pfile
, ext_numeric_literals
))
293 return ((i
? CPP_N_IMAGINARY
: 0)
299 fn
? CPP_N_FLOATN
| (fn_bits
<< CPP_FLOATN_SHIFT
) :
300 fnx
? CPP_N_FLOATNX
| (fn_bits
<< CPP_FLOATN_SHIFT
) :
304 /* Return the classification flags for a float suffix. */
306 cpp_interpret_float_suffix (cpp_reader
*pfile
, const char *s
, size_t len
)
308 return interpret_float_suffix (pfile
, (const unsigned char *)s
, len
);
311 /* Subroutine of cpp_classify_number. S points to an integer suffix
312 of length LEN, possibly zero. Returns 0 for an invalid suffix, or a
313 flag vector describing the suffix. */
315 interpret_int_suffix (cpp_reader
*pfile
, const uchar
*s
, size_t len
)
317 size_t orig_len
= len
;
325 case 'u': case 'U': u
++; break;
327 case 'j': case 'J': i
++; break;
328 case 'l': case 'L': l
++;
329 /* If there are two Ls, they must be adjacent and the same case. */
330 if (l
== 2 && s
[len
] != s
[len
+ 1])
337 if (l
> 2 || u
> 1 || i
> 1)
342 if (!CPP_OPTION (pfile
, ext_numeric_literals
))
345 /* In C++14 and up these suffixes are in the standard library, so treat
346 them as user-defined literals. */
347 if (CPP_OPTION (pfile
, cplusplus
)
348 && CPP_OPTION (pfile
, lang
) > CLK_CXX11
350 && (orig_len
== 1 || (orig_len
== 2 && s
[1] == 'l')))
354 return ((i
? CPP_N_IMAGINARY
: 0)
355 | (u
? CPP_N_UNSIGNED
: 0)
356 | ((l
== 0) ? CPP_N_SMALL
357 : (l
== 1) ? CPP_N_MEDIUM
: CPP_N_LARGE
));
360 /* Return the classification flags for an int suffix. */
362 cpp_interpret_int_suffix (cpp_reader
*pfile
, const char *s
, size_t len
)
364 return interpret_int_suffix (pfile
, (const unsigned char *)s
, len
);
367 /* Return the string type corresponding to the the input user-defined string
368 literal type. If the input type is not a user-defined string literal
369 type return the input type. */
371 cpp_userdef_string_remove_type (enum cpp_ttype type
)
373 if (type
== CPP_STRING_USERDEF
)
375 else if (type
== CPP_WSTRING_USERDEF
)
377 else if (type
== CPP_STRING16_USERDEF
)
379 else if (type
== CPP_STRING32_USERDEF
)
381 else if (type
== CPP_UTF8STRING_USERDEF
)
382 return CPP_UTF8STRING
;
387 /* Return the user-defined string literal type corresponding to the input
388 string type. If the input type is not a string type return the input
391 cpp_userdef_string_add_type (enum cpp_ttype type
)
393 if (type
== CPP_STRING
)
394 return CPP_STRING_USERDEF
;
395 else if (type
== CPP_WSTRING
)
396 return CPP_WSTRING_USERDEF
;
397 else if (type
== CPP_STRING16
)
398 return CPP_STRING16_USERDEF
;
399 else if (type
== CPP_STRING32
)
400 return CPP_STRING32_USERDEF
;
401 else if (type
== CPP_UTF8STRING
)
402 return CPP_UTF8STRING_USERDEF
;
407 /* Return the char type corresponding to the the input user-defined char
408 literal type. If the input type is not a user-defined char literal
409 type return the input type. */
411 cpp_userdef_char_remove_type (enum cpp_ttype type
)
413 if (type
== CPP_CHAR_USERDEF
)
415 else if (type
== CPP_WCHAR_USERDEF
)
417 else if (type
== CPP_CHAR16_USERDEF
)
419 else if (type
== CPP_CHAR32_USERDEF
)
421 else if (type
== CPP_UTF8CHAR_USERDEF
)
427 /* Return the user-defined char literal type corresponding to the input
428 char type. If the input type is not a char type return the input
431 cpp_userdef_char_add_type (enum cpp_ttype type
)
433 if (type
== CPP_CHAR
)
434 return CPP_CHAR_USERDEF
;
435 else if (type
== CPP_WCHAR
)
436 return CPP_WCHAR_USERDEF
;
437 else if (type
== CPP_CHAR16
)
438 return CPP_CHAR16_USERDEF
;
439 else if (type
== CPP_CHAR32
)
440 return CPP_CHAR32_USERDEF
;
441 else if (type
== CPP_UTF8CHAR
)
442 return CPP_UTF8CHAR_USERDEF
;
447 /* Return true if the token type is a user-defined string literal. */
449 cpp_userdef_string_p (enum cpp_ttype type
)
451 if (type
== CPP_STRING_USERDEF
452 || type
== CPP_WSTRING_USERDEF
453 || type
== CPP_STRING16_USERDEF
454 || type
== CPP_STRING32_USERDEF
455 || type
== CPP_UTF8STRING_USERDEF
)
461 /* Return true if the token type is a user-defined char literal. */
463 cpp_userdef_char_p (enum cpp_ttype type
)
465 if (type
== CPP_CHAR_USERDEF
466 || type
== CPP_WCHAR_USERDEF
467 || type
== CPP_CHAR16_USERDEF
468 || type
== CPP_CHAR32_USERDEF
469 || type
== CPP_UTF8CHAR_USERDEF
)
475 /* Extract the suffix from a user-defined literal string or char. */
477 cpp_get_userdef_suffix (const cpp_token
*tok
)
479 unsigned int len
= tok
->val
.str
.len
;
480 const char *text
= (const char *)tok
->val
.str
.text
;
483 for (i
= 0; i
< len
; ++i
)
484 if (text
[i
] == '\'' || text
[i
] == '"')
489 for (i
= len
; i
> 0; --i
)
490 if (text
[i
- 1] == delim
)
495 /* Categorize numeric constants according to their field (integer,
496 floating point, or invalid), radix (decimal, octal, hexadecimal),
499 TOKEN is the token that represents the numeric constant to
502 In C++0X if UD_SUFFIX is non null it will be assigned
503 any unrecognized suffix for a user-defined literal.
505 VIRTUAL_LOCATION is the virtual location for TOKEN. */
507 cpp_classify_number (cpp_reader
*pfile
, const cpp_token
*token
,
508 const char **ud_suffix
, location_t virtual_location
)
510 const uchar
*str
= token
->val
.str
.text
;
512 unsigned int max_digit
, result
, radix
;
513 enum {NOT_FLOAT
= 0, AFTER_POINT
, AFTER_EXPON
} float_flag
;
520 /* If the lexer has done its job, length one can only be a single
521 digit. Fast-path this very common case. */
522 if (token
->val
.str
.len
== 1)
523 return CPP_N_INTEGER
| CPP_N_SMALL
| CPP_N_DECIMAL
;
525 limit
= str
+ token
->val
.str
.len
;
526 float_flag
= NOT_FLOAT
;
530 seen_digit_sep
= false;
532 /* First, interpret the radix. */
538 /* Require at least one hex digit to classify it as hex. */
539 if (*str
== 'x' || *str
== 'X')
541 if (str
[1] == '.' || ISXDIGIT (str
[1]))
546 else if (DIGIT_SEP (str
[1]))
547 SYNTAX_ERROR_AT (virtual_location
,
548 "digit separator after base indicator");
550 else if (*str
== 'b' || *str
== 'B')
552 if (str
[1] == '0' || str
[1] == '1')
557 else if (DIGIT_SEP (str
[1]))
558 SYNTAX_ERROR_AT (virtual_location
,
559 "digit separator after base indicator");
563 /* Now scan for a well-formed integer or float. */
566 unsigned int c
= *str
++;
568 if (ISDIGIT (c
) || (ISXDIGIT (c
) && radix
== 16))
570 seen_digit_sep
= false;
576 else if (DIGIT_SEP (c
))
579 SYNTAX_ERROR_AT (virtual_location
, "adjacent digit separators");
580 seen_digit_sep
= true;
584 if (seen_digit_sep
|| DIGIT_SEP (*str
))
585 SYNTAX_ERROR_AT (virtual_location
,
586 "digit separator adjacent to decimal point");
587 seen_digit_sep
= false;
588 if (float_flag
== NOT_FLOAT
)
589 float_flag
= AFTER_POINT
;
591 SYNTAX_ERROR_AT (virtual_location
,
592 "too many decimal points in number");
594 else if ((radix
<= 10 && (c
== 'e' || c
== 'E'))
595 || (radix
== 16 && (c
== 'p' || c
== 'P')))
597 if (seen_digit_sep
|| DIGIT_SEP (*str
))
598 SYNTAX_ERROR_AT (virtual_location
,
599 "digit separator adjacent to exponent");
600 float_flag
= AFTER_EXPON
;
605 /* Start of suffix. */
611 if (seen_digit_sep
&& float_flag
!= AFTER_EXPON
)
612 SYNTAX_ERROR_AT (virtual_location
,
613 "digit separator outside digit sequence");
615 /* The suffix may be for decimal fixed-point constants without exponent. */
616 if (radix
!= 16 && float_flag
== NOT_FLOAT
)
618 result
= interpret_float_suffix (pfile
, str
, limit
- str
);
619 if ((result
& CPP_N_FRACT
) || (result
& CPP_N_ACCUM
))
621 result
|= CPP_N_FLOATING
;
622 /* We need to restore the radix to 10, if the radix is 8. */
626 if (CPP_PEDANTIC (pfile
))
627 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
628 "fixed-point constants are a GCC extension");
635 if (float_flag
!= NOT_FLOAT
&& radix
== 8)
638 if (max_digit
>= radix
)
641 SYNTAX_ERROR2_AT (virtual_location
,
642 "invalid digit \"%c\" in binary constant", '0' + max_digit
);
644 SYNTAX_ERROR2_AT (virtual_location
,
645 "invalid digit \"%c\" in octal constant", '0' + max_digit
);
648 if (float_flag
!= NOT_FLOAT
)
652 cpp_error_with_line (pfile
, CPP_DL_ERROR
, virtual_location
, 0,
653 "invalid prefix \"0b\" for floating constant");
654 return CPP_N_INVALID
;
657 if (radix
== 16 && !seen_digit
)
658 SYNTAX_ERROR_AT (virtual_location
,
659 "no digits in hexadecimal floating constant");
661 if (radix
== 16 && CPP_PEDANTIC (pfile
)
662 && !CPP_OPTION (pfile
, extended_numbers
))
664 if (CPP_OPTION (pfile
, cplusplus
))
665 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
666 "use of C++17 hexadecimal floating constant");
668 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
669 "use of C99 hexadecimal floating constant");
672 if (float_flag
== AFTER_EXPON
)
674 if (*str
== '+' || *str
== '-')
677 /* Exponent is decimal, even if string is a hex float. */
680 if (DIGIT_SEP (*str
))
681 SYNTAX_ERROR_AT (virtual_location
,
682 "digit separator adjacent to exponent");
684 SYNTAX_ERROR_AT (virtual_location
, "exponent has no digits");
688 seen_digit_sep
= DIGIT_SEP (*str
);
691 while (ISDIGIT (*str
) || DIGIT_SEP (*str
));
693 else if (radix
== 16)
694 SYNTAX_ERROR_AT (virtual_location
,
695 "hexadecimal floating constants require an exponent");
698 SYNTAX_ERROR_AT (virtual_location
,
699 "digit separator outside digit sequence");
701 result
= interpret_float_suffix (pfile
, str
, limit
- str
);
704 if (CPP_OPTION (pfile
, user_literals
))
707 *ud_suffix
= (const char *) str
;
708 result
= CPP_N_LARGE
| CPP_N_USERDEF
;
712 cpp_error_with_line (pfile
, CPP_DL_ERROR
, virtual_location
, 0,
713 "invalid suffix \"%.*s\" on floating constant",
714 (int) (limit
- str
), str
);
715 return CPP_N_INVALID
;
719 /* Traditional C didn't accept any floating suffixes. */
721 && CPP_WTRADITIONAL (pfile
)
722 && ! cpp_sys_macro_p (pfile
))
723 cpp_warning_with_line (pfile
, CPP_W_TRADITIONAL
, virtual_location
, 0,
724 "traditional C rejects the \"%.*s\" suffix",
725 (int) (limit
- str
), str
);
727 /* A suffix for double is a GCC extension via decimal float support.
728 If the suffix also specifies an imaginary value we'll catch that
730 if ((result
== CPP_N_MEDIUM
) && CPP_PEDANTIC (pfile
))
731 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
732 "suffix for double constant is a GCC extension");
734 /* Radix must be 10 for decimal floats. */
735 if ((result
& CPP_N_DFLOAT
) && radix
!= 10)
737 cpp_error_with_line (pfile
, CPP_DL_ERROR
, virtual_location
, 0,
738 "invalid suffix \"%.*s\" with hexadecimal floating constant",
739 (int) (limit
- str
), str
);
740 return CPP_N_INVALID
;
743 if ((result
& (CPP_N_FRACT
| CPP_N_ACCUM
)) && CPP_PEDANTIC (pfile
))
744 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
745 "fixed-point constants are a GCC extension");
747 if ((result
& CPP_N_DFLOAT
) && CPP_PEDANTIC (pfile
))
748 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
749 "decimal float constants are a GCC extension");
751 result
|= CPP_N_FLOATING
;
755 result
= interpret_int_suffix (pfile
, str
, limit
- str
);
758 if (CPP_OPTION (pfile
, user_literals
))
761 *ud_suffix
= (const char *) str
;
762 result
= CPP_N_UNSIGNED
| CPP_N_LARGE
| CPP_N_USERDEF
;
766 cpp_error_with_line (pfile
, CPP_DL_ERROR
, virtual_location
, 0,
767 "invalid suffix \"%.*s\" on integer constant",
768 (int) (limit
- str
), str
);
769 return CPP_N_INVALID
;
773 /* Traditional C only accepted the 'L' suffix.
774 Suppress warning about 'LL' with -Wno-long-long. */
775 if (CPP_WTRADITIONAL (pfile
) && ! cpp_sys_macro_p (pfile
))
777 int u_or_i
= (result
& (CPP_N_UNSIGNED
|CPP_N_IMAGINARY
));
778 int large
= (result
& CPP_N_WIDTH
) == CPP_N_LARGE
779 && CPP_OPTION (pfile
, cpp_warn_long_long
);
782 cpp_warning_with_line (pfile
, large
? CPP_W_LONG_LONG
: CPP_W_TRADITIONAL
,
784 "traditional C rejects the \"%.*s\" suffix",
785 (int) (limit
- str
), str
);
788 if ((result
& CPP_N_WIDTH
) == CPP_N_LARGE
789 && CPP_OPTION (pfile
, cpp_warn_long_long
))
791 const char *message
= CPP_OPTION (pfile
, cplusplus
)
792 ? N_("use of C++11 long long integer constant")
793 : N_("use of C99 long long integer constant");
795 if (CPP_OPTION (pfile
, c99
))
796 cpp_warning_with_line (pfile
, CPP_W_LONG_LONG
, virtual_location
,
799 cpp_pedwarning_with_line (pfile
, CPP_W_LONG_LONG
,
800 virtual_location
, 0, message
);
803 result
|= CPP_N_INTEGER
;
807 if ((result
& CPP_N_IMAGINARY
) && CPP_PEDANTIC (pfile
))
808 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
809 "imaginary constants are a GCC extension");
811 && !CPP_OPTION (pfile
, binary_constants
)
812 && CPP_PEDANTIC (pfile
))
813 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
814 CPP_OPTION (pfile
, cplusplus
)
815 ? N_("binary constants are a C++14 feature "
817 : N_("binary constants are a GCC extension"));
820 result
|= CPP_N_DECIMAL
;
821 else if (radix
== 16)
824 result
|= CPP_N_BINARY
;
826 result
|= CPP_N_OCTAL
;
831 return CPP_N_INVALID
;
834 /* cpp_interpret_integer converts an integer constant into a cpp_num,
835 of precision options->precision.
837 We do not provide any interface for decimal->float conversion,
838 because the preprocessor doesn't need it and we don't want to
839 drag in GCC's floating point emulator. */
841 cpp_interpret_integer (cpp_reader
*pfile
, const cpp_token
*token
,
844 const uchar
*p
, *end
;
849 result
.unsignedp
= !!(type
& CPP_N_UNSIGNED
);
850 result
.overflow
= false;
852 p
= token
->val
.str
.text
;
853 end
= p
+ token
->val
.str
.len
;
855 /* Common case of a single digit. */
856 if (token
->val
.str
.len
== 1)
857 result
.low
= p
[0] - '0';
861 size_t precision
= CPP_OPTION (pfile
, precision
);
862 unsigned int base
= 10, c
= 0;
863 bool overflow
= false;
865 if ((type
& CPP_N_RADIX
) == CPP_N_OCTAL
)
870 else if ((type
& CPP_N_RADIX
) == CPP_N_HEX
)
875 else if ((type
& CPP_N_RADIX
) == CPP_N_BINARY
)
881 /* We can add a digit to numbers strictly less than this without
882 needing the precision and slowness of double integers. */
883 max
= ~(cpp_num_part
) 0;
884 if (precision
< PART_PRECISION
)
885 max
>>= PART_PRECISION
- precision
;
886 max
= (max
- base
+ 1) / base
+ 1;
892 if (ISDIGIT (c
) || (base
== 16 && ISXDIGIT (c
)))
894 else if (DIGIT_SEP (c
))
899 /* Strict inequality for when max is set to zero. */
900 if (result
.low
< max
)
901 result
.low
= result
.low
* base
+ c
;
904 result
= append_digit (result
, c
, base
, precision
);
905 overflow
|= result
.overflow
;
910 if (overflow
&& !(type
& CPP_N_USERDEF
))
911 cpp_error (pfile
, CPP_DL_PEDWARN
,
912 "integer constant is too large for its type");
913 /* If too big to be signed, consider it unsigned. Only warn for
914 decimal numbers. Traditional numbers were always signed (but
915 we still honor an explicit U suffix); but we only have
916 traditional semantics in directives. */
917 else if (!result
.unsignedp
918 && !(CPP_OPTION (pfile
, traditional
)
919 && pfile
->state
.in_directive
)
920 && !num_positive (result
, precision
))
922 /* This is for constants within the range of uintmax_t but
923 not that of intmax_t. For such decimal constants, a
924 diagnostic is required for C99 as the selected type must
925 be signed and not having a type is a constraint violation
926 (DR#298, TC3), so this must be a pedwarn. For C90,
927 unsigned long is specified to be used for a constant that
928 does not fit in signed long; if uintmax_t has the same
929 range as unsigned long this means only a warning is
930 appropriate here. C90 permits the preprocessor to use a
931 wider range than unsigned long in the compiler, so if
932 uintmax_t is wider than unsigned long no diagnostic is
933 required for such constants in preprocessor #if
934 expressions and the compiler will pedwarn for such
935 constants outside the range of unsigned long that reach
936 the compiler so a diagnostic is not required there
937 either; thus, pedwarn for C99 but use a plain warning for
940 cpp_error (pfile
, (CPP_OPTION (pfile
, c99
)
943 "integer constant is so large that it is unsigned");
944 result
.unsignedp
= true;
951 /* Append DIGIT to NUM, a number of PRECISION bits being read in base BASE. */
953 append_digit (cpp_num num
, int digit
, int base
, size_t precision
)
958 cpp_num_part add_high
, add_low
;
960 /* Multiply by 2, 8 or 16. Catching this overflow here means we don't
961 need to worry about add_high overflowing. */
975 overflow
= !!(num
.high
>> (PART_PRECISION
- shift
));
976 result
.high
= num
.high
<< shift
;
977 result
.low
= num
.low
<< shift
;
978 result
.high
|= num
.low
>> (PART_PRECISION
- shift
);
979 result
.unsignedp
= num
.unsignedp
;
983 add_low
= num
.low
<< 1;
984 add_high
= (num
.high
<< 1) + (num
.low
>> (PART_PRECISION
- 1));
987 add_high
= add_low
= 0;
989 if (add_low
+ digit
< add_low
)
993 if (result
.low
+ add_low
< result
.low
)
995 if (result
.high
+ add_high
< result
.high
)
998 result
.low
+= add_low
;
999 result
.high
+= add_high
;
1000 result
.overflow
= overflow
;
1002 /* The above code catches overflow of a cpp_num type. This catches
1003 overflow of the (possibly shorter) target precision. */
1004 num
.low
= result
.low
;
1005 num
.high
= result
.high
;
1006 result
= num_trim (result
, precision
);
1007 if (!num_eq (result
, num
))
1008 result
.overflow
= true;
1013 /* Handle meeting "defined" in a preprocessor expression. */
1015 parse_defined (cpp_reader
*pfile
)
1019 cpp_hashnode
*node
= 0;
1020 const cpp_token
*token
;
1021 cpp_context
*initial_context
= pfile
->context
;
1023 /* Don't expand macros. */
1024 pfile
->state
.prevent_expansion
++;
1026 token
= cpp_get_token (pfile
);
1027 if (token
->type
== CPP_OPEN_PAREN
)
1030 token
= cpp_get_token (pfile
);
1033 if (token
->type
== CPP_NAME
)
1035 node
= token
->val
.node
.node
;
1036 if (paren
&& cpp_get_token (pfile
)->type
!= CPP_CLOSE_PAREN
)
1038 cpp_error (pfile
, CPP_DL_ERROR
, "missing ')' after \"defined\"");
1044 cpp_error (pfile
, CPP_DL_ERROR
,
1045 "operator \"defined\" requires an identifier");
1046 if (token
->flags
& NAMED_OP
)
1051 op
.type
= token
->type
;
1052 cpp_error (pfile
, CPP_DL_ERROR
,
1053 "(\"%s\" is an alternative token for \"%s\" in C++)",
1054 cpp_token_as_text (pfile
, token
),
1055 cpp_token_as_text (pfile
, &op
));
1061 if ((pfile
->context
!= initial_context
1062 || initial_context
!= &pfile
->base_context
)
1063 && CPP_OPTION (pfile
, warn_expansion_to_defined
))
1064 cpp_pedwarning (pfile
, CPP_W_EXPANSION_TO_DEFINED
,
1065 "this use of \"defined\" may not be portable");
1067 _cpp_mark_macro_used (node
);
1068 _cpp_maybe_notify_macro_use (pfile
, node
);
1070 /* A possible controlling macro of the form #if !defined ().
1071 _cpp_parse_expr checks there was no other junk on the line. */
1072 pfile
->mi_ind_cmacro
= node
;
1075 pfile
->state
.prevent_expansion
--;
1077 /* Do not treat conditional macros as being defined. This is due to the
1078 powerpc and spu ports using conditional macros for 'vector', 'bool', and
1079 'pixel' to act as conditional keywords. This messes up tests like #ifndef
1081 result
.unsignedp
= false;
1083 result
.overflow
= false;
1084 result
.low
= (node
&& cpp_macro_p (node
)
1085 && !(node
->flags
& NODE_CONDITIONAL
));
1089 /* Convert a token into a CPP_NUMBER (an interpreted preprocessing
1090 number or character constant, or the result of the "defined" or "#"
1093 eval_token (cpp_reader
*pfile
, const cpp_token
*token
,
1094 location_t virtual_location
)
1100 result
.unsignedp
= false;
1101 result
.overflow
= false;
1103 switch (token
->type
)
1106 temp
= cpp_classify_number (pfile
, token
, NULL
, virtual_location
);
1107 if (temp
& CPP_N_USERDEF
)
1108 cpp_error (pfile
, CPP_DL_ERROR
,
1109 "user-defined literal in preprocessor expression");
1110 switch (temp
& CPP_N_CATEGORY
)
1112 case CPP_N_FLOATING
:
1113 cpp_error_with_line (pfile
, CPP_DL_ERROR
, virtual_location
, 0,
1114 "floating constant in preprocessor expression");
1117 if (!(temp
& CPP_N_IMAGINARY
))
1118 return cpp_interpret_integer (pfile
, token
, temp
);
1119 cpp_error_with_line (pfile
, CPP_DL_ERROR
, virtual_location
, 0,
1120 "imaginary number in preprocessor expression");
1124 /* Error already issued. */
1127 result
.high
= result
.low
= 0;
1136 cppchar_t cc
= cpp_interpret_charconst (pfile
, token
,
1141 /* Sign-extend the result if necessary. */
1142 if (!unsignedp
&& (cppchar_signed_t
) cc
< 0)
1144 if (PART_PRECISION
> BITS_PER_CPPCHAR_T
)
1145 result
.low
|= ~(~(cpp_num_part
) 0
1146 >> (PART_PRECISION
- BITS_PER_CPPCHAR_T
));
1147 result
.high
= ~(cpp_num_part
) 0;
1148 result
= num_trim (result
, CPP_OPTION (pfile
, precision
));
1154 if (token
->val
.node
.node
== pfile
->spec_nodes
.n_defined
)
1155 return parse_defined (pfile
);
1156 else if (token
->val
.node
.node
== pfile
->spec_nodes
.n__has_include__
)
1157 return parse_has_include (pfile
, IT_INCLUDE
);
1158 else if (token
->val
.node
.node
== pfile
->spec_nodes
.n__has_include_next__
)
1159 return parse_has_include (pfile
, IT_INCLUDE_NEXT
);
1160 else if (CPP_OPTION (pfile
, cplusplus
)
1161 && (token
->val
.node
.node
== pfile
->spec_nodes
.n_true
1162 || token
->val
.node
.node
== pfile
->spec_nodes
.n_false
))
1165 result
.low
= (token
->val
.node
.node
== pfile
->spec_nodes
.n_true
);
1171 if (CPP_OPTION (pfile
, warn_undef
) && !pfile
->state
.skip_eval
)
1172 cpp_warning_with_line (pfile
, CPP_W_UNDEF
, virtual_location
, 0,
1173 "\"%s\" is not defined, evaluates to 0",
1174 NODE_NAME (token
->val
.node
.node
));
1179 if (!pfile
->state
.skipping
)
1181 /* A pedantic warning takes precedence over a deprecated
1183 if (CPP_PEDANTIC (pfile
))
1184 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
,
1185 virtual_location
, 0,
1186 "assertions are a GCC extension");
1187 else if (CPP_OPTION (pfile
, cpp_warn_deprecated
))
1188 cpp_warning_with_line (pfile
, CPP_W_DEPRECATED
, virtual_location
, 0,
1189 "assertions are a deprecated extension");
1191 _cpp_test_assertion (pfile
, &temp
);
1200 result
.unsignedp
= !!unsignedp
;
1204 /* Operator precedence and flags table.
1206 After an operator is returned from the lexer, if it has priority less
1207 than the operator on the top of the stack, we reduce the stack by one
1208 operator and repeat the test. Since equal priorities do not reduce,
1209 this is naturally right-associative.
1211 We handle left-associative operators by decrementing the priority of
1212 just-lexed operators by one, but retaining the priority of operators
1213 already on the stack.
1215 The remaining cases are '(' and ')'. We handle '(' by skipping the
1216 reduction phase completely. ')' is given lower priority than
1217 everything else, including '(', effectively forcing a reduction of the
1218 parenthesized expression. If there is a matching '(', the routine
1219 reduce() exits immediately. If the normal exit route sees a ')', then
1220 there cannot have been a matching '(' and an error message is output.
1222 The parser assumes all shifted operators require a left operand unless
1223 the flag NO_L_OPERAND is set. These semantics are automatic; any
1224 extra semantics need to be handled with operator-specific code. */
1226 /* Flags. If CHECK_PROMOTION, we warn if the effective sign of an
1227 operand changes because of integer promotions. */
1228 #define NO_L_OPERAND (1 << 0)
1229 #define LEFT_ASSOC (1 << 1)
1230 #define CHECK_PROMOTION (1 << 2)
1232 /* Operator to priority map. Must be in the same order as the first
1233 N entries of enum cpp_ttype. */
1234 static const struct cpp_operator
1240 /* EQ */ {0, 0}, /* Shouldn't happen. */
1241 /* NOT */ {16, NO_L_OPERAND
},
1242 /* GREATER */ {12, LEFT_ASSOC
| CHECK_PROMOTION
},
1243 /* LESS */ {12, LEFT_ASSOC
| CHECK_PROMOTION
},
1244 /* PLUS */ {14, LEFT_ASSOC
| CHECK_PROMOTION
},
1245 /* MINUS */ {14, LEFT_ASSOC
| CHECK_PROMOTION
},
1246 /* MULT */ {15, LEFT_ASSOC
| CHECK_PROMOTION
},
1247 /* DIV */ {15, LEFT_ASSOC
| CHECK_PROMOTION
},
1248 /* MOD */ {15, LEFT_ASSOC
| CHECK_PROMOTION
},
1249 /* AND */ {9, LEFT_ASSOC
| CHECK_PROMOTION
},
1250 /* OR */ {7, LEFT_ASSOC
| CHECK_PROMOTION
},
1251 /* XOR */ {8, LEFT_ASSOC
| CHECK_PROMOTION
},
1252 /* RSHIFT */ {13, LEFT_ASSOC
},
1253 /* LSHIFT */ {13, LEFT_ASSOC
},
1255 /* COMPL */ {16, NO_L_OPERAND
},
1256 /* AND_AND */ {6, LEFT_ASSOC
},
1257 /* OR_OR */ {5, LEFT_ASSOC
},
1258 /* Note that QUERY, COLON, and COMMA must have the same precedence.
1259 However, there are some special cases for these in reduce(). */
1261 /* COLON */ {4, LEFT_ASSOC
| CHECK_PROMOTION
},
1262 /* COMMA */ {4, LEFT_ASSOC
},
1263 /* OPEN_PAREN */ {1, NO_L_OPERAND
},
1264 /* CLOSE_PAREN */ {0, 0},
1266 /* EQ_EQ */ {11, LEFT_ASSOC
},
1267 /* NOT_EQ */ {11, LEFT_ASSOC
},
1268 /* GREATER_EQ */ {12, LEFT_ASSOC
| CHECK_PROMOTION
},
1269 /* LESS_EQ */ {12, LEFT_ASSOC
| CHECK_PROMOTION
},
1270 /* UPLUS */ {16, NO_L_OPERAND
},
1271 /* UMINUS */ {16, NO_L_OPERAND
}
1274 /* Parse and evaluate a C expression, reading from PFILE.
1275 Returns the truth value of the expression.
1277 The implementation is an operator precedence parser, i.e. a
1278 bottom-up parser, using a stack for not-yet-reduced tokens.
1280 The stack base is op_stack, and the current stack pointer is 'top'.
1281 There is a stack element for each operator (only), and the most
1282 recently pushed operator is 'top->op'. An operand (value) is
1283 stored in the 'value' field of the stack element of the operator
1284 that precedes it. */
1286 _cpp_parse_expr (cpp_reader
*pfile
, bool is_if
)
1288 struct op
*top
= pfile
->op_stack
;
1289 unsigned int lex_count
;
1290 bool saw_leading_not
, want_value
= true;
1291 location_t virtual_location
= 0;
1293 pfile
->state
.skip_eval
= 0;
1295 /* Set up detection of #if ! defined(). */
1296 pfile
->mi_ind_cmacro
= 0;
1297 saw_leading_not
= false;
1300 /* Lowest priority operator prevents further reductions. */
1308 op
.token
= cpp_get_token_with_location (pfile
, &virtual_location
);
1309 op
.op
= op
.token
->type
;
1310 op
.loc
= virtual_location
;
1314 /* These tokens convert into values. */
1324 SYNTAX_ERROR2_AT (op
.loc
,
1325 "missing binary operator before token \"%s\"",
1326 cpp_token_as_text (pfile
, op
.token
));
1328 top
->value
= eval_token (pfile
, op
.token
, op
.loc
);
1332 saw_leading_not
= lex_count
== 1;
1344 if ((int) op
.op
<= (int) CPP_EQ
|| (int) op
.op
>= (int) CPP_PLUS_EQ
)
1345 SYNTAX_ERROR2_AT (op
.loc
,
1346 "token \"%s\" is not valid in preprocessor expressions",
1347 cpp_token_as_text (pfile
, op
.token
));
1351 /* Check we have a value or operator as appropriate. */
1352 if (optab
[op
.op
].flags
& NO_L_OPERAND
)
1355 SYNTAX_ERROR2_AT (op
.loc
,
1356 "missing binary operator before token \"%s\"",
1357 cpp_token_as_text (pfile
, op
.token
));
1359 else if (want_value
)
1361 /* We want a number (or expression) and haven't got one.
1362 Try to emit a specific diagnostic. */
1363 if (op
.op
== CPP_CLOSE_PAREN
&& top
->op
== CPP_OPEN_PAREN
)
1364 SYNTAX_ERROR_AT (op
.loc
,
1365 "missing expression between '(' and ')'");
1367 if (op
.op
== CPP_EOF
&& top
->op
== CPP_EOF
)
1368 SYNTAX_ERROR2_AT (op
.loc
,
1369 "%s with no expression", is_if
? "#if" : "#elif");
1371 if (top
->op
!= CPP_EOF
&& top
->op
!= CPP_OPEN_PAREN
)
1372 SYNTAX_ERROR2_AT (op
.loc
,
1373 "operator '%s' has no right operand",
1374 cpp_token_as_text (pfile
, top
->token
));
1375 else if (op
.op
== CPP_CLOSE_PAREN
|| op
.op
== CPP_EOF
)
1376 /* Complain about missing paren during reduction. */;
1378 SYNTAX_ERROR2_AT (op
.loc
,
1379 "operator '%s' has no left operand",
1380 cpp_token_as_text (pfile
, op
.token
));
1383 top
= reduce (pfile
, top
, op
.op
);
1387 if (op
.op
== CPP_EOF
)
1392 case CPP_CLOSE_PAREN
:
1395 if (!num_zerop (top
->value
))
1396 pfile
->state
.skip_eval
++;
1400 if (num_zerop (top
->value
))
1401 pfile
->state
.skip_eval
++;
1404 if (top
->op
!= CPP_QUERY
)
1405 SYNTAX_ERROR_AT (op
.loc
,
1406 " ':' without preceding '?'");
1407 if (!num_zerop (top
[-1].value
)) /* Was '?' condition true? */
1408 pfile
->state
.skip_eval
++;
1410 pfile
->state
.skip_eval
--;
1417 /* Check for and handle stack overflow. */
1418 if (++top
== pfile
->op_limit
)
1419 top
= _cpp_expand_op_stack (pfile
);
1422 top
->token
= op
.token
;
1426 /* The controlling macro expression is only valid if we called lex 3
1427 times: <!> <defined expression> and <EOF>. push_conditional ()
1428 checks that we are at top-of-file. */
1429 if (pfile
->mi_ind_cmacro
&& !(saw_leading_not
&& lex_count
== 3))
1430 pfile
->mi_ind_cmacro
= 0;
1432 if (top
!= pfile
->op_stack
)
1434 cpp_error_with_line (pfile
, CPP_DL_ICE
, top
->loc
, 0,
1435 "unbalanced stack in %s",
1436 is_if
? "#if" : "#elif");
1438 return false; /* Return false on syntax error. */
1441 return !num_zerop (top
->value
);
1444 /* Reduce the operator / value stack if possible, in preparation for
1445 pushing operator OP. Returns NULL on error, otherwise the top of
1448 reduce (cpp_reader
*pfile
, struct op
*top
, enum cpp_ttype op
)
1452 if (top
->op
<= CPP_EQ
|| top
->op
> CPP_LAST_CPP_OP
+ 2)
1455 cpp_error (pfile
, CPP_DL_ICE
, "impossible operator '%u'", top
->op
);
1459 if (op
== CPP_OPEN_PAREN
)
1462 /* Decrement the priority of left-associative operators to force a
1463 reduction with operators of otherwise equal priority. */
1464 prio
= optab
[op
].prio
- ((optab
[op
].flags
& LEFT_ASSOC
) != 0);
1465 while (prio
< optab
[top
->op
].prio
)
1467 if (CPP_OPTION (pfile
, warn_num_sign_change
)
1468 && optab
[top
->op
].flags
& CHECK_PROMOTION
)
1469 check_promotion (pfile
, top
);
1477 top
[-1].value
= num_unary_op (pfile
, top
->value
, top
->op
);
1478 top
[-1].loc
= top
->loc
;
1486 top
[-1].value
= num_binary_op (pfile
, top
[-1].value
,
1487 top
->value
, top
->op
);
1488 top
[-1].loc
= top
->loc
;
1493 case CPP_GREATER_EQ
:
1496 = num_inequality_op (pfile
, top
[-1].value
, top
->value
, top
->op
);
1497 top
[-1].loc
= top
->loc
;
1503 = num_equality_op (pfile
, top
[-1].value
, top
->value
, top
->op
);
1504 top
[-1].loc
= top
->loc
;
1511 = num_bitwise_op (pfile
, top
[-1].value
, top
->value
, top
->op
);
1512 top
[-1].loc
= top
->loc
;
1516 top
[-1].value
= num_mul (pfile
, top
[-1].value
, top
->value
);
1517 top
[-1].loc
= top
->loc
;
1522 top
[-1].value
= num_div_op (pfile
, top
[-1].value
,
1523 top
->value
, top
->op
, top
->loc
);
1524 top
[-1].loc
= top
->loc
;
1529 if (!num_zerop (top
->value
))
1530 pfile
->state
.skip_eval
--;
1531 top
->value
.low
= (!num_zerop (top
->value
)
1532 || !num_zerop (top
[1].value
));
1533 top
->value
.high
= 0;
1534 top
->value
.unsignedp
= false;
1535 top
->value
.overflow
= false;
1536 top
->loc
= top
[1].loc
;
1541 if (num_zerop (top
->value
))
1542 pfile
->state
.skip_eval
--;
1543 top
->value
.low
= (!num_zerop (top
->value
)
1544 && !num_zerop (top
[1].value
));
1545 top
->value
.high
= 0;
1546 top
->value
.unsignedp
= false;
1547 top
->value
.overflow
= false;
1548 top
->loc
= top
[1].loc
;
1551 case CPP_OPEN_PAREN
:
1552 if (op
!= CPP_CLOSE_PAREN
)
1554 cpp_error_with_line (pfile
, CPP_DL_ERROR
,
1555 top
->token
->src_loc
,
1556 0, "missing ')' in expression");
1560 top
->value
= top
[1].value
;
1561 top
->loc
= top
[1].loc
;
1566 if (!num_zerop (top
->value
))
1568 pfile
->state
.skip_eval
--;
1569 top
->value
= top
[1].value
;
1570 top
->loc
= top
[1].loc
;
1574 top
->value
= top
[2].value
;
1575 top
->loc
= top
[2].loc
;
1577 top
->value
.unsignedp
= (top
[1].value
.unsignedp
1578 || top
[2].value
.unsignedp
);
1582 /* COMMA and COLON should not reduce a QUERY operator. */
1583 if (op
== CPP_COMMA
|| op
== CPP_COLON
)
1585 cpp_error (pfile
, CPP_DL_ERROR
, "'?' without following ':'");
1593 if (top
->value
.overflow
&& !pfile
->state
.skip_eval
)
1594 cpp_error (pfile
, CPP_DL_PEDWARN
,
1595 "integer overflow in preprocessor expression");
1598 if (op
== CPP_CLOSE_PAREN
)
1600 cpp_error (pfile
, CPP_DL_ERROR
, "missing '(' in expression");
1607 /* Returns the position of the old top of stack after expansion. */
1609 _cpp_expand_op_stack (cpp_reader
*pfile
)
1611 size_t old_size
= (size_t) (pfile
->op_limit
- pfile
->op_stack
);
1612 size_t new_size
= old_size
* 2 + 20;
1614 pfile
->op_stack
= XRESIZEVEC (struct op
, pfile
->op_stack
, new_size
);
1615 pfile
->op_limit
= pfile
->op_stack
+ new_size
;
1617 return pfile
->op_stack
+ old_size
;
1620 /* Emits a warning if the effective sign of either operand of OP
1621 changes because of integer promotions. */
1623 check_promotion (cpp_reader
*pfile
, const struct op
*op
)
1625 if (op
->value
.unsignedp
== op
[-1].value
.unsignedp
)
1628 if (op
->value
.unsignedp
)
1630 if (!num_positive (op
[-1].value
, CPP_OPTION (pfile
, precision
)))
1631 cpp_error_with_line (pfile
, CPP_DL_WARNING
, op
[-1].loc
, 0,
1632 "the left operand of \"%s\" changes sign when promoted",
1633 cpp_token_as_text (pfile
, op
->token
));
1635 else if (!num_positive (op
->value
, CPP_OPTION (pfile
, precision
)))
1636 cpp_error_with_line (pfile
, CPP_DL_WARNING
, op
->loc
, 0,
1637 "the right operand of \"%s\" changes sign when promoted",
1638 cpp_token_as_text (pfile
, op
->token
));
1641 /* Clears the unused high order bits of the number pointed to by PNUM. */
1643 num_trim (cpp_num num
, size_t precision
)
1645 if (precision
> PART_PRECISION
)
1647 precision
-= PART_PRECISION
;
1648 if (precision
< PART_PRECISION
)
1649 num
.high
&= ((cpp_num_part
) 1 << precision
) - 1;
1653 if (precision
< PART_PRECISION
)
1654 num
.low
&= ((cpp_num_part
) 1 << precision
) - 1;
1661 /* True iff A (presumed signed) >= 0. */
1663 num_positive (cpp_num num
, size_t precision
)
1665 if (precision
> PART_PRECISION
)
1667 precision
-= PART_PRECISION
;
1668 return (num
.high
& (cpp_num_part
) 1 << (precision
- 1)) == 0;
1671 return (num
.low
& (cpp_num_part
) 1 << (precision
- 1)) == 0;
1674 /* Sign extend a number, with PRECISION significant bits and all
1675 others assumed clear, to fill out a cpp_num structure. */
1677 cpp_num_sign_extend (cpp_num num
, size_t precision
)
1681 if (precision
> PART_PRECISION
)
1683 precision
-= PART_PRECISION
;
1684 if (precision
< PART_PRECISION
1685 && (num
.high
& (cpp_num_part
) 1 << (precision
- 1)))
1686 num
.high
|= ~(~(cpp_num_part
) 0 >> (PART_PRECISION
- precision
));
1688 else if (num
.low
& (cpp_num_part
) 1 << (precision
- 1))
1690 if (precision
< PART_PRECISION
)
1691 num
.low
|= ~(~(cpp_num_part
) 0 >> (PART_PRECISION
- precision
));
1692 num
.high
= ~(cpp_num_part
) 0;
1699 /* Returns the negative of NUM. */
1701 num_negate (cpp_num num
, size_t precision
)
1706 num
.high
= ~num
.high
;
1710 num
= num_trim (num
, precision
);
1711 num
.overflow
= (!num
.unsignedp
&& num_eq (num
, copy
) && !num_zerop (num
));
1716 /* Returns true if A >= B. */
1718 num_greater_eq (cpp_num pa
, cpp_num pb
, size_t precision
)
1722 unsignedp
= pa
.unsignedp
|| pb
.unsignedp
;
1726 /* Both numbers have signed type. If they are of different
1727 sign, the answer is the sign of A. */
1728 unsignedp
= num_positive (pa
, precision
);
1730 if (unsignedp
!= num_positive (pb
, precision
))
1733 /* Otherwise we can do an unsigned comparison. */
1736 return (pa
.high
> pb
.high
) || (pa
.high
== pb
.high
&& pa
.low
>= pb
.low
);
1739 /* Returns LHS OP RHS, where OP is a bit-wise operation. */
1741 num_bitwise_op (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1742 cpp_num lhs
, cpp_num rhs
, enum cpp_ttype op
)
1744 lhs
.overflow
= false;
1745 lhs
.unsignedp
= lhs
.unsignedp
|| rhs
.unsignedp
;
1747 /* As excess precision is zeroed, there is no need to num_trim () as
1748 these operations cannot introduce a set bit there. */
1752 lhs
.high
&= rhs
.high
;
1754 else if (op
== CPP_OR
)
1757 lhs
.high
|= rhs
.high
;
1762 lhs
.high
^= rhs
.high
;
1768 /* Returns LHS OP RHS, where OP is an inequality. */
1770 num_inequality_op (cpp_reader
*pfile
, cpp_num lhs
, cpp_num rhs
,
1773 bool gte
= num_greater_eq (lhs
, rhs
, CPP_OPTION (pfile
, precision
));
1775 if (op
== CPP_GREATER_EQ
)
1777 else if (op
== CPP_LESS
)
1779 else if (op
== CPP_GREATER
)
1780 lhs
.low
= gte
&& !num_eq (lhs
, rhs
);
1781 else /* CPP_LESS_EQ. */
1782 lhs
.low
= !gte
|| num_eq (lhs
, rhs
);
1785 lhs
.overflow
= false;
1786 lhs
.unsignedp
= false;
1790 /* Returns LHS OP RHS, where OP is == or !=. */
1792 num_equality_op (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1793 cpp_num lhs
, cpp_num rhs
, enum cpp_ttype op
)
1795 /* Work around a 3.0.4 bug; see PR 6950. */
1796 bool eq
= num_eq (lhs
, rhs
);
1797 if (op
== CPP_NOT_EQ
)
1801 lhs
.overflow
= false;
1802 lhs
.unsignedp
= false;
1806 /* Shift NUM, of width PRECISION, right by N bits. */
1808 num_rshift (cpp_num num
, size_t precision
, size_t n
)
1810 cpp_num_part sign_mask
;
1811 bool x
= num_positive (num
, precision
);
1813 if (num
.unsignedp
|| x
)
1816 sign_mask
= ~(cpp_num_part
) 0;
1819 num
.high
= num
.low
= sign_mask
;
1823 if (precision
< PART_PRECISION
)
1824 num
.high
= sign_mask
, num
.low
|= sign_mask
<< precision
;
1825 else if (precision
< 2 * PART_PRECISION
)
1826 num
.high
|= sign_mask
<< (precision
- PART_PRECISION
);
1828 if (n
>= PART_PRECISION
)
1830 n
-= PART_PRECISION
;
1832 num
.high
= sign_mask
;
1837 num
.low
= (num
.low
>> n
) | (num
.high
<< (PART_PRECISION
- n
));
1838 num
.high
= (num
.high
>> n
) | (sign_mask
<< (PART_PRECISION
- n
));
1842 num
= num_trim (num
, precision
);
1843 num
.overflow
= false;
1847 /* Shift NUM, of width PRECISION, left by N bits. */
1849 num_lshift (cpp_num num
, size_t precision
, size_t n
)
1853 num
.overflow
= !num
.unsignedp
&& !num_zerop (num
);
1854 num
.high
= num
.low
= 0;
1858 cpp_num orig
, maybe_orig
;
1862 if (m
>= PART_PRECISION
)
1864 m
-= PART_PRECISION
;
1870 num
.high
= (num
.high
<< m
) | (num
.low
>> (PART_PRECISION
- m
));
1873 num
= num_trim (num
, precision
);
1876 num
.overflow
= false;
1879 maybe_orig
= num_rshift (num
, precision
, n
);
1880 num
.overflow
= !num_eq (orig
, maybe_orig
);
1887 /* The four unary operators: +, -, ! and ~. */
1889 num_unary_op (cpp_reader
*pfile
, cpp_num num
, enum cpp_ttype op
)
1894 if (CPP_WTRADITIONAL (pfile
) && !pfile
->state
.skip_eval
)
1895 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
1896 "traditional C rejects the unary plus operator");
1897 num
.overflow
= false;
1901 num
= num_negate (num
, CPP_OPTION (pfile
, precision
));
1905 num
.high
= ~num
.high
;
1907 num
= num_trim (num
, CPP_OPTION (pfile
, precision
));
1908 num
.overflow
= false;
1911 default: /* case CPP_NOT: */
1912 num
.low
= num_zerop (num
);
1914 num
.overflow
= false;
1915 num
.unsignedp
= false;
1922 /* The various binary operators. */
1924 num_binary_op (cpp_reader
*pfile
, cpp_num lhs
, cpp_num rhs
, enum cpp_ttype op
)
1927 size_t precision
= CPP_OPTION (pfile
, precision
);
1935 if (!rhs
.unsignedp
&& !num_positive (rhs
, precision
))
1937 /* A negative shift is a positive shift the other way. */
1938 if (op
== CPP_LSHIFT
)
1942 rhs
= num_negate (rhs
, precision
);
1945 n
= ~0; /* Maximal. */
1948 if (op
== CPP_LSHIFT
)
1949 lhs
= num_lshift (lhs
, precision
, n
);
1951 lhs
= num_rshift (lhs
, precision
, n
);
1956 result
.low
= lhs
.low
- rhs
.low
;
1957 result
.high
= lhs
.high
- rhs
.high
;
1958 if (result
.low
> lhs
.low
)
1960 result
.unsignedp
= lhs
.unsignedp
|| rhs
.unsignedp
;
1961 result
.overflow
= false;
1963 result
= num_trim (result
, precision
);
1964 if (!result
.unsignedp
)
1966 bool lhsp
= num_positive (lhs
, precision
);
1967 result
.overflow
= (lhsp
!= num_positive (rhs
, precision
)
1968 && lhsp
!= num_positive (result
, precision
));
1973 result
.low
= lhs
.low
+ rhs
.low
;
1974 result
.high
= lhs
.high
+ rhs
.high
;
1975 if (result
.low
< lhs
.low
)
1977 result
.unsignedp
= lhs
.unsignedp
|| rhs
.unsignedp
;
1978 result
.overflow
= false;
1980 result
= num_trim (result
, precision
);
1981 if (!result
.unsignedp
)
1983 bool lhsp
= num_positive (lhs
, precision
);
1984 result
.overflow
= (lhsp
== num_positive (rhs
, precision
)
1985 && lhsp
!= num_positive (result
, precision
));
1990 default: /* case CPP_COMMA: */
1991 if (CPP_PEDANTIC (pfile
) && (!CPP_OPTION (pfile
, c99
)
1992 || !pfile
->state
.skip_eval
))
1993 cpp_pedwarning (pfile
, CPP_W_PEDANTIC
,
1994 "comma operator in operand of #if");
2002 /* Multiplies two unsigned cpp_num_parts to give a cpp_num. This
2005 num_part_mul (cpp_num_part lhs
, cpp_num_part rhs
)
2008 cpp_num_part middle
[2], temp
;
2010 result
.low
= LOW_PART (lhs
) * LOW_PART (rhs
);
2011 result
.high
= HIGH_PART (lhs
) * HIGH_PART (rhs
);
2013 middle
[0] = LOW_PART (lhs
) * HIGH_PART (rhs
);
2014 middle
[1] = HIGH_PART (lhs
) * LOW_PART (rhs
);
2017 result
.low
+= LOW_PART (middle
[0]) << (PART_PRECISION
/ 2);
2018 if (result
.low
< temp
)
2022 result
.low
+= LOW_PART (middle
[1]) << (PART_PRECISION
/ 2);
2023 if (result
.low
< temp
)
2026 result
.high
+= HIGH_PART (middle
[0]);
2027 result
.high
+= HIGH_PART (middle
[1]);
2028 result
.unsignedp
= true;
2029 result
.overflow
= false;
2034 /* Multiply two preprocessing numbers. */
2036 num_mul (cpp_reader
*pfile
, cpp_num lhs
, cpp_num rhs
)
2038 cpp_num result
, temp
;
2039 bool unsignedp
= lhs
.unsignedp
|| rhs
.unsignedp
;
2040 bool overflow
, negate
= false;
2041 size_t precision
= CPP_OPTION (pfile
, precision
);
2043 /* Prepare for unsigned multiplication. */
2046 if (!num_positive (lhs
, precision
))
2047 negate
= !negate
, lhs
= num_negate (lhs
, precision
);
2048 if (!num_positive (rhs
, precision
))
2049 negate
= !negate
, rhs
= num_negate (rhs
, precision
);
2052 overflow
= lhs
.high
&& rhs
.high
;
2053 result
= num_part_mul (lhs
.low
, rhs
.low
);
2055 temp
= num_part_mul (lhs
.high
, rhs
.low
);
2056 result
.high
+= temp
.low
;
2060 temp
= num_part_mul (lhs
.low
, rhs
.high
);
2061 result
.high
+= temp
.low
;
2065 temp
.low
= result
.low
, temp
.high
= result
.high
;
2066 result
= num_trim (result
, precision
);
2067 if (!num_eq (result
, temp
))
2071 result
= num_negate (result
, precision
);
2074 result
.overflow
= false;
2076 result
.overflow
= overflow
|| (num_positive (result
, precision
) ^ !negate
2077 && !num_zerop (result
));
2078 result
.unsignedp
= unsignedp
;
2083 /* Divide two preprocessing numbers, LHS and RHS, returning the answer
2084 or the remainder depending upon OP. LOCATION is the source location
2085 of this operator (for diagnostics). */
2088 num_div_op (cpp_reader
*pfile
, cpp_num lhs
, cpp_num rhs
, enum cpp_ttype op
,
2089 location_t location
)
2091 cpp_num result
, sub
;
2093 bool unsignedp
= lhs
.unsignedp
|| rhs
.unsignedp
;
2094 bool negate
= false, lhs_neg
= false;
2095 size_t i
, precision
= CPP_OPTION (pfile
, precision
);
2097 /* Prepare for unsigned division. */
2100 if (!num_positive (lhs
, precision
))
2101 negate
= !negate
, lhs_neg
= true, lhs
= num_negate (lhs
, precision
);
2102 if (!num_positive (rhs
, precision
))
2103 negate
= !negate
, rhs
= num_negate (rhs
, precision
);
2106 /* Find the high bit. */
2110 mask
= (cpp_num_part
) 1 << (i
- PART_PRECISION
);
2111 for (; ; i
--, mask
>>= 1)
2112 if (rhs
.high
& mask
)
2117 if (precision
> PART_PRECISION
)
2118 i
= precision
- PART_PRECISION
- 1;
2121 mask
= (cpp_num_part
) 1 << i
;
2122 for (; ; i
--, mask
>>= 1)
2128 if (!pfile
->state
.skip_eval
)
2129 cpp_error_with_line (pfile
, CPP_DL_ERROR
, location
, 0,
2130 "division by zero in #if");
2134 /* First nonzero bit of RHS is bit I. Do naive division by
2135 shifting the RHS fully left, and subtracting from LHS if LHS is
2136 at least as big, and then repeating but with one less shift.
2137 This is not very efficient, but is easy to understand. */
2139 rhs
.unsignedp
= true;
2140 lhs
.unsignedp
= true;
2141 i
= precision
- i
- 1;
2142 sub
= num_lshift (rhs
, precision
, i
);
2144 result
.high
= result
.low
= 0;
2147 if (num_greater_eq (lhs
, sub
, precision
))
2149 lhs
= num_binary_op (pfile
, lhs
, sub
, CPP_MINUS
);
2150 if (i
>= PART_PRECISION
)
2151 result
.high
|= (cpp_num_part
) 1 << (i
- PART_PRECISION
);
2153 result
.low
|= (cpp_num_part
) 1 << i
;
2157 sub
.low
= (sub
.low
>> 1) | (sub
.high
<< (PART_PRECISION
- 1));
2161 /* We divide so that the remainder has the sign of the LHS. */
2164 result
.unsignedp
= unsignedp
;
2165 result
.overflow
= false;
2169 result
= num_negate (result
, precision
);
2170 result
.overflow
= (num_positive (result
, precision
) ^ !negate
2171 && !num_zerop (result
));
2178 lhs
.unsignedp
= unsignedp
;
2179 lhs
.overflow
= false;
2181 lhs
= num_negate (lhs
, precision
);
2186 /* Handle meeting "__has_include__" in a preprocessor expression. */
2188 parse_has_include (cpp_reader
*pfile
, enum include_type type
)
2192 cpp_hashnode
*node
= 0;
2193 const cpp_token
*token
;
2194 bool bracket
= false;
2197 result
.unsignedp
= false;
2199 result
.overflow
= false;
2202 pfile
->state
.in__has_include__
++;
2204 token
= cpp_get_token (pfile
);
2205 if (token
->type
== CPP_OPEN_PAREN
)
2208 token
= cpp_get_token (pfile
);
2211 if (token
->type
== CPP_STRING
|| token
->type
== CPP_HEADER_NAME
)
2213 if (token
->type
== CPP_HEADER_NAME
)
2215 fname
= XNEWVEC (char, token
->val
.str
.len
- 1);
2216 memcpy (fname
, token
->val
.str
.text
+ 1, token
->val
.str
.len
- 2);
2217 fname
[token
->val
.str
.len
- 2] = '\0';
2218 node
= token
->val
.node
.node
;
2220 else if (token
->type
== CPP_LESS
)
2223 fname
= _cpp_bracket_include (pfile
);
2226 cpp_error (pfile
, CPP_DL_ERROR
,
2227 "operator \"__has_include__\" requires a header string");
2231 int angle_brackets
= (bracket
? 1 : 0);
2233 if (_cpp_has_header (pfile
, fname
, angle_brackets
, type
))
2241 if (paren
&& !SEEN_EOL () && cpp_get_token (pfile
)->type
!= CPP_CLOSE_PAREN
)
2242 cpp_error (pfile
, CPP_DL_ERROR
,
2243 "missing ')' after \"__has_include__\"");
2245 /* A possible controlling macro of the form #if !__has_include__ ().
2246 _cpp_parse_expr checks there was no other junk on the line. */
2248 pfile
->mi_ind_cmacro
= node
;
2250 pfile
->state
.in__has_include__
--;