1 /* Parse C expressions for cpplib.
2 Copyright (C) 1987-2016 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 source_location 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
*, source_location
);
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
)
94 size_t f
, d
, l
, w
, q
, i
, fn
, fnx
, fn_bits
;
97 f
= d
= l
= w
= q
= i
= fn
= fnx
= fn_bits
= 0;
99 /* The following decimal float suffixes, from TR 24732:2009 and TS
100 18661-2:2015, 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). */
136 /* Process decimal float suffixes, which are two letters starting
137 with d or D. Order and case are significant. */
138 if (len
== 2 && (*s
== 'd' || *s
== 'D'))
140 bool uppercase
= (*s
== 'D');
143 case 'f': return (!uppercase
? (CPP_N_DFLOAT
| CPP_N_SMALL
): 0); break;
144 case 'F': return (uppercase
? (CPP_N_DFLOAT
| CPP_N_SMALL
) : 0); break;
145 case 'd': return (!uppercase
? (CPP_N_DFLOAT
| CPP_N_MEDIUM
): 0); break;
146 case 'D': return (uppercase
? (CPP_N_DFLOAT
| CPP_N_MEDIUM
) : 0); break;
147 case 'l': return (!uppercase
? (CPP_N_DFLOAT
| CPP_N_LARGE
) : 0); break;
148 case 'L': return (uppercase
? (CPP_N_DFLOAT
| CPP_N_LARGE
) : 0); break;
150 /* Additional two-character suffixes beginning with D are not
151 for decimal float constants. */
156 if (CPP_OPTION (pfile
, ext_numeric_literals
))
158 /* Recognize a fixed-point suffix. */
162 case 'k': case 'K': flags
= CPP_N_ACCUM
; break;
163 case 'r': case 'R': flags
= CPP_N_FRACT
; break;
167 /* Continue processing a fixed-point suffix. The suffix is case
168 insensitive except for ll or LL. Order is significant. */
175 if (*s
== 'u' || *s
== 'U')
177 flags
|= CPP_N_UNSIGNED
;
188 return flags
|= CPP_N_SMALL
;
192 return flags
|= CPP_N_MEDIUM
;
193 if (len
== 2 && s
[1] == 'l')
194 return flags
|= CPP_N_LARGE
;
198 return flags
|= CPP_N_MEDIUM
;
199 if (len
== 2 && s
[1] == 'L')
200 return flags
|= CPP_N_LARGE
;
205 /* Anything left at this point is invalid. */
210 /* In any remaining valid suffix, the case and order don't matter. */
218 && !CPP_OPTION (pfile
, cplusplus
)
227 && fn_bits
< CPP_FLOATN_MAX
)
229 fn_bits
= fn_bits
* 10 + (s
[1] - '0');
233 if (len
> 0 && s
[1] == 'x')
243 case 'd': case 'D': d
++; break;
244 case 'l': case 'L': l
++; break;
245 case 'w': case 'W': w
++; break;
246 case 'q': case 'Q': q
++; break;
248 case 'j': case 'J': i
++; break;
255 /* Reject any case of multiple suffixes specifying types, multiple
256 suffixes specifying an imaginary constant, _FloatN or _FloatNx
257 suffixes for invalid values of N, and _FloatN suffixes for values
258 of N larger than can be represented in the return value. The
259 caller is responsible for rejecting _FloatN suffixes where
260 _FloatN is not supported on the chosen target. */
261 if (f
+ d
+ l
+ w
+ q
+ fn
+ fnx
> 1 || i
> 1)
263 if (fn_bits
> CPP_FLOATN_MAX
)
265 if (fnx
&& fn_bits
!= 32 && fn_bits
!= 64 && fn_bits
!= 128)
267 if (fn
&& fn_bits
!= 16 && fn_bits
% 32 != 0)
269 if (fn
&& fn_bits
== 96)
272 if (i
&& !CPP_OPTION (pfile
, ext_numeric_literals
))
275 if ((w
|| q
) && !CPP_OPTION (pfile
, ext_numeric_literals
))
278 return ((i
? CPP_N_IMAGINARY
: 0)
284 fn
? CPP_N_FLOATN
| (fn_bits
<< CPP_FLOATN_SHIFT
) :
285 fnx
? CPP_N_FLOATNX
| (fn_bits
<< CPP_FLOATN_SHIFT
) :
289 /* Return the classification flags for a float suffix. */
291 cpp_interpret_float_suffix (cpp_reader
*pfile
, const char *s
, size_t len
)
293 return interpret_float_suffix (pfile
, (const unsigned char *)s
, len
);
296 /* Subroutine of cpp_classify_number. S points to an integer suffix
297 of length LEN, possibly zero. Returns 0 for an invalid suffix, or a
298 flag vector describing the suffix. */
300 interpret_int_suffix (cpp_reader
*pfile
, const uchar
*s
, size_t len
)
309 case 'u': case 'U': u
++; break;
311 case 'j': case 'J': i
++; break;
312 case 'l': case 'L': l
++;
313 /* If there are two Ls, they must be adjacent and the same case. */
314 if (l
== 2 && s
[len
] != s
[len
+ 1])
321 if (l
> 2 || u
> 1 || i
> 1)
324 if (i
&& !CPP_OPTION (pfile
, ext_numeric_literals
))
327 return ((i
? CPP_N_IMAGINARY
: 0)
328 | (u
? CPP_N_UNSIGNED
: 0)
329 | ((l
== 0) ? CPP_N_SMALL
330 : (l
== 1) ? CPP_N_MEDIUM
: CPP_N_LARGE
));
333 /* Return the classification flags for an int suffix. */
335 cpp_interpret_int_suffix (cpp_reader
*pfile
, const char *s
, size_t len
)
337 return interpret_int_suffix (pfile
, (const unsigned char *)s
, len
);
340 /* Return the string type corresponding to the the input user-defined string
341 literal type. If the input type is not a user-defined string literal
342 type return the input type. */
344 cpp_userdef_string_remove_type (enum cpp_ttype type
)
346 if (type
== CPP_STRING_USERDEF
)
348 else if (type
== CPP_WSTRING_USERDEF
)
350 else if (type
== CPP_STRING16_USERDEF
)
352 else if (type
== CPP_STRING32_USERDEF
)
354 else if (type
== CPP_UTF8STRING_USERDEF
)
355 return CPP_UTF8STRING
;
360 /* Return the user-defined string literal type corresponding to the input
361 string type. If the input type is not a string type return the input
364 cpp_userdef_string_add_type (enum cpp_ttype type
)
366 if (type
== CPP_STRING
)
367 return CPP_STRING_USERDEF
;
368 else if (type
== CPP_WSTRING
)
369 return CPP_WSTRING_USERDEF
;
370 else if (type
== CPP_STRING16
)
371 return CPP_STRING16_USERDEF
;
372 else if (type
== CPP_STRING32
)
373 return CPP_STRING32_USERDEF
;
374 else if (type
== CPP_UTF8STRING
)
375 return CPP_UTF8STRING_USERDEF
;
380 /* Return the char type corresponding to the the input user-defined char
381 literal type. If the input type is not a user-defined char literal
382 type return the input type. */
384 cpp_userdef_char_remove_type (enum cpp_ttype type
)
386 if (type
== CPP_CHAR_USERDEF
)
388 else if (type
== CPP_WCHAR_USERDEF
)
390 else if (type
== CPP_CHAR16_USERDEF
)
392 else if (type
== CPP_CHAR32_USERDEF
)
394 else if (type
== CPP_UTF8CHAR_USERDEF
)
400 /* Return the user-defined char literal type corresponding to the input
401 char type. If the input type is not a char type return the input
404 cpp_userdef_char_add_type (enum cpp_ttype type
)
406 if (type
== CPP_CHAR
)
407 return CPP_CHAR_USERDEF
;
408 else if (type
== CPP_WCHAR
)
409 return CPP_WCHAR_USERDEF
;
410 else if (type
== CPP_CHAR16
)
411 return CPP_CHAR16_USERDEF
;
412 else if (type
== CPP_CHAR32
)
413 return CPP_CHAR32_USERDEF
;
414 else if (type
== CPP_UTF8CHAR
)
415 return CPP_UTF8CHAR_USERDEF
;
420 /* Return true if the token type is a user-defined string literal. */
422 cpp_userdef_string_p (enum cpp_ttype type
)
424 if (type
== CPP_STRING_USERDEF
425 || type
== CPP_WSTRING_USERDEF
426 || type
== CPP_STRING16_USERDEF
427 || type
== CPP_STRING32_USERDEF
428 || type
== CPP_UTF8STRING_USERDEF
)
434 /* Return true if the token type is a user-defined char literal. */
436 cpp_userdef_char_p (enum cpp_ttype type
)
438 if (type
== CPP_CHAR_USERDEF
439 || type
== CPP_WCHAR_USERDEF
440 || type
== CPP_CHAR16_USERDEF
441 || type
== CPP_CHAR32_USERDEF
442 || type
== CPP_UTF8CHAR_USERDEF
)
448 /* Extract the suffix from a user-defined literal string or char. */
450 cpp_get_userdef_suffix (const cpp_token
*tok
)
452 unsigned int len
= tok
->val
.str
.len
;
453 const char *text
= (const char *)tok
->val
.str
.text
;
456 for (i
= 0; i
< len
; ++i
)
457 if (text
[i
] == '\'' || text
[i
] == '"')
462 for (i
= len
; i
> 0; --i
)
463 if (text
[i
- 1] == delim
)
468 /* Categorize numeric constants according to their field (integer,
469 floating point, or invalid), radix (decimal, octal, hexadecimal),
472 TOKEN is the token that represents the numeric constant to
475 In C++0X if UD_SUFFIX is non null it will be assigned
476 any unrecognized suffix for a user-defined literal.
478 VIRTUAL_LOCATION is the virtual location for TOKEN. */
480 cpp_classify_number (cpp_reader
*pfile
, const cpp_token
*token
,
481 const char **ud_suffix
, source_location virtual_location
)
483 const uchar
*str
= token
->val
.str
.text
;
485 unsigned int max_digit
, result
, radix
;
486 enum {NOT_FLOAT
= 0, AFTER_POINT
, AFTER_EXPON
} float_flag
;
493 /* If the lexer has done its job, length one can only be a single
494 digit. Fast-path this very common case. */
495 if (token
->val
.str
.len
== 1)
496 return CPP_N_INTEGER
| CPP_N_SMALL
| CPP_N_DECIMAL
;
498 limit
= str
+ token
->val
.str
.len
;
499 float_flag
= NOT_FLOAT
;
503 seen_digit_sep
= false;
505 /* First, interpret the radix. */
511 /* Require at least one hex digit to classify it as hex. */
512 if (*str
== 'x' || *str
== 'X')
514 if (str
[1] == '.' || ISXDIGIT (str
[1]))
519 else if (DIGIT_SEP (str
[1]))
520 SYNTAX_ERROR_AT (virtual_location
,
521 "digit separator after base indicator");
523 else if (*str
== 'b' || *str
== 'B')
525 if (str
[1] == '0' || str
[1] == '1')
530 else if (DIGIT_SEP (str
[1]))
531 SYNTAX_ERROR_AT (virtual_location
,
532 "digit separator after base indicator");
536 /* Now scan for a well-formed integer or float. */
539 unsigned int c
= *str
++;
541 if (ISDIGIT (c
) || (ISXDIGIT (c
) && radix
== 16))
543 seen_digit_sep
= false;
549 else if (DIGIT_SEP (c
))
552 SYNTAX_ERROR_AT (virtual_location
, "adjacent digit separators");
553 seen_digit_sep
= true;
557 if (seen_digit_sep
|| DIGIT_SEP (*str
))
558 SYNTAX_ERROR_AT (virtual_location
,
559 "digit separator adjacent to decimal point");
560 seen_digit_sep
= false;
561 if (float_flag
== NOT_FLOAT
)
562 float_flag
= AFTER_POINT
;
564 SYNTAX_ERROR_AT (virtual_location
,
565 "too many decimal points in number");
567 else if ((radix
<= 10 && (c
== 'e' || c
== 'E'))
568 || (radix
== 16 && (c
== 'p' || c
== 'P')))
570 if (seen_digit_sep
|| DIGIT_SEP (*str
))
571 SYNTAX_ERROR_AT (virtual_location
,
572 "digit separator adjacent to exponent");
573 float_flag
= AFTER_EXPON
;
578 /* Start of suffix. */
584 if (seen_digit_sep
&& float_flag
!= AFTER_EXPON
)
585 SYNTAX_ERROR_AT (virtual_location
,
586 "digit separator outside digit sequence");
588 /* The suffix may be for decimal fixed-point constants without exponent. */
589 if (radix
!= 16 && float_flag
== NOT_FLOAT
)
591 result
= interpret_float_suffix (pfile
, str
, limit
- str
);
592 if ((result
& CPP_N_FRACT
) || (result
& CPP_N_ACCUM
))
594 result
|= CPP_N_FLOATING
;
595 /* We need to restore the radix to 10, if the radix is 8. */
599 if (CPP_PEDANTIC (pfile
))
600 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
601 "fixed-point constants are a GCC extension");
608 if (float_flag
!= NOT_FLOAT
&& radix
== 8)
611 if (max_digit
>= radix
)
614 SYNTAX_ERROR2_AT (virtual_location
,
615 "invalid digit \"%c\" in binary constant", '0' + max_digit
);
617 SYNTAX_ERROR2_AT (virtual_location
,
618 "invalid digit \"%c\" in octal constant", '0' + max_digit
);
621 if (float_flag
!= NOT_FLOAT
)
625 cpp_error_with_line (pfile
, CPP_DL_ERROR
, virtual_location
, 0,
626 "invalid prefix \"0b\" for floating constant");
627 return CPP_N_INVALID
;
630 if (radix
== 16 && !seen_digit
)
631 SYNTAX_ERROR_AT (virtual_location
,
632 "no digits in hexadecimal floating constant");
634 if (radix
== 16 && CPP_PEDANTIC (pfile
)
635 && !CPP_OPTION (pfile
, extended_numbers
))
637 if (CPP_OPTION (pfile
, cplusplus
))
638 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
639 "use of C++1z hexadecimal floating constant");
641 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
642 "use of C99 hexadecimal floating constant");
645 if (float_flag
== AFTER_EXPON
)
647 if (*str
== '+' || *str
== '-')
650 /* Exponent is decimal, even if string is a hex float. */
653 if (DIGIT_SEP (*str
))
654 SYNTAX_ERROR_AT (virtual_location
,
655 "digit separator adjacent to exponent");
657 SYNTAX_ERROR_AT (virtual_location
, "exponent has no digits");
661 seen_digit_sep
= DIGIT_SEP (*str
);
664 while (ISDIGIT (*str
) || DIGIT_SEP (*str
));
666 else if (radix
== 16)
667 SYNTAX_ERROR_AT (virtual_location
,
668 "hexadecimal floating constants require an exponent");
671 SYNTAX_ERROR_AT (virtual_location
,
672 "digit separator outside digit sequence");
674 result
= interpret_float_suffix (pfile
, str
, limit
- str
);
677 if (CPP_OPTION (pfile
, user_literals
))
680 *ud_suffix
= (const char *) str
;
681 result
= CPP_N_LARGE
| CPP_N_USERDEF
;
685 cpp_error_with_line (pfile
, CPP_DL_ERROR
, virtual_location
, 0,
686 "invalid suffix \"%.*s\" on floating constant",
687 (int) (limit
- str
), str
);
688 return CPP_N_INVALID
;
692 /* Traditional C didn't accept any floating suffixes. */
694 && CPP_WTRADITIONAL (pfile
)
695 && ! cpp_sys_macro_p (pfile
))
696 cpp_warning_with_line (pfile
, CPP_W_TRADITIONAL
, virtual_location
, 0,
697 "traditional C rejects the \"%.*s\" suffix",
698 (int) (limit
- str
), str
);
700 /* A suffix for double is a GCC extension via decimal float support.
701 If the suffix also specifies an imaginary value we'll catch that
703 if ((result
== CPP_N_MEDIUM
) && CPP_PEDANTIC (pfile
))
704 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
705 "suffix for double constant is a GCC extension");
707 /* Radix must be 10 for decimal floats. */
708 if ((result
& CPP_N_DFLOAT
) && radix
!= 10)
710 cpp_error_with_line (pfile
, CPP_DL_ERROR
, virtual_location
, 0,
711 "invalid suffix \"%.*s\" with hexadecimal floating constant",
712 (int) (limit
- str
), str
);
713 return CPP_N_INVALID
;
716 if ((result
& (CPP_N_FRACT
| CPP_N_ACCUM
)) && CPP_PEDANTIC (pfile
))
717 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
718 "fixed-point constants are a GCC extension");
720 if ((result
& CPP_N_DFLOAT
) && CPP_PEDANTIC (pfile
))
721 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
722 "decimal float constants are a GCC extension");
724 result
|= CPP_N_FLOATING
;
728 result
= interpret_int_suffix (pfile
, str
, limit
- str
);
731 if (CPP_OPTION (pfile
, user_literals
))
734 *ud_suffix
= (const char *) str
;
735 result
= CPP_N_UNSIGNED
| CPP_N_LARGE
| CPP_N_USERDEF
;
739 cpp_error_with_line (pfile
, CPP_DL_ERROR
, virtual_location
, 0,
740 "invalid suffix \"%.*s\" on integer constant",
741 (int) (limit
- str
), str
);
742 return CPP_N_INVALID
;
746 /* Traditional C only accepted the 'L' suffix.
747 Suppress warning about 'LL' with -Wno-long-long. */
748 if (CPP_WTRADITIONAL (pfile
) && ! cpp_sys_macro_p (pfile
))
750 int u_or_i
= (result
& (CPP_N_UNSIGNED
|CPP_N_IMAGINARY
));
751 int large
= (result
& CPP_N_WIDTH
) == CPP_N_LARGE
752 && CPP_OPTION (pfile
, cpp_warn_long_long
);
755 cpp_warning_with_line (pfile
, large
? CPP_W_LONG_LONG
: CPP_W_TRADITIONAL
,
757 "traditional C rejects the \"%.*s\" suffix",
758 (int) (limit
- str
), str
);
761 if ((result
& CPP_N_WIDTH
) == CPP_N_LARGE
762 && CPP_OPTION (pfile
, cpp_warn_long_long
))
764 const char *message
= CPP_OPTION (pfile
, cplusplus
)
765 ? N_("use of C++11 long long integer constant")
766 : N_("use of C99 long long integer constant");
768 if (CPP_OPTION (pfile
, c99
))
769 cpp_warning_with_line (pfile
, CPP_W_LONG_LONG
, virtual_location
,
772 cpp_pedwarning_with_line (pfile
, CPP_W_LONG_LONG
,
773 virtual_location
, 0, message
);
776 result
|= CPP_N_INTEGER
;
780 if ((result
& CPP_N_IMAGINARY
) && CPP_PEDANTIC (pfile
))
781 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
782 "imaginary constants are a GCC extension");
784 && !CPP_OPTION (pfile
, binary_constants
)
785 && CPP_PEDANTIC (pfile
))
786 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, virtual_location
, 0,
787 CPP_OPTION (pfile
, cplusplus
)
788 ? N_("binary constants are a C++14 feature "
790 : N_("binary constants are a GCC extension"));
793 result
|= CPP_N_DECIMAL
;
794 else if (radix
== 16)
797 result
|= CPP_N_BINARY
;
799 result
|= CPP_N_OCTAL
;
804 return CPP_N_INVALID
;
807 /* cpp_interpret_integer converts an integer constant into a cpp_num,
808 of precision options->precision.
810 We do not provide any interface for decimal->float conversion,
811 because the preprocessor doesn't need it and we don't want to
812 drag in GCC's floating point emulator. */
814 cpp_interpret_integer (cpp_reader
*pfile
, const cpp_token
*token
,
817 const uchar
*p
, *end
;
822 result
.unsignedp
= !!(type
& CPP_N_UNSIGNED
);
823 result
.overflow
= false;
825 p
= token
->val
.str
.text
;
826 end
= p
+ token
->val
.str
.len
;
828 /* Common case of a single digit. */
829 if (token
->val
.str
.len
== 1)
830 result
.low
= p
[0] - '0';
834 size_t precision
= CPP_OPTION (pfile
, precision
);
835 unsigned int base
= 10, c
= 0;
836 bool overflow
= false;
838 if ((type
& CPP_N_RADIX
) == CPP_N_OCTAL
)
843 else if ((type
& CPP_N_RADIX
) == CPP_N_HEX
)
848 else if ((type
& CPP_N_RADIX
) == CPP_N_BINARY
)
854 /* We can add a digit to numbers strictly less than this without
855 needing the precision and slowness of double integers. */
856 max
= ~(cpp_num_part
) 0;
857 if (precision
< PART_PRECISION
)
858 max
>>= PART_PRECISION
- precision
;
859 max
= (max
- base
+ 1) / base
+ 1;
865 if (ISDIGIT (c
) || (base
== 16 && ISXDIGIT (c
)))
867 else if (DIGIT_SEP (c
))
872 /* Strict inequality for when max is set to zero. */
873 if (result
.low
< max
)
874 result
.low
= result
.low
* base
+ c
;
877 result
= append_digit (result
, c
, base
, precision
);
878 overflow
|= result
.overflow
;
883 if (overflow
&& !(type
& CPP_N_USERDEF
))
884 cpp_error (pfile
, CPP_DL_PEDWARN
,
885 "integer constant is too large for its type");
886 /* If too big to be signed, consider it unsigned. Only warn for
887 decimal numbers. Traditional numbers were always signed (but
888 we still honor an explicit U suffix); but we only have
889 traditional semantics in directives. */
890 else if (!result
.unsignedp
891 && !(CPP_OPTION (pfile
, traditional
)
892 && pfile
->state
.in_directive
)
893 && !num_positive (result
, precision
))
895 /* This is for constants within the range of uintmax_t but
896 not that of intmax_t. For such decimal constants, a
897 diagnostic is required for C99 as the selected type must
898 be signed and not having a type is a constraint violation
899 (DR#298, TC3), so this must be a pedwarn. For C90,
900 unsigned long is specified to be used for a constant that
901 does not fit in signed long; if uintmax_t has the same
902 range as unsigned long this means only a warning is
903 appropriate here. C90 permits the preprocessor to use a
904 wider range than unsigned long in the compiler, so if
905 uintmax_t is wider than unsigned long no diagnostic is
906 required for such constants in preprocessor #if
907 expressions and the compiler will pedwarn for such
908 constants outside the range of unsigned long that reach
909 the compiler so a diagnostic is not required there
910 either; thus, pedwarn for C99 but use a plain warning for
913 cpp_error (pfile
, (CPP_OPTION (pfile
, c99
)
916 "integer constant is so large that it is unsigned");
917 result
.unsignedp
= true;
924 /* Append DIGIT to NUM, a number of PRECISION bits being read in base BASE. */
926 append_digit (cpp_num num
, int digit
, int base
, size_t precision
)
931 cpp_num_part add_high
, add_low
;
933 /* Multiply by 2, 8 or 16. Catching this overflow here means we don't
934 need to worry about add_high overflowing. */
948 overflow
= !!(num
.high
>> (PART_PRECISION
- shift
));
949 result
.high
= num
.high
<< shift
;
950 result
.low
= num
.low
<< shift
;
951 result
.high
|= num
.low
>> (PART_PRECISION
- shift
);
952 result
.unsignedp
= num
.unsignedp
;
956 add_low
= num
.low
<< 1;
957 add_high
= (num
.high
<< 1) + (num
.low
>> (PART_PRECISION
- 1));
960 add_high
= add_low
= 0;
962 if (add_low
+ digit
< add_low
)
966 if (result
.low
+ add_low
< result
.low
)
968 if (result
.high
+ add_high
< result
.high
)
971 result
.low
+= add_low
;
972 result
.high
+= add_high
;
973 result
.overflow
= overflow
;
975 /* The above code catches overflow of a cpp_num type. This catches
976 overflow of the (possibly shorter) target precision. */
977 num
.low
= result
.low
;
978 num
.high
= result
.high
;
979 result
= num_trim (result
, precision
);
980 if (!num_eq (result
, num
))
981 result
.overflow
= true;
986 /* Handle meeting "defined" in a preprocessor expression. */
988 parse_defined (cpp_reader
*pfile
)
992 cpp_hashnode
*node
= 0;
993 const cpp_token
*token
;
994 cpp_context
*initial_context
= pfile
->context
;
996 /* Don't expand macros. */
997 pfile
->state
.prevent_expansion
++;
999 token
= cpp_get_token (pfile
);
1000 if (token
->type
== CPP_OPEN_PAREN
)
1003 token
= cpp_get_token (pfile
);
1006 if (token
->type
== CPP_NAME
)
1008 node
= token
->val
.node
.node
;
1009 if (paren
&& cpp_get_token (pfile
)->type
!= CPP_CLOSE_PAREN
)
1011 cpp_error (pfile
, CPP_DL_ERROR
, "missing ')' after \"defined\"");
1017 cpp_error (pfile
, CPP_DL_ERROR
,
1018 "operator \"defined\" requires an identifier");
1019 if (token
->flags
& NAMED_OP
)
1024 op
.type
= token
->type
;
1025 cpp_error (pfile
, CPP_DL_ERROR
,
1026 "(\"%s\" is an alternative token for \"%s\" in C++)",
1027 cpp_token_as_text (pfile
, token
),
1028 cpp_token_as_text (pfile
, &op
));
1034 if (pfile
->context
!= initial_context
&& CPP_PEDANTIC (pfile
))
1035 cpp_error (pfile
, CPP_DL_WARNING
,
1036 "this use of \"defined\" may not be portable");
1038 _cpp_mark_macro_used (node
);
1039 if (!(node
->flags
& NODE_USED
))
1041 node
->flags
|= NODE_USED
;
1042 if (node
->type
== NT_MACRO
)
1044 if ((node
->flags
& NODE_BUILTIN
)
1045 && pfile
->cb
.user_builtin_macro
)
1046 pfile
->cb
.user_builtin_macro (pfile
, node
);
1047 if (pfile
->cb
.used_define
)
1048 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
1052 if (pfile
->cb
.used_undef
)
1053 pfile
->cb
.used_undef (pfile
, pfile
->directive_line
, node
);
1057 /* A possible controlling macro of the form #if !defined ().
1058 _cpp_parse_expr checks there was no other junk on the line. */
1059 pfile
->mi_ind_cmacro
= node
;
1062 pfile
->state
.prevent_expansion
--;
1064 /* Do not treat conditional macros as being defined. This is due to the
1065 powerpc and spu ports using conditional macros for 'vector', 'bool', and
1066 'pixel' to act as conditional keywords. This messes up tests like #ifndef
1068 result
.unsignedp
= false;
1070 result
.overflow
= false;
1071 result
.low
= (node
&& node
->type
== NT_MACRO
1072 && (node
->flags
& NODE_CONDITIONAL
) == 0);
1076 /* Convert a token into a CPP_NUMBER (an interpreted preprocessing
1077 number or character constant, or the result of the "defined" or "#"
1080 eval_token (cpp_reader
*pfile
, const cpp_token
*token
,
1081 source_location virtual_location
)
1087 result
.unsignedp
= false;
1088 result
.overflow
= false;
1090 switch (token
->type
)
1093 temp
= cpp_classify_number (pfile
, token
, NULL
, virtual_location
);
1094 if (temp
& CPP_N_USERDEF
)
1095 cpp_error (pfile
, CPP_DL_ERROR
,
1096 "user-defined literal in preprocessor expression");
1097 switch (temp
& CPP_N_CATEGORY
)
1099 case CPP_N_FLOATING
:
1100 cpp_error_with_line (pfile
, CPP_DL_ERROR
, virtual_location
, 0,
1101 "floating constant in preprocessor expression");
1104 if (!(temp
& CPP_N_IMAGINARY
))
1105 return cpp_interpret_integer (pfile
, token
, temp
);
1106 cpp_error_with_line (pfile
, CPP_DL_ERROR
, virtual_location
, 0,
1107 "imaginary number in preprocessor expression");
1111 /* Error already issued. */
1114 result
.high
= result
.low
= 0;
1123 cppchar_t cc
= cpp_interpret_charconst (pfile
, token
,
1128 /* Sign-extend the result if necessary. */
1129 if (!unsignedp
&& (cppchar_signed_t
) cc
< 0)
1131 if (PART_PRECISION
> BITS_PER_CPPCHAR_T
)
1132 result
.low
|= ~(~(cpp_num_part
) 0
1133 >> (PART_PRECISION
- BITS_PER_CPPCHAR_T
));
1134 result
.high
= ~(cpp_num_part
) 0;
1135 result
= num_trim (result
, CPP_OPTION (pfile
, precision
));
1141 if (token
->val
.node
.node
== pfile
->spec_nodes
.n_defined
)
1142 return parse_defined (pfile
);
1143 else if (token
->val
.node
.node
== pfile
->spec_nodes
.n__has_include__
)
1144 return parse_has_include (pfile
, IT_INCLUDE
);
1145 else if (token
->val
.node
.node
== pfile
->spec_nodes
.n__has_include_next__
)
1146 return parse_has_include (pfile
, IT_INCLUDE_NEXT
);
1147 else if (CPP_OPTION (pfile
, cplusplus
)
1148 && (token
->val
.node
.node
== pfile
->spec_nodes
.n_true
1149 || token
->val
.node
.node
== pfile
->spec_nodes
.n_false
))
1152 result
.low
= (token
->val
.node
.node
== pfile
->spec_nodes
.n_true
);
1158 if (CPP_OPTION (pfile
, warn_undef
) && !pfile
->state
.skip_eval
)
1159 cpp_warning_with_line (pfile
, CPP_W_UNDEF
, virtual_location
, 0,
1160 "\"%s\" is not defined, evaluates to 0",
1161 NODE_NAME (token
->val
.node
.node
));
1166 if (!pfile
->state
.skipping
)
1168 /* A pedantic warning takes precedence over a deprecated
1170 if (CPP_PEDANTIC (pfile
))
1171 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
,
1172 virtual_location
, 0,
1173 "assertions are a GCC extension");
1174 else if (CPP_OPTION (pfile
, cpp_warn_deprecated
))
1175 cpp_warning_with_line (pfile
, CPP_W_DEPRECATED
, virtual_location
, 0,
1176 "assertions are a deprecated extension");
1178 _cpp_test_assertion (pfile
, &temp
);
1187 result
.unsignedp
= !!unsignedp
;
1191 /* Operator precedence and flags table.
1193 After an operator is returned from the lexer, if it has priority less
1194 than the operator on the top of the stack, we reduce the stack by one
1195 operator and repeat the test. Since equal priorities do not reduce,
1196 this is naturally right-associative.
1198 We handle left-associative operators by decrementing the priority of
1199 just-lexed operators by one, but retaining the priority of operators
1200 already on the stack.
1202 The remaining cases are '(' and ')'. We handle '(' by skipping the
1203 reduction phase completely. ')' is given lower priority than
1204 everything else, including '(', effectively forcing a reduction of the
1205 parenthesized expression. If there is a matching '(', the routine
1206 reduce() exits immediately. If the normal exit route sees a ')', then
1207 there cannot have been a matching '(' and an error message is output.
1209 The parser assumes all shifted operators require a left operand unless
1210 the flag NO_L_OPERAND is set. These semantics are automatic; any
1211 extra semantics need to be handled with operator-specific code. */
1213 /* Flags. If CHECK_PROMOTION, we warn if the effective sign of an
1214 operand changes because of integer promotions. */
1215 #define NO_L_OPERAND (1 << 0)
1216 #define LEFT_ASSOC (1 << 1)
1217 #define CHECK_PROMOTION (1 << 2)
1219 /* Operator to priority map. Must be in the same order as the first
1220 N entries of enum cpp_ttype. */
1221 static const struct cpp_operator
1227 /* EQ */ {0, 0}, /* Shouldn't happen. */
1228 /* NOT */ {16, NO_L_OPERAND
},
1229 /* GREATER */ {12, LEFT_ASSOC
| CHECK_PROMOTION
},
1230 /* LESS */ {12, LEFT_ASSOC
| CHECK_PROMOTION
},
1231 /* PLUS */ {14, LEFT_ASSOC
| CHECK_PROMOTION
},
1232 /* MINUS */ {14, LEFT_ASSOC
| CHECK_PROMOTION
},
1233 /* MULT */ {15, LEFT_ASSOC
| CHECK_PROMOTION
},
1234 /* DIV */ {15, LEFT_ASSOC
| CHECK_PROMOTION
},
1235 /* MOD */ {15, LEFT_ASSOC
| CHECK_PROMOTION
},
1236 /* AND */ {9, LEFT_ASSOC
| CHECK_PROMOTION
},
1237 /* OR */ {7, LEFT_ASSOC
| CHECK_PROMOTION
},
1238 /* XOR */ {8, LEFT_ASSOC
| CHECK_PROMOTION
},
1239 /* RSHIFT */ {13, LEFT_ASSOC
},
1240 /* LSHIFT */ {13, LEFT_ASSOC
},
1242 /* COMPL */ {16, NO_L_OPERAND
},
1243 /* AND_AND */ {6, LEFT_ASSOC
},
1244 /* OR_OR */ {5, LEFT_ASSOC
},
1245 /* Note that QUERY, COLON, and COMMA must have the same precedence.
1246 However, there are some special cases for these in reduce(). */
1248 /* COLON */ {4, LEFT_ASSOC
| CHECK_PROMOTION
},
1249 /* COMMA */ {4, LEFT_ASSOC
},
1250 /* OPEN_PAREN */ {1, NO_L_OPERAND
},
1251 /* CLOSE_PAREN */ {0, 0},
1253 /* EQ_EQ */ {11, LEFT_ASSOC
},
1254 /* NOT_EQ */ {11, LEFT_ASSOC
},
1255 /* GREATER_EQ */ {12, LEFT_ASSOC
| CHECK_PROMOTION
},
1256 /* LESS_EQ */ {12, LEFT_ASSOC
| CHECK_PROMOTION
},
1257 /* UPLUS */ {16, NO_L_OPERAND
},
1258 /* UMINUS */ {16, NO_L_OPERAND
}
1261 /* Parse and evaluate a C expression, reading from PFILE.
1262 Returns the truth value of the expression.
1264 The implementation is an operator precedence parser, i.e. a
1265 bottom-up parser, using a stack for not-yet-reduced tokens.
1267 The stack base is op_stack, and the current stack pointer is 'top'.
1268 There is a stack element for each operator (only), and the most
1269 recently pushed operator is 'top->op'. An operand (value) is
1270 stored in the 'value' field of the stack element of the operator
1271 that precedes it. */
1273 _cpp_parse_expr (cpp_reader
*pfile
, bool is_if
)
1275 struct op
*top
= pfile
->op_stack
;
1276 unsigned int lex_count
;
1277 bool saw_leading_not
, want_value
= true;
1278 source_location virtual_location
= 0;
1280 pfile
->state
.skip_eval
= 0;
1282 /* Set up detection of #if ! defined(). */
1283 pfile
->mi_ind_cmacro
= 0;
1284 saw_leading_not
= false;
1287 /* Lowest priority operator prevents further reductions. */
1295 op
.token
= cpp_get_token_with_location (pfile
, &virtual_location
);
1296 op
.op
= op
.token
->type
;
1297 op
.loc
= virtual_location
;
1301 /* These tokens convert into values. */
1311 SYNTAX_ERROR2_AT (op
.loc
,
1312 "missing binary operator before token \"%s\"",
1313 cpp_token_as_text (pfile
, op
.token
));
1315 top
->value
= eval_token (pfile
, op
.token
, op
.loc
);
1319 saw_leading_not
= lex_count
== 1;
1331 if ((int) op
.op
<= (int) CPP_EQ
|| (int) op
.op
>= (int) CPP_PLUS_EQ
)
1332 SYNTAX_ERROR2_AT (op
.loc
,
1333 "token \"%s\" is not valid in preprocessor expressions",
1334 cpp_token_as_text (pfile
, op
.token
));
1338 /* Check we have a value or operator as appropriate. */
1339 if (optab
[op
.op
].flags
& NO_L_OPERAND
)
1342 SYNTAX_ERROR2_AT (op
.loc
,
1343 "missing binary operator before token \"%s\"",
1344 cpp_token_as_text (pfile
, op
.token
));
1346 else if (want_value
)
1348 /* We want a number (or expression) and haven't got one.
1349 Try to emit a specific diagnostic. */
1350 if (op
.op
== CPP_CLOSE_PAREN
&& top
->op
== CPP_OPEN_PAREN
)
1351 SYNTAX_ERROR_AT (op
.loc
,
1352 "missing expression between '(' and ')'");
1354 if (op
.op
== CPP_EOF
&& top
->op
== CPP_EOF
)
1355 SYNTAX_ERROR2_AT (op
.loc
,
1356 "%s with no expression", is_if
? "#if" : "#elif");
1358 if (top
->op
!= CPP_EOF
&& top
->op
!= CPP_OPEN_PAREN
)
1359 SYNTAX_ERROR2_AT (op
.loc
,
1360 "operator '%s' has no right operand",
1361 cpp_token_as_text (pfile
, top
->token
));
1362 else if (op
.op
== CPP_CLOSE_PAREN
|| op
.op
== CPP_EOF
)
1363 /* Complain about missing paren during reduction. */;
1365 SYNTAX_ERROR2_AT (op
.loc
,
1366 "operator '%s' has no left operand",
1367 cpp_token_as_text (pfile
, op
.token
));
1370 top
= reduce (pfile
, top
, op
.op
);
1374 if (op
.op
== CPP_EOF
)
1379 case CPP_CLOSE_PAREN
:
1382 if (!num_zerop (top
->value
))
1383 pfile
->state
.skip_eval
++;
1387 if (num_zerop (top
->value
))
1388 pfile
->state
.skip_eval
++;
1391 if (top
->op
!= CPP_QUERY
)
1392 SYNTAX_ERROR_AT (op
.loc
,
1393 " ':' without preceding '?'");
1394 if (!num_zerop (top
[-1].value
)) /* Was '?' condition true? */
1395 pfile
->state
.skip_eval
++;
1397 pfile
->state
.skip_eval
--;
1404 /* Check for and handle stack overflow. */
1405 if (++top
== pfile
->op_limit
)
1406 top
= _cpp_expand_op_stack (pfile
);
1409 top
->token
= op
.token
;
1413 /* The controlling macro expression is only valid if we called lex 3
1414 times: <!> <defined expression> and <EOF>. push_conditional ()
1415 checks that we are at top-of-file. */
1416 if (pfile
->mi_ind_cmacro
&& !(saw_leading_not
&& lex_count
== 3))
1417 pfile
->mi_ind_cmacro
= 0;
1419 if (top
!= pfile
->op_stack
)
1421 cpp_error_with_line (pfile
, CPP_DL_ICE
, top
->loc
, 0,
1422 "unbalanced stack in %s",
1423 is_if
? "#if" : "#elif");
1425 return false; /* Return false on syntax error. */
1428 return !num_zerop (top
->value
);
1431 /* Reduce the operator / value stack if possible, in preparation for
1432 pushing operator OP. Returns NULL on error, otherwise the top of
1435 reduce (cpp_reader
*pfile
, struct op
*top
, enum cpp_ttype op
)
1439 if (top
->op
<= CPP_EQ
|| top
->op
> CPP_LAST_CPP_OP
+ 2)
1442 cpp_error (pfile
, CPP_DL_ICE
, "impossible operator '%u'", top
->op
);
1446 if (op
== CPP_OPEN_PAREN
)
1449 /* Decrement the priority of left-associative operators to force a
1450 reduction with operators of otherwise equal priority. */
1451 prio
= optab
[op
].prio
- ((optab
[op
].flags
& LEFT_ASSOC
) != 0);
1452 while (prio
< optab
[top
->op
].prio
)
1454 if (CPP_OPTION (pfile
, warn_num_sign_change
)
1455 && optab
[top
->op
].flags
& CHECK_PROMOTION
)
1456 check_promotion (pfile
, top
);
1464 top
[-1].value
= num_unary_op (pfile
, top
->value
, top
->op
);
1465 top
[-1].loc
= top
->loc
;
1473 top
[-1].value
= num_binary_op (pfile
, top
[-1].value
,
1474 top
->value
, top
->op
);
1475 top
[-1].loc
= top
->loc
;
1480 case CPP_GREATER_EQ
:
1483 = num_inequality_op (pfile
, top
[-1].value
, top
->value
, top
->op
);
1484 top
[-1].loc
= top
->loc
;
1490 = num_equality_op (pfile
, top
[-1].value
, top
->value
, top
->op
);
1491 top
[-1].loc
= top
->loc
;
1498 = num_bitwise_op (pfile
, top
[-1].value
, top
->value
, top
->op
);
1499 top
[-1].loc
= top
->loc
;
1503 top
[-1].value
= num_mul (pfile
, top
[-1].value
, top
->value
);
1504 top
[-1].loc
= top
->loc
;
1509 top
[-1].value
= num_div_op (pfile
, top
[-1].value
,
1510 top
->value
, top
->op
, top
->loc
);
1511 top
[-1].loc
= top
->loc
;
1516 if (!num_zerop (top
->value
))
1517 pfile
->state
.skip_eval
--;
1518 top
->value
.low
= (!num_zerop (top
->value
)
1519 || !num_zerop (top
[1].value
));
1520 top
->value
.high
= 0;
1521 top
->value
.unsignedp
= false;
1522 top
->value
.overflow
= false;
1523 top
->loc
= top
[1].loc
;
1528 if (num_zerop (top
->value
))
1529 pfile
->state
.skip_eval
--;
1530 top
->value
.low
= (!num_zerop (top
->value
)
1531 && !num_zerop (top
[1].value
));
1532 top
->value
.high
= 0;
1533 top
->value
.unsignedp
= false;
1534 top
->value
.overflow
= false;
1535 top
->loc
= top
[1].loc
;
1538 case CPP_OPEN_PAREN
:
1539 if (op
!= CPP_CLOSE_PAREN
)
1541 cpp_error_with_line (pfile
, CPP_DL_ERROR
,
1542 top
->token
->src_loc
,
1543 0, "missing ')' in expression");
1547 top
->value
= top
[1].value
;
1548 top
->loc
= top
[1].loc
;
1553 if (!num_zerop (top
->value
))
1555 pfile
->state
.skip_eval
--;
1556 top
->value
= top
[1].value
;
1557 top
->loc
= top
[1].loc
;
1561 top
->value
= top
[2].value
;
1562 top
->loc
= top
[2].loc
;
1564 top
->value
.unsignedp
= (top
[1].value
.unsignedp
1565 || top
[2].value
.unsignedp
);
1569 /* COMMA and COLON should not reduce a QUERY operator. */
1570 if (op
== CPP_COMMA
|| op
== CPP_COLON
)
1572 cpp_error (pfile
, CPP_DL_ERROR
, "'?' without following ':'");
1580 if (top
->value
.overflow
&& !pfile
->state
.skip_eval
)
1581 cpp_error (pfile
, CPP_DL_PEDWARN
,
1582 "integer overflow in preprocessor expression");
1585 if (op
== CPP_CLOSE_PAREN
)
1587 cpp_error (pfile
, CPP_DL_ERROR
, "missing '(' in expression");
1594 /* Returns the position of the old top of stack after expansion. */
1596 _cpp_expand_op_stack (cpp_reader
*pfile
)
1598 size_t old_size
= (size_t) (pfile
->op_limit
- pfile
->op_stack
);
1599 size_t new_size
= old_size
* 2 + 20;
1601 pfile
->op_stack
= XRESIZEVEC (struct op
, pfile
->op_stack
, new_size
);
1602 pfile
->op_limit
= pfile
->op_stack
+ new_size
;
1604 return pfile
->op_stack
+ old_size
;
1607 /* Emits a warning if the effective sign of either operand of OP
1608 changes because of integer promotions. */
1610 check_promotion (cpp_reader
*pfile
, const struct op
*op
)
1612 if (op
->value
.unsignedp
== op
[-1].value
.unsignedp
)
1615 if (op
->value
.unsignedp
)
1617 if (!num_positive (op
[-1].value
, CPP_OPTION (pfile
, precision
)))
1618 cpp_error_with_line (pfile
, CPP_DL_WARNING
, op
[-1].loc
, 0,
1619 "the left operand of \"%s\" changes sign when promoted",
1620 cpp_token_as_text (pfile
, op
->token
));
1622 else if (!num_positive (op
->value
, CPP_OPTION (pfile
, precision
)))
1623 cpp_error_with_line (pfile
, CPP_DL_WARNING
, op
->loc
, 0,
1624 "the right operand of \"%s\" changes sign when promoted",
1625 cpp_token_as_text (pfile
, op
->token
));
1628 /* Clears the unused high order bits of the number pointed to by PNUM. */
1630 num_trim (cpp_num num
, size_t precision
)
1632 if (precision
> PART_PRECISION
)
1634 precision
-= PART_PRECISION
;
1635 if (precision
< PART_PRECISION
)
1636 num
.high
&= ((cpp_num_part
) 1 << precision
) - 1;
1640 if (precision
< PART_PRECISION
)
1641 num
.low
&= ((cpp_num_part
) 1 << precision
) - 1;
1648 /* True iff A (presumed signed) >= 0. */
1650 num_positive (cpp_num num
, size_t precision
)
1652 if (precision
> PART_PRECISION
)
1654 precision
-= PART_PRECISION
;
1655 return (num
.high
& (cpp_num_part
) 1 << (precision
- 1)) == 0;
1658 return (num
.low
& (cpp_num_part
) 1 << (precision
- 1)) == 0;
1661 /* Sign extend a number, with PRECISION significant bits and all
1662 others assumed clear, to fill out a cpp_num structure. */
1664 cpp_num_sign_extend (cpp_num num
, size_t precision
)
1668 if (precision
> PART_PRECISION
)
1670 precision
-= PART_PRECISION
;
1671 if (precision
< PART_PRECISION
1672 && (num
.high
& (cpp_num_part
) 1 << (precision
- 1)))
1673 num
.high
|= ~(~(cpp_num_part
) 0 >> (PART_PRECISION
- precision
));
1675 else if (num
.low
& (cpp_num_part
) 1 << (precision
- 1))
1677 if (precision
< PART_PRECISION
)
1678 num
.low
|= ~(~(cpp_num_part
) 0 >> (PART_PRECISION
- precision
));
1679 num
.high
= ~(cpp_num_part
) 0;
1686 /* Returns the negative of NUM. */
1688 num_negate (cpp_num num
, size_t precision
)
1693 num
.high
= ~num
.high
;
1697 num
= num_trim (num
, precision
);
1698 num
.overflow
= (!num
.unsignedp
&& num_eq (num
, copy
) && !num_zerop (num
));
1703 /* Returns true if A >= B. */
1705 num_greater_eq (cpp_num pa
, cpp_num pb
, size_t precision
)
1709 unsignedp
= pa
.unsignedp
|| pb
.unsignedp
;
1713 /* Both numbers have signed type. If they are of different
1714 sign, the answer is the sign of A. */
1715 unsignedp
= num_positive (pa
, precision
);
1717 if (unsignedp
!= num_positive (pb
, precision
))
1720 /* Otherwise we can do an unsigned comparison. */
1723 return (pa
.high
> pb
.high
) || (pa
.high
== pb
.high
&& pa
.low
>= pb
.low
);
1726 /* Returns LHS OP RHS, where OP is a bit-wise operation. */
1728 num_bitwise_op (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1729 cpp_num lhs
, cpp_num rhs
, enum cpp_ttype op
)
1731 lhs
.overflow
= false;
1732 lhs
.unsignedp
= lhs
.unsignedp
|| rhs
.unsignedp
;
1734 /* As excess precision is zeroed, there is no need to num_trim () as
1735 these operations cannot introduce a set bit there. */
1739 lhs
.high
&= rhs
.high
;
1741 else if (op
== CPP_OR
)
1744 lhs
.high
|= rhs
.high
;
1749 lhs
.high
^= rhs
.high
;
1755 /* Returns LHS OP RHS, where OP is an inequality. */
1757 num_inequality_op (cpp_reader
*pfile
, cpp_num lhs
, cpp_num rhs
,
1760 bool gte
= num_greater_eq (lhs
, rhs
, CPP_OPTION (pfile
, precision
));
1762 if (op
== CPP_GREATER_EQ
)
1764 else if (op
== CPP_LESS
)
1766 else if (op
== CPP_GREATER
)
1767 lhs
.low
= gte
&& !num_eq (lhs
, rhs
);
1768 else /* CPP_LESS_EQ. */
1769 lhs
.low
= !gte
|| num_eq (lhs
, rhs
);
1772 lhs
.overflow
= false;
1773 lhs
.unsignedp
= false;
1777 /* Returns LHS OP RHS, where OP is == or !=. */
1779 num_equality_op (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1780 cpp_num lhs
, cpp_num rhs
, enum cpp_ttype op
)
1782 /* Work around a 3.0.4 bug; see PR 6950. */
1783 bool eq
= num_eq (lhs
, rhs
);
1784 if (op
== CPP_NOT_EQ
)
1788 lhs
.overflow
= false;
1789 lhs
.unsignedp
= false;
1793 /* Shift NUM, of width PRECISION, right by N bits. */
1795 num_rshift (cpp_num num
, size_t precision
, size_t n
)
1797 cpp_num_part sign_mask
;
1798 bool x
= num_positive (num
, precision
);
1800 if (num
.unsignedp
|| x
)
1803 sign_mask
= ~(cpp_num_part
) 0;
1806 num
.high
= num
.low
= sign_mask
;
1810 if (precision
< PART_PRECISION
)
1811 num
.high
= sign_mask
, num
.low
|= sign_mask
<< precision
;
1812 else if (precision
< 2 * PART_PRECISION
)
1813 num
.high
|= sign_mask
<< (precision
- PART_PRECISION
);
1815 if (n
>= PART_PRECISION
)
1817 n
-= PART_PRECISION
;
1819 num
.high
= sign_mask
;
1824 num
.low
= (num
.low
>> n
) | (num
.high
<< (PART_PRECISION
- n
));
1825 num
.high
= (num
.high
>> n
) | (sign_mask
<< (PART_PRECISION
- n
));
1829 num
= num_trim (num
, precision
);
1830 num
.overflow
= false;
1834 /* Shift NUM, of width PRECISION, left by N bits. */
1836 num_lshift (cpp_num num
, size_t precision
, size_t n
)
1840 num
.overflow
= !num
.unsignedp
&& !num_zerop (num
);
1841 num
.high
= num
.low
= 0;
1845 cpp_num orig
, maybe_orig
;
1849 if (m
>= PART_PRECISION
)
1851 m
-= PART_PRECISION
;
1857 num
.high
= (num
.high
<< m
) | (num
.low
>> (PART_PRECISION
- m
));
1860 num
= num_trim (num
, precision
);
1863 num
.overflow
= false;
1866 maybe_orig
= num_rshift (num
, precision
, n
);
1867 num
.overflow
= !num_eq (orig
, maybe_orig
);
1874 /* The four unary operators: +, -, ! and ~. */
1876 num_unary_op (cpp_reader
*pfile
, cpp_num num
, enum cpp_ttype op
)
1881 if (CPP_WTRADITIONAL (pfile
) && !pfile
->state
.skip_eval
)
1882 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
1883 "traditional C rejects the unary plus operator");
1884 num
.overflow
= false;
1888 num
= num_negate (num
, CPP_OPTION (pfile
, precision
));
1892 num
.high
= ~num
.high
;
1894 num
= num_trim (num
, CPP_OPTION (pfile
, precision
));
1895 num
.overflow
= false;
1898 default: /* case CPP_NOT: */
1899 num
.low
= num_zerop (num
);
1901 num
.overflow
= false;
1902 num
.unsignedp
= false;
1909 /* The various binary operators. */
1911 num_binary_op (cpp_reader
*pfile
, cpp_num lhs
, cpp_num rhs
, enum cpp_ttype op
)
1914 size_t precision
= CPP_OPTION (pfile
, precision
);
1922 if (!rhs
.unsignedp
&& !num_positive (rhs
, precision
))
1924 /* A negative shift is a positive shift the other way. */
1925 if (op
== CPP_LSHIFT
)
1929 rhs
= num_negate (rhs
, precision
);
1932 n
= ~0; /* Maximal. */
1935 if (op
== CPP_LSHIFT
)
1936 lhs
= num_lshift (lhs
, precision
, n
);
1938 lhs
= num_rshift (lhs
, precision
, n
);
1943 result
.low
= lhs
.low
- rhs
.low
;
1944 result
.high
= lhs
.high
- rhs
.high
;
1945 if (result
.low
> lhs
.low
)
1947 result
.unsignedp
= lhs
.unsignedp
|| rhs
.unsignedp
;
1948 result
.overflow
= false;
1950 result
= num_trim (result
, precision
);
1951 if (!result
.unsignedp
)
1953 bool lhsp
= num_positive (lhs
, precision
);
1954 result
.overflow
= (lhsp
!= num_positive (rhs
, precision
)
1955 && lhsp
!= num_positive (result
, precision
));
1960 result
.low
= lhs
.low
+ rhs
.low
;
1961 result
.high
= lhs
.high
+ rhs
.high
;
1962 if (result
.low
< lhs
.low
)
1964 result
.unsignedp
= lhs
.unsignedp
|| rhs
.unsignedp
;
1965 result
.overflow
= false;
1967 result
= num_trim (result
, precision
);
1968 if (!result
.unsignedp
)
1970 bool lhsp
= num_positive (lhs
, precision
);
1971 result
.overflow
= (lhsp
== num_positive (rhs
, precision
)
1972 && lhsp
!= num_positive (result
, precision
));
1977 default: /* case CPP_COMMA: */
1978 if (CPP_PEDANTIC (pfile
) && (!CPP_OPTION (pfile
, c99
)
1979 || !pfile
->state
.skip_eval
))
1980 cpp_pedwarning (pfile
, CPP_W_PEDANTIC
,
1981 "comma operator in operand of #if");
1989 /* Multiplies two unsigned cpp_num_parts to give a cpp_num. This
1992 num_part_mul (cpp_num_part lhs
, cpp_num_part rhs
)
1995 cpp_num_part middle
[2], temp
;
1997 result
.low
= LOW_PART (lhs
) * LOW_PART (rhs
);
1998 result
.high
= HIGH_PART (lhs
) * HIGH_PART (rhs
);
2000 middle
[0] = LOW_PART (lhs
) * HIGH_PART (rhs
);
2001 middle
[1] = HIGH_PART (lhs
) * LOW_PART (rhs
);
2004 result
.low
+= LOW_PART (middle
[0]) << (PART_PRECISION
/ 2);
2005 if (result
.low
< temp
)
2009 result
.low
+= LOW_PART (middle
[1]) << (PART_PRECISION
/ 2);
2010 if (result
.low
< temp
)
2013 result
.high
+= HIGH_PART (middle
[0]);
2014 result
.high
+= HIGH_PART (middle
[1]);
2015 result
.unsignedp
= true;
2016 result
.overflow
= false;
2021 /* Multiply two preprocessing numbers. */
2023 num_mul (cpp_reader
*pfile
, cpp_num lhs
, cpp_num rhs
)
2025 cpp_num result
, temp
;
2026 bool unsignedp
= lhs
.unsignedp
|| rhs
.unsignedp
;
2027 bool overflow
, negate
= false;
2028 size_t precision
= CPP_OPTION (pfile
, precision
);
2030 /* Prepare for unsigned multiplication. */
2033 if (!num_positive (lhs
, precision
))
2034 negate
= !negate
, lhs
= num_negate (lhs
, precision
);
2035 if (!num_positive (rhs
, precision
))
2036 negate
= !negate
, rhs
= num_negate (rhs
, precision
);
2039 overflow
= lhs
.high
&& rhs
.high
;
2040 result
= num_part_mul (lhs
.low
, rhs
.low
);
2042 temp
= num_part_mul (lhs
.high
, rhs
.low
);
2043 result
.high
+= temp
.low
;
2047 temp
= num_part_mul (lhs
.low
, rhs
.high
);
2048 result
.high
+= temp
.low
;
2052 temp
.low
= result
.low
, temp
.high
= result
.high
;
2053 result
= num_trim (result
, precision
);
2054 if (!num_eq (result
, temp
))
2058 result
= num_negate (result
, precision
);
2061 result
.overflow
= false;
2063 result
.overflow
= overflow
|| (num_positive (result
, precision
) ^ !negate
2064 && !num_zerop (result
));
2065 result
.unsignedp
= unsignedp
;
2070 /* Divide two preprocessing numbers, LHS and RHS, returning the answer
2071 or the remainder depending upon OP. LOCATION is the source location
2072 of this operator (for diagnostics). */
2075 num_div_op (cpp_reader
*pfile
, cpp_num lhs
, cpp_num rhs
, enum cpp_ttype op
,
2076 source_location location
)
2078 cpp_num result
, sub
;
2080 bool unsignedp
= lhs
.unsignedp
|| rhs
.unsignedp
;
2081 bool negate
= false, lhs_neg
= false;
2082 size_t i
, precision
= CPP_OPTION (pfile
, precision
);
2084 /* Prepare for unsigned division. */
2087 if (!num_positive (lhs
, precision
))
2088 negate
= !negate
, lhs_neg
= true, lhs
= num_negate (lhs
, precision
);
2089 if (!num_positive (rhs
, precision
))
2090 negate
= !negate
, rhs
= num_negate (rhs
, precision
);
2093 /* Find the high bit. */
2097 mask
= (cpp_num_part
) 1 << (i
- PART_PRECISION
);
2098 for (; ; i
--, mask
>>= 1)
2099 if (rhs
.high
& mask
)
2104 if (precision
> PART_PRECISION
)
2105 i
= precision
- PART_PRECISION
- 1;
2108 mask
= (cpp_num_part
) 1 << i
;
2109 for (; ; i
--, mask
>>= 1)
2115 if (!pfile
->state
.skip_eval
)
2116 cpp_error_with_line (pfile
, CPP_DL_ERROR
, location
, 0,
2117 "division by zero in #if");
2121 /* First nonzero bit of RHS is bit I. Do naive division by
2122 shifting the RHS fully left, and subtracting from LHS if LHS is
2123 at least as big, and then repeating but with one less shift.
2124 This is not very efficient, but is easy to understand. */
2126 rhs
.unsignedp
= true;
2127 lhs
.unsignedp
= true;
2128 i
= precision
- i
- 1;
2129 sub
= num_lshift (rhs
, precision
, i
);
2131 result
.high
= result
.low
= 0;
2134 if (num_greater_eq (lhs
, sub
, precision
))
2136 lhs
= num_binary_op (pfile
, lhs
, sub
, CPP_MINUS
);
2137 if (i
>= PART_PRECISION
)
2138 result
.high
|= (cpp_num_part
) 1 << (i
- PART_PRECISION
);
2140 result
.low
|= (cpp_num_part
) 1 << i
;
2144 sub
.low
= (sub
.low
>> 1) | (sub
.high
<< (PART_PRECISION
- 1));
2148 /* We divide so that the remainder has the sign of the LHS. */
2151 result
.unsignedp
= unsignedp
;
2152 result
.overflow
= false;
2156 result
= num_negate (result
, precision
);
2157 result
.overflow
= (num_positive (result
, precision
) ^ !negate
2158 && !num_zerop (result
));
2165 lhs
.unsignedp
= unsignedp
;
2166 lhs
.overflow
= false;
2168 lhs
= num_negate (lhs
, precision
);
2173 /* Handle meeting "__has_include__" in a preprocessor expression. */
2175 parse_has_include (cpp_reader
*pfile
, enum include_type type
)
2179 cpp_hashnode
*node
= 0;
2180 const cpp_token
*token
;
2181 bool bracket
= false;
2184 result
.unsignedp
= false;
2186 result
.overflow
= false;
2189 pfile
->state
.in__has_include__
++;
2191 token
= cpp_get_token (pfile
);
2192 if (token
->type
== CPP_OPEN_PAREN
)
2195 token
= cpp_get_token (pfile
);
2198 if (token
->type
== CPP_STRING
|| token
->type
== CPP_HEADER_NAME
)
2200 if (token
->type
== CPP_HEADER_NAME
)
2202 fname
= XNEWVEC (char, token
->val
.str
.len
- 1);
2203 memcpy (fname
, token
->val
.str
.text
+ 1, token
->val
.str
.len
- 2);
2204 fname
[token
->val
.str
.len
- 2] = '\0';
2205 node
= token
->val
.node
.node
;
2207 else if (token
->type
== CPP_LESS
)
2210 fname
= _cpp_bracket_include (pfile
);
2213 cpp_error (pfile
, CPP_DL_ERROR
,
2214 "operator \"__has_include__\" requires a header string");
2218 int angle_brackets
= (bracket
? 1 : 0);
2220 if (_cpp_has_header (pfile
, fname
, angle_brackets
, type
))
2228 if (paren
&& cpp_get_token (pfile
)->type
!= CPP_CLOSE_PAREN
)
2229 cpp_error (pfile
, CPP_DL_ERROR
,
2230 "missing ')' after \"__has_include__\"");
2232 /* A possible controlling macro of the form #if !__has_include__ ().
2233 _cpp_parse_expr checks there was no other junk on the line. */
2235 pfile
->mi_ind_cmacro
= node
;
2237 pfile
->state
.in__has_include__
--;