1 /* Parse C expressions for cpplib.
2 Copyright (C) 1987-2023 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 /* 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; } \
78 #define SYNTAX_ERROR_AT(loc, msgid) \
79 do { cpp_error_with_line (pfile, CPP_DL_ERROR, (loc), 0, msgid); goto syntax_error; } \
81 #define SYNTAX_ERROR2_AT(loc, msgid, arg) \
82 do { cpp_error_with_line (pfile, CPP_DL_ERROR, (loc), 0, msgid, arg); goto syntax_error; } \
85 /* Subroutine of cpp_classify_number. S points to a float suffix of
86 length LEN, possibly zero. Returns 0 for an invalid suffix, or a
87 flag vector (of CPP_N_* bits) describing the suffix. */
89 interpret_float_suffix (cpp_reader
*pfile
, const uchar
*s
, size_t len
)
91 size_t orig_len
= len
;
92 const uchar
*orig_s
= s
;
94 size_t f
, d
, l
, w
, q
, i
, fn
, fnx
, fn_bits
, bf16
;
97 f
= d
= l
= w
= q
= i
= fn
= fnx
= fn_bits
= bf16
= 0;
99 /* The following decimal float suffixes, from TR 24732:2009, TS
100 18661-2:2015 and C2X, are supported:
104 dl, DL - _Decimal128.
106 The dN and DN suffixes for _DecimalN, and dNx and DNx for
107 _DecimalNx, defined in TS 18661-3:2015, are not supported.
109 Fixed-point suffixes, from TR 18037:2008, are supported. They
110 consist of three parts, in order:
112 (i) An optional u or U, for unsigned types.
114 (ii) An optional h or H, for short types, or l or L, for long
115 types, or ll or LL, for long long types. Use of ll or LL is a
118 (iii) r or R, for _Fract types, or k or K, for _Accum types.
120 Otherwise the suffix is for a binary or standard floating-point
121 type. Such a suffix, or the absence of a suffix, may be preceded
122 or followed by i, I, j or J, to indicate an imaginary number with
123 the corresponding complex type. The following suffixes for
124 binary or standard floating-point types are supported:
126 f, F - float (ISO C and C++).
127 l, L - long double (ISO C and C++).
128 d, D - double, even with the FLOAT_CONST_DECIMAL64 pragma in
129 operation (from TR 24732:2009; the pragma and the suffix
130 are not included in TS 18661-2:2015).
131 w, W - machine-specific type such as __float80 (GNU extension).
132 q, Q - machine-specific type such as __float128 (GNU extension).
133 fN, FN - _FloatN (TS 18661-3:2015).
134 fNx, FNx - _FloatNx (TS 18661-3:2015).
135 bf16, BF16 - std::bfloat16_t (ISO C++23). */
137 /* Process decimal float suffixes, which are two letters starting
138 with d or D. Order and case are significant. */
139 if (len
== 2 && (*s
== 'd' || *s
== 'D'))
141 bool uppercase
= (*s
== 'D');
144 case 'f': return (!uppercase
? (CPP_N_DFLOAT
| CPP_N_SMALL
): 0); break;
145 case 'F': return (uppercase
? (CPP_N_DFLOAT
| CPP_N_SMALL
) : 0); break;
146 case 'd': return (!uppercase
? (CPP_N_DFLOAT
| CPP_N_MEDIUM
): 0); break;
147 case 'D': return (uppercase
? (CPP_N_DFLOAT
| CPP_N_MEDIUM
) : 0); break;
148 case 'l': return (!uppercase
? (CPP_N_DFLOAT
| CPP_N_LARGE
) : 0); break;
149 case 'L': return (uppercase
? (CPP_N_DFLOAT
| CPP_N_LARGE
) : 0); break;
151 /* Additional two-character suffixes beginning with D are not
152 for decimal float constants. */
157 if (CPP_OPTION (pfile
, ext_numeric_literals
))
159 /* Recognize a fixed-point suffix. */
163 case 'k': case 'K': flags
= CPP_N_ACCUM
; break;
164 case 'r': case 'R': flags
= CPP_N_FRACT
; break;
168 /* Continue processing a fixed-point suffix. The suffix is case
169 insensitive except for ll or LL. Order is significant. */
176 if (*s
== 'u' || *s
== 'U')
178 flags
|= CPP_N_UNSIGNED
;
189 return flags
|= CPP_N_SMALL
;
193 return flags
|= CPP_N_MEDIUM
;
194 if (len
== 2 && s
[1] == 'l')
195 return flags
|= CPP_N_LARGE
;
199 return flags
|= CPP_N_MEDIUM
;
200 if (len
== 2 && s
[1] == 'L')
201 return flags
|= CPP_N_LARGE
;
206 /* Anything left at this point is invalid. */
211 /* In any remaining valid suffix, the case and order don't matter. */
227 && fn_bits
< CPP_FLOATN_MAX
)
229 fn_bits
= fn_bits
* 10 + (s
[1] - '0');
233 if (len
> 0 && s
[1] == 'x')
245 /* Except for bf16 / BF16 where case is significant. */
246 && s
[1] == (s
[0] == 'b' ? 'f' : 'F')
256 case 'd': case 'D': d
++; break;
257 case 'l': case 'L': l
++; break;
258 case 'w': case 'W': w
++; break;
259 case 'q': case 'Q': q
++; break;
261 case 'j': case 'J': i
++; break;
268 /* Reject any case of multiple suffixes specifying types, multiple
269 suffixes specifying an imaginary constant, _FloatN or _FloatNx
270 suffixes for invalid values of N, and _FloatN suffixes for values
271 of N larger than can be represented in the return value. The
272 caller is responsible for rejecting _FloatN suffixes where
273 _FloatN is not supported on the chosen target. */
274 if (f
+ d
+ l
+ w
+ q
+ fn
+ fnx
+ bf16
> 1 || i
> 1)
276 if (fn_bits
> CPP_FLOATN_MAX
)
278 if (fnx
&& fn_bits
!= 32 && fn_bits
!= 64 && fn_bits
!= 128)
280 if (fn
&& fn_bits
!= 16 && fn_bits
% 32 != 0)
282 if (fn
&& fn_bits
== 96)
287 if (!CPP_OPTION (pfile
, ext_numeric_literals
))
290 /* In C++14 and up these suffixes are in the standard library, so treat
291 them as user-defined literals. */
292 if (CPP_OPTION (pfile
, cplusplus
)
293 && CPP_OPTION (pfile
, lang
) > CLK_CXX11
297 && (orig_s
[1] == 'f' || orig_s
[1] == 'l'))))
301 if ((w
|| q
) && !CPP_OPTION (pfile
, ext_numeric_literals
))
304 return ((i
? CPP_N_IMAGINARY
: 0)
310 fn
? CPP_N_FLOATN
| (fn_bits
<< CPP_FLOATN_SHIFT
) :
311 fnx
? CPP_N_FLOATNX
| (fn_bits
<< CPP_FLOATN_SHIFT
) :
312 bf16
? CPP_N_BFLOAT16
:
316 /* Return the classification flags for a float suffix. */
318 cpp_interpret_float_suffix (cpp_reader
*pfile
, const char *s
, size_t len
)
320 return interpret_float_suffix (pfile
, (const unsigned char *)s
, len
);
323 /* Subroutine of cpp_classify_number. S points to an integer suffix
324 of length LEN, possibly zero. Returns 0 for an invalid suffix, or a
325 flag vector describing the suffix. */
327 interpret_int_suffix (cpp_reader
*pfile
, const uchar
*s
, size_t len
)
329 size_t orig_len
= len
;
330 size_t u
, l
, i
, z
, wb
;
332 u
= l
= i
= z
= wb
= 0;
337 case 'z': case 'Z': z
++; break;
338 case 'u': case 'U': u
++; break;
340 case 'j': case 'J': i
++; break;
341 case 'l': case 'L': l
++;
342 /* If there are two Ls, they must be adjacent and the same case. */
343 if (l
== 2 && s
[len
] != s
[len
+ 1])
347 if (len
== 0 || s
[len
- 1] != 'w')
353 if (len
== 0 || s
[len
- 1] != 'W')
362 if (l
> 2 || u
> 1 || i
> 1 || z
> 1 || wb
> 1)
369 if (!CPP_OPTION (pfile
, cplusplus
))
375 if (CPP_OPTION (pfile
, cplusplus
))
377 if (l
> 0 || i
> 0 || z
> 0)
383 if (!CPP_OPTION (pfile
, ext_numeric_literals
))
386 /* In C++14 and up these suffixes are in the standard library, so treat
387 them as user-defined literals. */
388 if (CPP_OPTION (pfile
, cplusplus
)
389 && CPP_OPTION (pfile
, lang
) > CLK_CXX11
391 && (orig_len
== 1 || (orig_len
== 2 && s
[1] == 'l')))
395 return ((i
? CPP_N_IMAGINARY
: 0)
396 | (u
? CPP_N_UNSIGNED
: 0)
397 | ((l
== 0) ? CPP_N_SMALL
398 : (l
== 1) ? CPP_N_MEDIUM
: CPP_N_LARGE
)
399 | (z
? CPP_N_SIZE_T
: 0)
400 | (wb
? CPP_N_BITINT
: 0));
403 /* Return the classification flags for an int suffix. */
405 cpp_interpret_int_suffix (cpp_reader
*pfile
, const char *s
, size_t len
)
407 return interpret_int_suffix (pfile
, (const unsigned char *)s
, len
);
410 /* Return the string type corresponding to the the input user-defined string
411 literal type. If the input type is not a user-defined string literal
412 type return the input type. */
414 cpp_userdef_string_remove_type (enum cpp_ttype type
)
416 if (type
== CPP_STRING_USERDEF
)
418 else if (type
== CPP_WSTRING_USERDEF
)
420 else if (type
== CPP_STRING16_USERDEF
)
422 else if (type
== CPP_STRING32_USERDEF
)
424 else if (type
== CPP_UTF8STRING_USERDEF
)
425 return CPP_UTF8STRING
;
430 /* Return the user-defined string literal type corresponding to the input
431 string type. If the input type is not a string type return the input
434 cpp_userdef_string_add_type (enum cpp_ttype type
)
436 if (type
== CPP_STRING
)
437 return CPP_STRING_USERDEF
;
438 else if (type
== CPP_WSTRING
)
439 return CPP_WSTRING_USERDEF
;
440 else if (type
== CPP_STRING16
)
441 return CPP_STRING16_USERDEF
;
442 else if (type
== CPP_STRING32
)
443 return CPP_STRING32_USERDEF
;
444 else if (type
== CPP_UTF8STRING
)
445 return CPP_UTF8STRING_USERDEF
;
450 /* Return the char type corresponding to the the input user-defined char
451 literal type. If the input type is not a user-defined char literal
452 type return the input type. */
454 cpp_userdef_char_remove_type (enum cpp_ttype type
)
456 if (type
== CPP_CHAR_USERDEF
)
458 else if (type
== CPP_WCHAR_USERDEF
)
460 else if (type
== CPP_CHAR16_USERDEF
)
462 else if (type
== CPP_CHAR32_USERDEF
)
464 else if (type
== CPP_UTF8CHAR_USERDEF
)
470 /* Return the user-defined char literal type corresponding to the input
471 char type. If the input type is not a char type return the input
474 cpp_userdef_char_add_type (enum cpp_ttype type
)
476 if (type
== CPP_CHAR
)
477 return CPP_CHAR_USERDEF
;
478 else if (type
== CPP_WCHAR
)
479 return CPP_WCHAR_USERDEF
;
480 else if (type
== CPP_CHAR16
)
481 return CPP_CHAR16_USERDEF
;
482 else if (type
== CPP_CHAR32
)
483 return CPP_CHAR32_USERDEF
;
484 else if (type
== CPP_UTF8CHAR
)
485 return CPP_UTF8CHAR_USERDEF
;
490 /* Return true if the token type is a user-defined string literal. */
492 cpp_userdef_string_p (enum cpp_ttype type
)
494 if (type
== CPP_STRING_USERDEF
495 || type
== CPP_WSTRING_USERDEF
496 || type
== CPP_STRING16_USERDEF
497 || type
== CPP_STRING32_USERDEF
498 || type
== CPP_UTF8STRING_USERDEF
)
504 /* Return true if the token type is a user-defined char literal. */
506 cpp_userdef_char_p (enum cpp_ttype type
)
508 if (type
== CPP_CHAR_USERDEF
509 || type
== CPP_WCHAR_USERDEF
510 || type
== CPP_CHAR16_USERDEF
511 || type
== CPP_CHAR32_USERDEF
512 || type
== CPP_UTF8CHAR_USERDEF
)
518 /* Extract the suffix from a user-defined literal string or char. */
520 cpp_get_userdef_suffix (const cpp_token
*tok
)
522 unsigned int len
= tok
->val
.str
.len
;
523 const char *text
= (const char *)tok
->val
.str
.text
;
526 for (i
= 0; i
< len
; ++i
)
527 if (text
[i
] == '\'' || text
[i
] == '"')
532 for (i
= len
; i
> 0; --i
)
533 if (text
[i
- 1] == delim
)
538 /* Categorize numeric constants according to their field (integer,
539 floating point, or invalid), radix (decimal, octal, hexadecimal),
542 TOKEN is the token that represents the numeric constant to
545 In C++0X if UD_SUFFIX is non null it will be assigned
546 any unrecognized suffix for a user-defined literal.
548 VIRTUAL_LOCATION is the virtual location for TOKEN. */
550 cpp_classify_number (cpp_reader
*pfile
, const cpp_token
*token
,
551 const char **ud_suffix
, location_t virtual_location
)
553 const uchar
*str
= token
->val
.str
.text
;
555 unsigned int max_digit
, result
, radix
;
556 enum {NOT_FLOAT
= 0, AFTER_POINT
, AFTER_EXPON
} float_flag
;
563 /* If the lexer has done its job, length one can only be a single
564 digit. Fast-path this very common case. */
565 if (token
->val
.str
.len
== 1)
566 return CPP_N_INTEGER
| CPP_N_SMALL
| CPP_N_DECIMAL
;
568 limit
= str
+ token
->val
.str
.len
;
569 float_flag
= NOT_FLOAT
;
573 seen_digit_sep
= false;
575 /* First, interpret the radix. */
581 /* Require at least one hex digit to classify it as hex. */
582 if (*str
== 'x' || *str
== 'X')
584 if (str
[1] == '.' || ISXDIGIT (str
[1]))
589 else if (DIGIT_SEP (str
[1]))
590 SYNTAX_ERROR_AT (virtual_location
,
591 "digit separator after base indicator");
593 else if (*str
== 'b' || *str
== 'B')
595 if (str
[1] == '0' || str
[1] == '1')
600 else if (DIGIT_SEP (str
[1]))
601 SYNTAX_ERROR_AT (virtual_location
,
602 "digit separator after base indicator");
606 /* Now scan for a well-formed integer or float. */
609 unsigned int c
= *str
++;
611 if (ISDIGIT (c
) || (ISXDIGIT (c
) && radix
== 16))
613 seen_digit_sep
= false;
619 else if (DIGIT_SEP (c
))
620 seen_digit_sep
= true;
623 if (seen_digit_sep
|| DIGIT_SEP (*str
))
624 SYNTAX_ERROR_AT (virtual_location
,
625 "digit separator adjacent to decimal point");
626 seen_digit_sep
= false;
627 if (float_flag
== NOT_FLOAT
)
628 float_flag
= AFTER_POINT
;
630 SYNTAX_ERROR_AT (virtual_location
,
631 "too many decimal points in number");
633 else if ((radix
<= 10 && (c
== 'e' || c
== 'E'))
634 || (radix
== 16 && (c
== 'p' || c
== 'P')))
636 if (seen_digit_sep
|| DIGIT_SEP (*str
))
637 SYNTAX_ERROR_AT (virtual_location
,
638 "digit separator adjacent to exponent");
639 float_flag
= AFTER_EXPON
;
644 /* Start of suffix. */
650 if (seen_digit_sep
&& float_flag
!= AFTER_EXPON
)
651 SYNTAX_ERROR_AT (virtual_location
,
652 "digit separator outside digit sequence");
654 /* The suffix may be for decimal fixed-point constants without exponent. */
655 if (radix
!= 16 && float_flag
== NOT_FLOAT
)
657 result
= interpret_float_suffix (pfile
, str
, limit
- str
);
658 if ((result
& CPP_N_FRACT
) || (result
& CPP_N_ACCUM
))
660 result
|= CPP_N_FLOATING
;
661 /* We need to restore the radix to 10, if the radix is 8. */
665 if (CPP_PEDANTIC (pfile
))
666 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
667 "fixed-point constants are a GCC extension");
674 if (float_flag
!= NOT_FLOAT
&& radix
== 8)
677 if (max_digit
>= radix
)
680 SYNTAX_ERROR2_AT (virtual_location
,
681 "invalid digit \"%c\" in binary constant", '0' + max_digit
);
683 SYNTAX_ERROR2_AT (virtual_location
,
684 "invalid digit \"%c\" in octal constant", '0' + max_digit
);
687 if (float_flag
!= NOT_FLOAT
)
691 cpp_error_with_line (pfile
, CPP_DL_ERROR
, virtual_location
, 0,
692 "invalid prefix \"0b\" for floating constant");
693 return CPP_N_INVALID
;
696 if (radix
== 16 && !seen_digit
)
697 SYNTAX_ERROR_AT (virtual_location
,
698 "no digits in hexadecimal floating constant");
700 if (radix
== 16 && CPP_PEDANTIC (pfile
)
701 && !CPP_OPTION (pfile
, extended_numbers
))
703 if (CPP_OPTION (pfile
, cplusplus
))
704 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
705 "use of C++17 hexadecimal floating constant");
707 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
708 "use of C99 hexadecimal floating constant");
711 if (float_flag
== AFTER_EXPON
)
713 if (*str
== '+' || *str
== '-')
716 /* Exponent is decimal, even if string is a hex float. */
719 if (DIGIT_SEP (*str
))
720 SYNTAX_ERROR_AT (virtual_location
,
721 "digit separator adjacent to exponent");
723 SYNTAX_ERROR_AT (virtual_location
, "exponent has no digits");
727 seen_digit_sep
= DIGIT_SEP (*str
);
730 while (ISDIGIT (*str
) || DIGIT_SEP (*str
));
732 else if (radix
== 16)
733 SYNTAX_ERROR_AT (virtual_location
,
734 "hexadecimal floating constants require an exponent");
737 SYNTAX_ERROR_AT (virtual_location
,
738 "digit separator outside digit sequence");
740 result
= interpret_float_suffix (pfile
, str
, limit
- str
);
743 if (CPP_OPTION (pfile
, user_literals
))
746 *ud_suffix
= (const char *) str
;
747 result
= CPP_N_LARGE
| CPP_N_USERDEF
;
751 cpp_error_with_line (pfile
, CPP_DL_ERROR
, virtual_location
, 0,
752 "invalid suffix \"%.*s\" on floating constant",
753 (int) (limit
- str
), str
);
754 return CPP_N_INVALID
;
758 /* Traditional C didn't accept any floating suffixes. */
760 && CPP_WTRADITIONAL (pfile
)
761 && ! cpp_sys_macro_p (pfile
))
762 cpp_warning_with_line (pfile
, CPP_W_TRADITIONAL
, virtual_location
, 0,
763 "traditional C rejects the \"%.*s\" suffix",
764 (int) (limit
- str
), str
);
766 /* A suffix for double is a GCC extension via decimal float support.
767 If the suffix also specifies an imaginary value we'll catch that
769 if ((result
== CPP_N_MEDIUM
) && CPP_PEDANTIC (pfile
))
770 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
771 "suffix for double constant is a GCC extension");
773 /* Radix must be 10 for decimal floats. */
774 if ((result
& CPP_N_DFLOAT
) && radix
!= 10)
776 cpp_error_with_line (pfile
, CPP_DL_ERROR
, virtual_location
, 0,
777 "invalid suffix \"%.*s\" with hexadecimal floating constant",
778 (int) (limit
- str
), str
);
779 return CPP_N_INVALID
;
782 if ((result
& (CPP_N_FRACT
| CPP_N_ACCUM
)) && CPP_PEDANTIC (pfile
))
783 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
784 "fixed-point constants are a GCC extension");
786 if (result
& CPP_N_DFLOAT
)
788 if (CPP_PEDANTIC (pfile
) && !CPP_OPTION (pfile
, dfp_constants
))
789 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
790 "decimal float constants are a C2X feature");
791 else if (CPP_OPTION (pfile
, cpp_warn_c11_c2x_compat
) > 0)
792 cpp_warning_with_line (pfile
, CPP_W_C11_C2X_COMPAT
,
794 "decimal float constants are a C2X feature");
797 result
|= CPP_N_FLOATING
;
801 result
= interpret_int_suffix (pfile
, str
, limit
- str
);
804 if (CPP_OPTION (pfile
, user_literals
))
807 *ud_suffix
= (const char *) str
;
808 result
= CPP_N_UNSIGNED
| CPP_N_LARGE
| CPP_N_USERDEF
;
812 cpp_error_with_line (pfile
, CPP_DL_ERROR
, virtual_location
, 0,
813 "invalid suffix \"%.*s\" on integer constant",
814 (int) (limit
- str
), str
);
815 return CPP_N_INVALID
;
819 /* Traditional C only accepted the 'L' suffix.
820 Suppress warning about 'LL' with -Wno-long-long. */
821 if (CPP_WTRADITIONAL (pfile
) && ! cpp_sys_macro_p (pfile
))
823 int u_or_i
= (result
& (CPP_N_UNSIGNED
|CPP_N_IMAGINARY
));
824 int large
= (result
& CPP_N_WIDTH
) == CPP_N_LARGE
825 && CPP_OPTION (pfile
, cpp_warn_long_long
);
828 cpp_warning_with_line (pfile
, large
? CPP_W_LONG_LONG
: CPP_W_TRADITIONAL
,
830 "traditional C rejects the \"%.*s\" suffix",
831 (int) (limit
- str
), str
);
834 if ((result
& CPP_N_WIDTH
) == CPP_N_LARGE
835 && CPP_OPTION (pfile
, cpp_warn_long_long
))
837 const char *message
= CPP_OPTION (pfile
, cplusplus
)
838 ? N_("use of C++11 long long integer constant")
839 : N_("use of C99 long long integer constant");
841 if (CPP_OPTION (pfile
, c99
))
842 cpp_warning_with_line (pfile
, CPP_W_LONG_LONG
, virtual_location
,
845 cpp_pedwarning_with_line (pfile
, CPP_W_LONG_LONG
,
846 virtual_location
, 0, message
);
849 if ((result
& CPP_N_SIZE_T
) == CPP_N_SIZE_T
850 && !CPP_OPTION (pfile
, size_t_literals
))
852 const char *message
= (result
& CPP_N_UNSIGNED
) == CPP_N_UNSIGNED
853 ? N_("use of C++23 %<size_t%> integer constant")
854 : N_("use of C++23 %<make_signed_t<size_t>%> integer constant");
855 cpp_warning_with_line (pfile
, CPP_W_SIZE_T_LITERALS
,
856 virtual_location
, 0, message
);
859 result
|= CPP_N_INTEGER
;
863 if ((result
& CPP_N_IMAGINARY
) && CPP_PEDANTIC (pfile
))
864 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
865 "imaginary constants are a GCC extension");
868 if (!CPP_OPTION (pfile
, binary_constants
)
869 && CPP_PEDANTIC (pfile
))
870 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
871 CPP_OPTION (pfile
, cplusplus
)
872 ? N_("binary constants are a C++14 feature "
874 : N_("binary constants are a C2X feature "
875 "or GCC extension"));
876 else if (CPP_OPTION (pfile
, cpp_warn_c11_c2x_compat
) > 0)
877 cpp_warning_with_line (pfile
, CPP_W_C11_C2X_COMPAT
,
879 "binary constants are a C2X feature");
883 result
|= CPP_N_DECIMAL
;
884 else if (radix
== 16)
887 result
|= CPP_N_BINARY
;
889 result
|= CPP_N_OCTAL
;
894 return CPP_N_INVALID
;
897 /* cpp_interpret_integer converts an integer constant into a cpp_num,
898 of precision options->precision.
900 We do not provide any interface for decimal->float conversion,
901 because the preprocessor doesn't need it and we don't want to
902 drag in GCC's floating point emulator. */
904 cpp_interpret_integer (cpp_reader
*pfile
, const cpp_token
*token
,
907 const uchar
*p
, *end
;
912 result
.unsignedp
= !!(type
& CPP_N_UNSIGNED
);
913 result
.overflow
= false;
915 p
= token
->val
.str
.text
;
916 end
= p
+ token
->val
.str
.len
;
918 /* Common case of a single digit. */
919 if (token
->val
.str
.len
== 1)
920 result
.low
= p
[0] - '0';
924 size_t precision
= CPP_OPTION (pfile
, precision
);
925 unsigned int base
= 10, c
= 0;
926 bool overflow
= false;
928 if ((type
& CPP_N_RADIX
) == CPP_N_OCTAL
)
933 else if ((type
& CPP_N_RADIX
) == CPP_N_HEX
)
938 else if ((type
& CPP_N_RADIX
) == CPP_N_BINARY
)
944 /* We can add a digit to numbers strictly less than this without
945 needing the precision and slowness of double integers. */
946 max
= ~(cpp_num_part
) 0;
947 if (precision
< PART_PRECISION
)
948 max
>>= PART_PRECISION
- precision
;
949 max
= (max
- base
+ 1) / base
+ 1;
955 if (ISDIGIT (c
) || (base
== 16 && ISXDIGIT (c
)))
957 else if (DIGIT_SEP (c
))
962 /* Strict inequality for when max is set to zero. */
963 if (result
.low
< max
)
964 result
.low
= result
.low
* base
+ c
;
967 result
= append_digit (result
, c
, base
, precision
);
968 overflow
|= result
.overflow
;
973 if (overflow
&& !(type
& CPP_N_USERDEF
))
974 cpp_error (pfile
, CPP_DL_PEDWARN
,
975 "integer constant is too large for its type");
976 /* If too big to be signed, consider it unsigned. Only warn for
977 decimal numbers. Traditional numbers were always signed (but
978 we still honor an explicit U suffix); but we only have
979 traditional semantics in directives. */
980 else if (!result
.unsignedp
981 && !(CPP_OPTION (pfile
, traditional
)
982 && pfile
->state
.in_directive
)
983 && !num_positive (result
, precision
))
985 /* This is for constants within the range of uintmax_t but
986 not that of intmax_t. For such decimal constants, a
987 diagnostic is required for C99 as the selected type must
988 be signed and not having a type is a constraint violation
989 (DR#298, TC3), so this must be a pedwarn. For C90,
990 unsigned long is specified to be used for a constant that
991 does not fit in signed long; if uintmax_t has the same
992 range as unsigned long this means only a warning is
993 appropriate here. C90 permits the preprocessor to use a
994 wider range than unsigned long in the compiler, so if
995 uintmax_t is wider than unsigned long no diagnostic is
996 required for such constants in preprocessor #if
997 expressions and the compiler will pedwarn for such
998 constants outside the range of unsigned long that reach
999 the compiler so a diagnostic is not required there
1000 either; thus, pedwarn for C99 but use a plain warning for
1003 cpp_error (pfile
, (CPP_OPTION (pfile
, c99
)
1006 "integer constant is so large that it is unsigned");
1007 result
.unsignedp
= true;
1014 /* Append DIGIT to NUM, a number of PRECISION bits being read in base BASE. */
1016 append_digit (cpp_num num
, int digit
, int base
, size_t precision
)
1021 cpp_num_part add_high
, add_low
;
1023 /* Multiply by 2, 8 or 16. Catching this overflow here means we don't
1024 need to worry about add_high overflowing. */
1038 overflow
= !!(num
.high
>> (PART_PRECISION
- shift
));
1039 result
.high
= num
.high
<< shift
;
1040 result
.low
= num
.low
<< shift
;
1041 result
.high
|= num
.low
>> (PART_PRECISION
- shift
);
1042 result
.unsignedp
= num
.unsignedp
;
1046 add_low
= num
.low
<< 1;
1047 add_high
= (num
.high
<< 1) + (num
.low
>> (PART_PRECISION
- 1));
1050 add_high
= add_low
= 0;
1052 if (add_low
+ digit
< add_low
)
1056 if (result
.low
+ add_low
< result
.low
)
1058 if (result
.high
+ add_high
< result
.high
)
1061 result
.low
+= add_low
;
1062 result
.high
+= add_high
;
1063 result
.overflow
= overflow
;
1065 /* The above code catches overflow of a cpp_num type. This catches
1066 overflow of the (possibly shorter) target precision. */
1067 num
.low
= result
.low
;
1068 num
.high
= result
.high
;
1069 result
= num_trim (result
, precision
);
1070 if (!num_eq (result
, num
))
1071 result
.overflow
= true;
1076 /* Handle meeting "defined" in a preprocessor expression. */
1078 parse_defined (cpp_reader
*pfile
)
1082 cpp_hashnode
*node
= 0;
1083 const cpp_token
*token
;
1084 cpp_context
*initial_context
= pfile
->context
;
1086 /* Don't expand macros. */
1087 pfile
->state
.prevent_expansion
++;
1089 token
= cpp_get_token (pfile
);
1090 if (token
->type
== CPP_OPEN_PAREN
)
1093 token
= cpp_get_token (pfile
);
1096 if (token
->type
== CPP_NAME
)
1098 node
= token
->val
.node
.node
;
1099 if (paren
&& cpp_get_token (pfile
)->type
!= CPP_CLOSE_PAREN
)
1101 cpp_error (pfile
, CPP_DL_ERROR
, "missing ')' after \"defined\"");
1107 cpp_error (pfile
, CPP_DL_ERROR
,
1108 "operator \"defined\" requires an identifier");
1109 if (token
->flags
& NAMED_OP
)
1114 op
.type
= token
->type
;
1115 cpp_error (pfile
, CPP_DL_ERROR
,
1116 "(\"%s\" is an alternative token for \"%s\" in C++)",
1117 cpp_token_as_text (pfile
, token
),
1118 cpp_token_as_text (pfile
, &op
));
1122 bool is_defined
= false;
1125 if ((pfile
->context
!= initial_context
1126 || initial_context
!= &pfile
->base_context
)
1127 && CPP_OPTION (pfile
, warn_expansion_to_defined
))
1128 cpp_pedwarning (pfile
, CPP_W_EXPANSION_TO_DEFINED
,
1129 "this use of \"defined\" may not be portable");
1130 is_defined
= _cpp_defined_macro_p (node
);
1131 if (!_cpp_maybe_notify_macro_use (pfile
, node
, token
->src_loc
))
1132 /* It wasn't a macro after all. */
1134 _cpp_mark_macro_used (node
);
1136 /* A possible controlling macro of the form #if !defined ().
1137 _cpp_parse_expr checks there was no other junk on the line. */
1138 pfile
->mi_ind_cmacro
= node
;
1141 pfile
->state
.prevent_expansion
--;
1143 /* Do not treat conditional macros as being defined. This is due to the
1144 powerpc port using conditional macros for 'vector', 'bool', and 'pixel'
1145 to act as conditional keywords. This messes up tests like #ifndef
1147 result
.unsignedp
= false;
1149 result
.overflow
= false;
1150 result
.low
= is_defined
;
1154 /* Convert a token into a CPP_NUMBER (an interpreted preprocessing
1155 number or character constant, or the result of the "defined" or "#"
1158 eval_token (cpp_reader
*pfile
, const cpp_token
*token
,
1159 location_t virtual_location
)
1165 result
.unsignedp
= false;
1166 result
.overflow
= false;
1168 switch (token
->type
)
1171 temp
= cpp_classify_number (pfile
, token
, NULL
, virtual_location
);
1172 if (temp
& CPP_N_USERDEF
)
1173 cpp_error (pfile
, CPP_DL_ERROR
,
1174 "user-defined literal in preprocessor expression");
1175 switch (temp
& CPP_N_CATEGORY
)
1177 case CPP_N_FLOATING
:
1178 cpp_error_with_line (pfile
, CPP_DL_ERROR
, virtual_location
, 0,
1179 "floating constant in preprocessor expression");
1182 if (!(temp
& CPP_N_IMAGINARY
))
1183 return cpp_interpret_integer (pfile
, token
, temp
);
1184 cpp_error_with_line (pfile
, CPP_DL_ERROR
, virtual_location
, 0,
1185 "imaginary number in preprocessor expression");
1189 /* Error already issued. */
1192 result
.high
= result
.low
= 0;
1201 cppchar_t cc
= cpp_interpret_charconst (pfile
, token
,
1206 /* Sign-extend the result if necessary. */
1207 if (!unsignedp
&& (cppchar_signed_t
) cc
< 0)
1209 if (PART_PRECISION
> BITS_PER_CPPCHAR_T
)
1210 result
.low
|= ~(~(cpp_num_part
) 0
1211 >> (PART_PRECISION
- BITS_PER_CPPCHAR_T
));
1212 result
.high
= ~(cpp_num_part
) 0;
1213 result
= num_trim (result
, CPP_OPTION (pfile
, precision
));
1219 if (token
->val
.node
.node
== pfile
->spec_nodes
.n_defined
)
1220 return parse_defined (pfile
);
1221 else if (CPP_OPTION (pfile
, true_false
)
1222 && (token
->val
.node
.node
== pfile
->spec_nodes
.n_true
1223 || token
->val
.node
.node
== pfile
->spec_nodes
.n_false
))
1226 result
.low
= (token
->val
.node
.node
== pfile
->spec_nodes
.n_true
);
1232 if (CPP_OPTION (pfile
, warn_undef
) && !pfile
->state
.skip_eval
)
1233 cpp_warning_with_line (pfile
, CPP_W_UNDEF
, virtual_location
, 0,
1234 "\"%s\" is not defined, evaluates to 0",
1235 NODE_NAME (token
->val
.node
.node
));
1240 if (!pfile
->state
.skipping
)
1242 /* A pedantic warning takes precedence over a deprecated
1244 if (CPP_PEDANTIC (pfile
))
1245 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
,
1246 virtual_location
, 0,
1247 "assertions are a GCC extension");
1248 else if (CPP_OPTION (pfile
, cpp_warn_deprecated
))
1249 cpp_warning_with_line (pfile
, CPP_W_DEPRECATED
, virtual_location
, 0,
1250 "assertions are a deprecated extension");
1252 _cpp_test_assertion (pfile
, &temp
);
1261 result
.unsignedp
= !!unsignedp
;
1265 /* Operator precedence and flags table.
1267 After an operator is returned from the lexer, if it has priority less
1268 than the operator on the top of the stack, we reduce the stack by one
1269 operator and repeat the test. Since equal priorities do not reduce,
1270 this is naturally right-associative.
1272 We handle left-associative operators by decrementing the priority of
1273 just-lexed operators by one, but retaining the priority of operators
1274 already on the stack.
1276 The remaining cases are '(' and ')'. We handle '(' by skipping the
1277 reduction phase completely. ')' is given lower priority than
1278 everything else, including '(', effectively forcing a reduction of the
1279 parenthesized expression. If there is a matching '(', the routine
1280 reduce() exits immediately. If the normal exit route sees a ')', then
1281 there cannot have been a matching '(' and an error message is output.
1283 The parser assumes all shifted operators require a left operand unless
1284 the flag NO_L_OPERAND is set. These semantics are automatic; any
1285 extra semantics need to be handled with operator-specific code. */
1287 /* Flags. If CHECK_PROMOTION, we warn if the effective sign of an
1288 operand changes because of integer promotions. */
1289 #define NO_L_OPERAND (1 << 0)
1290 #define LEFT_ASSOC (1 << 1)
1291 #define CHECK_PROMOTION (1 << 2)
1293 /* Operator to priority map. Must be in the same order as the first
1294 N entries of enum cpp_ttype. */
1295 static const struct cpp_operator
1301 /* EQ */ {0, 0}, /* Shouldn't happen. */
1302 /* NOT */ {16, NO_L_OPERAND
},
1303 /* GREATER */ {12, LEFT_ASSOC
| CHECK_PROMOTION
},
1304 /* LESS */ {12, LEFT_ASSOC
| CHECK_PROMOTION
},
1305 /* PLUS */ {14, LEFT_ASSOC
| CHECK_PROMOTION
},
1306 /* MINUS */ {14, LEFT_ASSOC
| CHECK_PROMOTION
},
1307 /* MULT */ {15, LEFT_ASSOC
| CHECK_PROMOTION
},
1308 /* DIV */ {15, LEFT_ASSOC
| CHECK_PROMOTION
},
1309 /* MOD */ {15, LEFT_ASSOC
| CHECK_PROMOTION
},
1310 /* AND */ {9, LEFT_ASSOC
| CHECK_PROMOTION
},
1311 /* OR */ {7, LEFT_ASSOC
| CHECK_PROMOTION
},
1312 /* XOR */ {8, LEFT_ASSOC
| CHECK_PROMOTION
},
1313 /* RSHIFT */ {13, LEFT_ASSOC
},
1314 /* LSHIFT */ {13, LEFT_ASSOC
},
1316 /* COMPL */ {16, NO_L_OPERAND
},
1317 /* AND_AND */ {6, LEFT_ASSOC
},
1318 /* OR_OR */ {5, LEFT_ASSOC
},
1319 /* Note that QUERY, COLON, and COMMA must have the same precedence.
1320 However, there are some special cases for these in reduce(). */
1322 /* COLON */ {4, LEFT_ASSOC
| CHECK_PROMOTION
},
1323 /* COMMA */ {4, LEFT_ASSOC
},
1324 /* OPEN_PAREN */ {1, NO_L_OPERAND
},
1325 /* CLOSE_PAREN */ {0, 0},
1327 /* EQ_EQ */ {11, LEFT_ASSOC
},
1328 /* NOT_EQ */ {11, LEFT_ASSOC
},
1329 /* GREATER_EQ */ {12, LEFT_ASSOC
| CHECK_PROMOTION
},
1330 /* LESS_EQ */ {12, LEFT_ASSOC
| CHECK_PROMOTION
},
1331 /* UPLUS */ {16, NO_L_OPERAND
},
1332 /* UMINUS */ {16, NO_L_OPERAND
}
1335 /* Parse and evaluate a C expression, reading from PFILE.
1336 Returns the truth value of the expression.
1338 The implementation is an operator precedence parser, i.e. a
1339 bottom-up parser, using a stack for not-yet-reduced tokens.
1341 The stack base is op_stack, and the current stack pointer is 'top'.
1342 There is a stack element for each operator (only), and the most
1343 recently pushed operator is 'top->op'. An operand (value) is
1344 stored in the 'value' field of the stack element of the operator
1345 that precedes it. */
1347 _cpp_parse_expr (cpp_reader
*pfile
, bool is_if
)
1349 struct op
*top
= pfile
->op_stack
;
1350 unsigned int lex_count
;
1351 bool saw_leading_not
, want_value
= true;
1352 location_t virtual_location
= 0;
1354 pfile
->state
.skip_eval
= 0;
1356 /* Set up detection of #if ! defined(). */
1357 pfile
->mi_ind_cmacro
= 0;
1358 saw_leading_not
= false;
1361 /* Lowest priority operator prevents further reductions. */
1369 op
.token
= cpp_get_token_with_location (pfile
, &virtual_location
);
1370 op
.op
= op
.token
->type
;
1371 op
.loc
= virtual_location
;
1375 /* These tokens convert into values. */
1385 SYNTAX_ERROR2_AT (op
.loc
,
1386 "missing binary operator before token \"%s\"",
1387 cpp_token_as_text (pfile
, op
.token
));
1389 top
->value
= eval_token (pfile
, op
.token
, op
.loc
);
1393 saw_leading_not
= lex_count
== 1;
1409 if ((int) op
.op
<= (int) CPP_EQ
|| (int) op
.op
>= (int) CPP_PLUS_EQ
)
1410 SYNTAX_ERROR2_AT (op
.loc
,
1411 "token \"%s\" is not valid in preprocessor expressions",
1412 cpp_token_as_text (pfile
, op
.token
));
1416 /* Check we have a value or operator as appropriate. */
1417 if (optab
[op
.op
].flags
& NO_L_OPERAND
)
1420 SYNTAX_ERROR2_AT (op
.loc
,
1421 "missing binary operator before token \"%s\"",
1422 cpp_token_as_text (pfile
, op
.token
));
1424 else if (want_value
)
1426 /* We want a number (or expression) and haven't got one.
1427 Try to emit a specific diagnostic. */
1428 if (op
.op
== CPP_CLOSE_PAREN
&& top
->op
== CPP_OPEN_PAREN
)
1429 SYNTAX_ERROR_AT (op
.loc
,
1430 "missing expression between '(' and ')'");
1432 if (op
.op
== CPP_EOF
&& top
->op
== CPP_EOF
)
1433 SYNTAX_ERROR2_AT (op
.loc
,
1434 "%s with no expression", is_if
? "#if" : "#elif");
1436 if (top
->op
!= CPP_EOF
&& top
->op
!= CPP_OPEN_PAREN
)
1437 SYNTAX_ERROR2_AT (op
.loc
,
1438 "operator '%s' has no right operand",
1439 cpp_token_as_text (pfile
, top
->token
));
1440 else if (op
.op
== CPP_CLOSE_PAREN
|| op
.op
== CPP_EOF
)
1441 /* Complain about missing paren during reduction. */;
1443 SYNTAX_ERROR2_AT (op
.loc
,
1444 "operator '%s' has no left operand",
1445 cpp_token_as_text (pfile
, op
.token
));
1448 top
= reduce (pfile
, top
, op
.op
);
1452 if (op
.op
== CPP_EOF
)
1457 case CPP_CLOSE_PAREN
:
1460 if (!num_zerop (top
->value
))
1461 pfile
->state
.skip_eval
++;
1465 if (num_zerop (top
->value
))
1466 pfile
->state
.skip_eval
++;
1469 if (top
->op
!= CPP_QUERY
)
1470 SYNTAX_ERROR_AT (op
.loc
,
1471 " ':' without preceding '?'");
1472 if (!num_zerop (top
[-1].value
)) /* Was '?' condition true? */
1473 pfile
->state
.skip_eval
++;
1475 pfile
->state
.skip_eval
--;
1482 /* Check for and handle stack overflow. */
1483 if (++top
== pfile
->op_limit
)
1484 top
= _cpp_expand_op_stack (pfile
);
1487 top
->token
= op
.token
;
1491 /* The controlling macro expression is only valid if we called lex 3
1492 times: <!> <defined expression> and <EOF>. push_conditional ()
1493 checks that we are at top-of-file. */
1494 if (pfile
->mi_ind_cmacro
&& !(saw_leading_not
&& lex_count
== 3))
1495 pfile
->mi_ind_cmacro
= 0;
1497 if (top
!= pfile
->op_stack
)
1499 cpp_error_with_line (pfile
, CPP_DL_ICE
, top
->loc
, 0,
1500 "unbalanced stack in %s",
1501 is_if
? "#if" : "#elif");
1503 return false; /* Return false on syntax error. */
1506 return !num_zerop (top
->value
);
1509 /* Reduce the operator / value stack if possible, in preparation for
1510 pushing operator OP. Returns NULL on error, otherwise the top of
1513 reduce (cpp_reader
*pfile
, struct op
*top
, enum cpp_ttype op
)
1517 if (top
->op
<= CPP_EQ
|| top
->op
> CPP_LAST_CPP_OP
+ 2)
1520 cpp_error (pfile
, CPP_DL_ICE
, "impossible operator '%u'", top
->op
);
1524 if (op
== CPP_OPEN_PAREN
)
1527 /* Decrement the priority of left-associative operators to force a
1528 reduction with operators of otherwise equal priority. */
1529 prio
= optab
[op
].prio
- ((optab
[op
].flags
& LEFT_ASSOC
) != 0);
1530 while (prio
< optab
[top
->op
].prio
)
1532 if (CPP_OPTION (pfile
, warn_num_sign_change
)
1533 && optab
[top
->op
].flags
& CHECK_PROMOTION
)
1534 check_promotion (pfile
, top
);
1542 top
[-1].value
= num_unary_op (pfile
, top
->value
, top
->op
);
1543 top
[-1].loc
= top
->loc
;
1551 top
[-1].value
= num_binary_op (pfile
, top
[-1].value
,
1552 top
->value
, top
->op
);
1553 top
[-1].loc
= top
->loc
;
1558 case CPP_GREATER_EQ
:
1561 = num_inequality_op (pfile
, top
[-1].value
, top
->value
, top
->op
);
1562 top
[-1].loc
= top
->loc
;
1568 = num_equality_op (pfile
, top
[-1].value
, top
->value
, top
->op
);
1569 top
[-1].loc
= top
->loc
;
1576 = num_bitwise_op (pfile
, top
[-1].value
, top
->value
, top
->op
);
1577 top
[-1].loc
= top
->loc
;
1581 top
[-1].value
= num_mul (pfile
, top
[-1].value
, top
->value
);
1582 top
[-1].loc
= top
->loc
;
1587 top
[-1].value
= num_div_op (pfile
, top
[-1].value
,
1588 top
->value
, top
->op
, top
->loc
);
1589 top
[-1].loc
= top
->loc
;
1594 if (!num_zerop (top
->value
))
1595 pfile
->state
.skip_eval
--;
1596 top
->value
.low
= (!num_zerop (top
->value
)
1597 || !num_zerop (top
[1].value
));
1598 top
->value
.high
= 0;
1599 top
->value
.unsignedp
= false;
1600 top
->value
.overflow
= false;
1601 top
->loc
= top
[1].loc
;
1606 if (num_zerop (top
->value
))
1607 pfile
->state
.skip_eval
--;
1608 top
->value
.low
= (!num_zerop (top
->value
)
1609 && !num_zerop (top
[1].value
));
1610 top
->value
.high
= 0;
1611 top
->value
.unsignedp
= false;
1612 top
->value
.overflow
= false;
1613 top
->loc
= top
[1].loc
;
1616 case CPP_OPEN_PAREN
:
1617 if (op
!= CPP_CLOSE_PAREN
)
1619 cpp_error_with_line (pfile
, CPP_DL_ERROR
,
1620 top
->token
->src_loc
,
1621 0, "missing ')' in expression");
1625 top
->value
= top
[1].value
;
1626 top
->loc
= top
[1].loc
;
1631 if (!num_zerop (top
->value
))
1633 pfile
->state
.skip_eval
--;
1634 top
->value
= top
[1].value
;
1635 top
->loc
= top
[1].loc
;
1639 top
->value
= top
[2].value
;
1640 top
->loc
= top
[2].loc
;
1642 top
->value
.unsignedp
= (top
[1].value
.unsignedp
1643 || top
[2].value
.unsignedp
);
1647 /* COMMA and COLON should not reduce a QUERY operator. */
1648 if (op
== CPP_COMMA
|| op
== CPP_COLON
)
1650 cpp_error (pfile
, CPP_DL_ERROR
, "'?' without following ':'");
1658 if (top
->value
.overflow
&& !pfile
->state
.skip_eval
)
1659 cpp_error (pfile
, CPP_DL_PEDWARN
,
1660 "integer overflow in preprocessor expression");
1663 if (op
== CPP_CLOSE_PAREN
)
1665 cpp_error (pfile
, CPP_DL_ERROR
, "missing '(' in expression");
1672 /* Returns the position of the old top of stack after expansion. */
1674 _cpp_expand_op_stack (cpp_reader
*pfile
)
1676 size_t old_size
= (size_t) (pfile
->op_limit
- pfile
->op_stack
);
1677 size_t new_size
= old_size
* 2 + 20;
1679 pfile
->op_stack
= XRESIZEVEC (struct op
, pfile
->op_stack
, new_size
);
1680 pfile
->op_limit
= pfile
->op_stack
+ new_size
;
1682 return pfile
->op_stack
+ old_size
;
1685 /* Emits a warning if the effective sign of either operand of OP
1686 changes because of integer promotions. */
1688 check_promotion (cpp_reader
*pfile
, const struct op
*op
)
1690 if (op
->value
.unsignedp
== op
[-1].value
.unsignedp
)
1693 if (op
->value
.unsignedp
)
1695 if (!num_positive (op
[-1].value
, CPP_OPTION (pfile
, precision
)))
1696 cpp_error_with_line (pfile
, CPP_DL_WARNING
, op
[-1].loc
, 0,
1697 "the left operand of \"%s\" changes sign when promoted",
1698 cpp_token_as_text (pfile
, op
->token
));
1700 else if (!num_positive (op
->value
, CPP_OPTION (pfile
, precision
)))
1701 cpp_error_with_line (pfile
, CPP_DL_WARNING
, op
->loc
, 0,
1702 "the right operand of \"%s\" changes sign when promoted",
1703 cpp_token_as_text (pfile
, op
->token
));
1706 /* Clears the unused high order bits of the number pointed to by PNUM. */
1708 num_trim (cpp_num num
, size_t precision
)
1710 if (precision
> PART_PRECISION
)
1712 precision
-= PART_PRECISION
;
1713 if (precision
< PART_PRECISION
)
1714 num
.high
&= ((cpp_num_part
) 1 << precision
) - 1;
1718 if (precision
< PART_PRECISION
)
1719 num
.low
&= ((cpp_num_part
) 1 << precision
) - 1;
1726 /* True iff A (presumed signed) >= 0. */
1728 num_positive (cpp_num num
, size_t precision
)
1730 if (precision
> PART_PRECISION
)
1732 precision
-= PART_PRECISION
;
1733 return (num
.high
& (cpp_num_part
) 1 << (precision
- 1)) == 0;
1736 return (num
.low
& (cpp_num_part
) 1 << (precision
- 1)) == 0;
1739 /* Sign extend a number, with PRECISION significant bits and all
1740 others assumed clear, to fill out a cpp_num structure. */
1742 cpp_num_sign_extend (cpp_num num
, size_t precision
)
1746 if (precision
> PART_PRECISION
)
1748 precision
-= PART_PRECISION
;
1749 if (precision
< PART_PRECISION
1750 && (num
.high
& (cpp_num_part
) 1 << (precision
- 1)))
1751 num
.high
|= ~(~(cpp_num_part
) 0 >> (PART_PRECISION
- precision
));
1753 else if (num
.low
& (cpp_num_part
) 1 << (precision
- 1))
1755 if (precision
< PART_PRECISION
)
1756 num
.low
|= ~(~(cpp_num_part
) 0 >> (PART_PRECISION
- precision
));
1757 num
.high
= ~(cpp_num_part
) 0;
1764 /* Returns the negative of NUM. */
1766 num_negate (cpp_num num
, size_t precision
)
1771 num
.high
= ~num
.high
;
1775 num
= num_trim (num
, precision
);
1776 num
.overflow
= (!num
.unsignedp
&& num_eq (num
, copy
) && !num_zerop (num
));
1781 /* Returns true if A >= B. */
1783 num_greater_eq (cpp_num pa
, cpp_num pb
, size_t precision
)
1787 unsignedp
= pa
.unsignedp
|| pb
.unsignedp
;
1791 /* Both numbers have signed type. If they are of different
1792 sign, the answer is the sign of A. */
1793 unsignedp
= num_positive (pa
, precision
);
1795 if (unsignedp
!= num_positive (pb
, precision
))
1798 /* Otherwise we can do an unsigned comparison. */
1801 return (pa
.high
> pb
.high
) || (pa
.high
== pb
.high
&& pa
.low
>= pb
.low
);
1804 /* Returns LHS OP RHS, where OP is a bit-wise operation. */
1806 num_bitwise_op (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1807 cpp_num lhs
, cpp_num rhs
, enum cpp_ttype op
)
1809 lhs
.overflow
= false;
1810 lhs
.unsignedp
= lhs
.unsignedp
|| rhs
.unsignedp
;
1812 /* As excess precision is zeroed, there is no need to num_trim () as
1813 these operations cannot introduce a set bit there. */
1817 lhs
.high
&= rhs
.high
;
1819 else if (op
== CPP_OR
)
1822 lhs
.high
|= rhs
.high
;
1827 lhs
.high
^= rhs
.high
;
1833 /* Returns LHS OP RHS, where OP is an inequality. */
1835 num_inequality_op (cpp_reader
*pfile
, cpp_num lhs
, cpp_num rhs
,
1838 bool gte
= num_greater_eq (lhs
, rhs
, CPP_OPTION (pfile
, precision
));
1840 if (op
== CPP_GREATER_EQ
)
1842 else if (op
== CPP_LESS
)
1844 else if (op
== CPP_GREATER
)
1845 lhs
.low
= gte
&& !num_eq (lhs
, rhs
);
1846 else /* CPP_LESS_EQ. */
1847 lhs
.low
= !gte
|| num_eq (lhs
, rhs
);
1850 lhs
.overflow
= false;
1851 lhs
.unsignedp
= false;
1855 /* Returns LHS OP RHS, where OP is == or !=. */
1857 num_equality_op (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1858 cpp_num lhs
, cpp_num rhs
, enum cpp_ttype op
)
1860 /* Work around a 3.0.4 bug; see PR 6950. */
1861 bool eq
= num_eq (lhs
, rhs
);
1862 if (op
== CPP_NOT_EQ
)
1866 lhs
.overflow
= false;
1867 lhs
.unsignedp
= false;
1871 /* Shift NUM, of width PRECISION, right by N bits. */
1873 num_rshift (cpp_num num
, size_t precision
, size_t n
)
1875 cpp_num_part sign_mask
;
1876 bool x
= num_positive (num
, precision
);
1878 if (num
.unsignedp
|| x
)
1881 sign_mask
= ~(cpp_num_part
) 0;
1884 num
.high
= num
.low
= sign_mask
;
1888 if (precision
< PART_PRECISION
)
1889 num
.high
= sign_mask
, num
.low
|= sign_mask
<< precision
;
1890 else if (precision
< 2 * PART_PRECISION
)
1891 num
.high
|= sign_mask
<< (precision
- PART_PRECISION
);
1893 if (n
>= PART_PRECISION
)
1895 n
-= PART_PRECISION
;
1897 num
.high
= sign_mask
;
1902 num
.low
= (num
.low
>> n
) | (num
.high
<< (PART_PRECISION
- n
));
1903 num
.high
= (num
.high
>> n
) | (sign_mask
<< (PART_PRECISION
- n
));
1907 num
= num_trim (num
, precision
);
1908 num
.overflow
= false;
1912 /* Shift NUM, of width PRECISION, left by N bits. */
1914 num_lshift (cpp_num num
, size_t precision
, size_t n
)
1918 num
.overflow
= !num
.unsignedp
&& !num_zerop (num
);
1919 num
.high
= num
.low
= 0;
1923 cpp_num orig
, maybe_orig
;
1927 if (m
>= PART_PRECISION
)
1929 m
-= PART_PRECISION
;
1935 num
.high
= (num
.high
<< m
) | (num
.low
>> (PART_PRECISION
- m
));
1938 num
= num_trim (num
, precision
);
1941 num
.overflow
= false;
1944 maybe_orig
= num_rshift (num
, precision
, n
);
1945 num
.overflow
= !num_eq (orig
, maybe_orig
);
1952 /* The four unary operators: +, -, ! and ~. */
1954 num_unary_op (cpp_reader
*pfile
, cpp_num num
, enum cpp_ttype op
)
1959 if (CPP_WTRADITIONAL (pfile
) && !pfile
->state
.skip_eval
)
1960 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
1961 "traditional C rejects the unary plus operator");
1962 num
.overflow
= false;
1966 num
= num_negate (num
, CPP_OPTION (pfile
, precision
));
1970 num
.high
= ~num
.high
;
1972 num
= num_trim (num
, CPP_OPTION (pfile
, precision
));
1973 num
.overflow
= false;
1976 default: /* case CPP_NOT: */
1977 num
.low
= num_zerop (num
);
1979 num
.overflow
= false;
1980 num
.unsignedp
= false;
1987 /* The various binary operators. */
1989 num_binary_op (cpp_reader
*pfile
, cpp_num lhs
, cpp_num rhs
, enum cpp_ttype op
)
1992 size_t precision
= CPP_OPTION (pfile
, precision
);
2000 if (!rhs
.unsignedp
&& !num_positive (rhs
, precision
))
2002 /* A negative shift is a positive shift the other way. */
2003 if (op
== CPP_LSHIFT
)
2007 rhs
= num_negate (rhs
, precision
);
2010 n
= ~0; /* Maximal. */
2013 if (op
== CPP_LSHIFT
)
2014 lhs
= num_lshift (lhs
, precision
, n
);
2016 lhs
= num_rshift (lhs
, precision
, n
);
2021 result
.low
= lhs
.low
- rhs
.low
;
2022 result
.high
= lhs
.high
- rhs
.high
;
2023 if (result
.low
> lhs
.low
)
2025 result
.unsignedp
= lhs
.unsignedp
|| rhs
.unsignedp
;
2026 result
.overflow
= false;
2028 result
= num_trim (result
, precision
);
2029 if (!result
.unsignedp
)
2031 bool lhsp
= num_positive (lhs
, precision
);
2032 result
.overflow
= (lhsp
!= num_positive (rhs
, precision
)
2033 && lhsp
!= num_positive (result
, precision
));
2038 result
.low
= lhs
.low
+ rhs
.low
;
2039 result
.high
= lhs
.high
+ rhs
.high
;
2040 if (result
.low
< lhs
.low
)
2042 result
.unsignedp
= lhs
.unsignedp
|| rhs
.unsignedp
;
2043 result
.overflow
= false;
2045 result
= num_trim (result
, precision
);
2046 if (!result
.unsignedp
)
2048 bool lhsp
= num_positive (lhs
, precision
);
2049 result
.overflow
= (lhsp
== num_positive (rhs
, precision
)
2050 && lhsp
!= num_positive (result
, precision
));
2055 default: /* case CPP_COMMA: */
2056 if (CPP_PEDANTIC (pfile
) && (!CPP_OPTION (pfile
, c99
)
2057 || !pfile
->state
.skip_eval
))
2058 cpp_pedwarning (pfile
, CPP_W_PEDANTIC
,
2059 "comma operator in operand of #if");
2067 /* Multiplies two unsigned cpp_num_parts to give a cpp_num. This
2070 num_part_mul (cpp_num_part lhs
, cpp_num_part rhs
)
2073 cpp_num_part middle
[2], temp
;
2075 result
.low
= LOW_PART (lhs
) * LOW_PART (rhs
);
2076 result
.high
= HIGH_PART (lhs
) * HIGH_PART (rhs
);
2078 middle
[0] = LOW_PART (lhs
) * HIGH_PART (rhs
);
2079 middle
[1] = HIGH_PART (lhs
) * LOW_PART (rhs
);
2082 result
.low
+= LOW_PART (middle
[0]) << (PART_PRECISION
/ 2);
2083 if (result
.low
< temp
)
2087 result
.low
+= LOW_PART (middle
[1]) << (PART_PRECISION
/ 2);
2088 if (result
.low
< temp
)
2091 result
.high
+= HIGH_PART (middle
[0]);
2092 result
.high
+= HIGH_PART (middle
[1]);
2093 result
.unsignedp
= true;
2094 result
.overflow
= false;
2099 /* Multiply two preprocessing numbers. */
2101 num_mul (cpp_reader
*pfile
, cpp_num lhs
, cpp_num rhs
)
2103 cpp_num result
, temp
;
2104 bool unsignedp
= lhs
.unsignedp
|| rhs
.unsignedp
;
2105 bool overflow
, negate
= false;
2106 size_t precision
= CPP_OPTION (pfile
, precision
);
2108 /* Prepare for unsigned multiplication. */
2111 if (!num_positive (lhs
, precision
))
2112 negate
= !negate
, lhs
= num_negate (lhs
, precision
);
2113 if (!num_positive (rhs
, precision
))
2114 negate
= !negate
, rhs
= num_negate (rhs
, precision
);
2117 overflow
= lhs
.high
&& rhs
.high
;
2118 result
= num_part_mul (lhs
.low
, rhs
.low
);
2120 temp
= num_part_mul (lhs
.high
, rhs
.low
);
2121 result
.high
+= temp
.low
;
2125 temp
= num_part_mul (lhs
.low
, rhs
.high
);
2126 result
.high
+= temp
.low
;
2130 temp
.low
= result
.low
, temp
.high
= result
.high
;
2131 result
= num_trim (result
, precision
);
2132 if (!num_eq (result
, temp
))
2136 result
= num_negate (result
, precision
);
2139 result
.overflow
= false;
2141 result
.overflow
= overflow
|| (num_positive (result
, precision
) ^ !negate
2142 && !num_zerop (result
));
2143 result
.unsignedp
= unsignedp
;
2148 /* Divide two preprocessing numbers, LHS and RHS, returning the answer
2149 or the remainder depending upon OP. LOCATION is the source location
2150 of this operator (for diagnostics). */
2153 num_div_op (cpp_reader
*pfile
, cpp_num lhs
, cpp_num rhs
, enum cpp_ttype op
,
2154 location_t location
)
2156 cpp_num result
, sub
;
2158 bool unsignedp
= lhs
.unsignedp
|| rhs
.unsignedp
;
2159 bool negate
= false, lhs_neg
= false;
2160 size_t i
, precision
= CPP_OPTION (pfile
, precision
);
2162 /* Prepare for unsigned division. */
2165 if (!num_positive (lhs
, precision
))
2166 negate
= !negate
, lhs_neg
= true, lhs
= num_negate (lhs
, precision
);
2167 if (!num_positive (rhs
, precision
))
2168 negate
= !negate
, rhs
= num_negate (rhs
, precision
);
2171 /* Find the high bit. */
2175 mask
= (cpp_num_part
) 1 << (i
- PART_PRECISION
);
2176 for (; ; i
--, mask
>>= 1)
2177 if (rhs
.high
& mask
)
2182 if (precision
> PART_PRECISION
)
2183 i
= precision
- PART_PRECISION
- 1;
2186 mask
= (cpp_num_part
) 1 << i
;
2187 for (; ; i
--, mask
>>= 1)
2193 if (!pfile
->state
.skip_eval
)
2194 cpp_error_with_line (pfile
, CPP_DL_ERROR
, location
, 0,
2195 "division by zero in #if");
2199 /* First nonzero bit of RHS is bit I. Do naive division by
2200 shifting the RHS fully left, and subtracting from LHS if LHS is
2201 at least as big, and then repeating but with one less shift.
2202 This is not very efficient, but is easy to understand. */
2204 rhs
.unsignedp
= true;
2205 lhs
.unsignedp
= true;
2206 i
= precision
- i
- 1;
2207 sub
= num_lshift (rhs
, precision
, i
);
2209 result
.high
= result
.low
= 0;
2212 if (num_greater_eq (lhs
, sub
, precision
))
2214 lhs
= num_binary_op (pfile
, lhs
, sub
, CPP_MINUS
);
2215 if (i
>= PART_PRECISION
)
2216 result
.high
|= (cpp_num_part
) 1 << (i
- PART_PRECISION
);
2218 result
.low
|= (cpp_num_part
) 1 << i
;
2222 sub
.low
= (sub
.low
>> 1) | (sub
.high
<< (PART_PRECISION
- 1));
2226 /* We divide so that the remainder has the sign of the LHS. */
2229 result
.unsignedp
= unsignedp
;
2230 result
.overflow
= false;
2234 result
= num_negate (result
, precision
);
2235 result
.overflow
= (num_positive (result
, precision
) ^ !negate
2236 && !num_zerop (result
));
2243 lhs
.unsignedp
= unsignedp
;
2244 lhs
.overflow
= false;
2246 lhs
= num_negate (lhs
, precision
);