read-md.c: Move various state to within class rtx_reader
[official-gcc.git] / libcpp / expr.c
blob61bc1b21af1837e0e1e98b0b9b3a079887f4dd0a
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
8 later version.
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/>. */
19 #include "config.h"
20 #include "system.h"
21 #include "cpplib.h"
22 #include "internal.h"
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))
29 struct op
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. */
34 enum cpp_ttype op;
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,
50 enum cpp_ttype);
51 static cpp_num num_equality_op (cpp_reader *, cpp_num, cpp_num,
52 enum cpp_ttype);
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,
55 source_location);
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; } \
79 while(0)
80 #define SYNTAX_ERROR_AT(loc, msgid) \
81 do { cpp_error_with_line (pfile, CPP_DL_ERROR, (loc), 0, msgid); goto syntax_error; } \
82 while(0)
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; } \
85 while(0)
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. */
90 static unsigned int
91 interpret_float_suffix (cpp_reader *pfile, const uchar *s, size_t len)
93 size_t flags;
94 size_t f, d, l, w, q, i, fn, fnx, fn_bits;
96 flags = 0;
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:
102 df, DF - _Decimal32.
103 dd, DD - _Decimal64.
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
116 GNU extension.
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');
141 switch (s[1])
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;
149 default:
150 /* Additional two-character suffixes beginning with D are not
151 for decimal float constants. */
152 break;
156 if (CPP_OPTION (pfile, ext_numeric_literals))
158 /* Recognize a fixed-point suffix. */
159 if (len != 0)
160 switch (s[len-1])
162 case 'k': case 'K': flags = CPP_N_ACCUM; break;
163 case 'r': case 'R': flags = CPP_N_FRACT; break;
164 default: break;
167 /* Continue processing a fixed-point suffix. The suffix is case
168 insensitive except for ll or LL. Order is significant. */
169 if (flags)
171 if (len == 1)
172 return flags;
173 len--;
175 if (*s == 'u' || *s == 'U')
177 flags |= CPP_N_UNSIGNED;
178 if (len == 1)
179 return flags;
180 len--;
181 s++;
184 switch (*s)
186 case 'h': case 'H':
187 if (len == 1)
188 return flags |= CPP_N_SMALL;
189 break;
190 case 'l':
191 if (len == 1)
192 return flags |= CPP_N_MEDIUM;
193 if (len == 2 && s[1] == 'l')
194 return flags |= CPP_N_LARGE;
195 break;
196 case 'L':
197 if (len == 1)
198 return flags |= CPP_N_MEDIUM;
199 if (len == 2 && s[1] == 'L')
200 return flags |= CPP_N_LARGE;
201 break;
202 default:
203 break;
205 /* Anything left at this point is invalid. */
206 return 0;
210 /* In any remaining valid suffix, the case and order don't matter. */
211 while (len--)
213 switch (s[0])
215 case 'f': case 'F':
216 f++;
217 if (len > 0
218 && !CPP_OPTION (pfile, cplusplus)
219 && s[1] >= '1'
220 && s[1] <= '9'
221 && fn_bits == 0)
223 f--;
224 while (len > 0
225 && s[1] >= '0'
226 && s[1] <= '9'
227 && fn_bits < CPP_FLOATN_MAX)
229 fn_bits = fn_bits * 10 + (s[1] - '0');
230 len--;
231 s++;
233 if (len > 0 && s[1] == 'x')
235 fnx++;
236 len--;
237 s++;
239 else
240 fn++;
242 break;
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;
247 case 'i': case 'I':
248 case 'j': case 'J': i++; break;
249 default:
250 return 0;
252 s++;
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)
262 return 0;
263 if (fn_bits > CPP_FLOATN_MAX)
264 return 0;
265 if (fnx && fn_bits != 32 && fn_bits != 64 && fn_bits != 128)
266 return 0;
267 if (fn && fn_bits != 16 && fn_bits % 32 != 0)
268 return 0;
269 if (fn && fn_bits == 96)
270 return 0;
272 if (i && !CPP_OPTION (pfile, ext_numeric_literals))
273 return 0;
275 if ((w || q) && !CPP_OPTION (pfile, ext_numeric_literals))
276 return 0;
278 return ((i ? CPP_N_IMAGINARY : 0)
279 | (f ? CPP_N_SMALL :
280 d ? CPP_N_MEDIUM :
281 l ? CPP_N_LARGE :
282 w ? CPP_N_MD_W :
283 q ? CPP_N_MD_Q :
284 fn ? CPP_N_FLOATN | (fn_bits << CPP_FLOATN_SHIFT) :
285 fnx ? CPP_N_FLOATNX | (fn_bits << CPP_FLOATN_SHIFT) :
286 CPP_N_DEFAULT));
289 /* Return the classification flags for a float suffix. */
290 unsigned int
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. */
299 static unsigned int
300 interpret_int_suffix (cpp_reader *pfile, const uchar *s, size_t len)
302 size_t u, l, i;
304 u = l = i = 0;
306 while (len--)
307 switch (s[len])
309 case 'u': case 'U': u++; break;
310 case 'i': case 'I':
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])
315 return 0;
316 break;
317 default:
318 return 0;
321 if (l > 2 || u > 1 || i > 1)
322 return 0;
324 if (i && !CPP_OPTION (pfile, ext_numeric_literals))
325 return 0;
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. */
334 unsigned int
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. */
343 enum cpp_ttype
344 cpp_userdef_string_remove_type (enum cpp_ttype type)
346 if (type == CPP_STRING_USERDEF)
347 return CPP_STRING;
348 else if (type == CPP_WSTRING_USERDEF)
349 return CPP_WSTRING;
350 else if (type == CPP_STRING16_USERDEF)
351 return CPP_STRING16;
352 else if (type == CPP_STRING32_USERDEF)
353 return CPP_STRING32;
354 else if (type == CPP_UTF8STRING_USERDEF)
355 return CPP_UTF8STRING;
356 else
357 return type;
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
362 type. */
363 enum cpp_ttype
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;
376 else
377 return type;
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. */
383 enum cpp_ttype
384 cpp_userdef_char_remove_type (enum cpp_ttype type)
386 if (type == CPP_CHAR_USERDEF)
387 return CPP_CHAR;
388 else if (type == CPP_WCHAR_USERDEF)
389 return CPP_WCHAR;
390 else if (type == CPP_CHAR16_USERDEF)
391 return CPP_CHAR16;
392 else if (type == CPP_CHAR32_USERDEF)
393 return CPP_CHAR32;
394 else if (type == CPP_UTF8CHAR_USERDEF)
395 return CPP_UTF8CHAR;
396 else
397 return type;
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
402 type. */
403 enum cpp_ttype
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;
416 else
417 return type;
420 /* Return true if the token type is a user-defined string literal. */
421 bool
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)
429 return true;
430 else
431 return false;
434 /* Return true if the token type is a user-defined char literal. */
435 bool
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)
443 return true;
444 else
445 return false;
448 /* Extract the suffix from a user-defined literal string or char. */
449 const 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;
454 char delim;
455 unsigned int i;
456 for (i = 0; i < len; ++i)
457 if (text[i] == '\'' || text[i] == '"')
458 break;
459 if (i == len)
460 return text + len;
461 delim = text[i];
462 for (i = len; i > 0; --i)
463 if (text[i - 1] == delim)
464 break;
465 return text + i;
468 /* Categorize numeric constants according to their field (integer,
469 floating point, or invalid), radix (decimal, octal, hexadecimal),
470 and type suffixes.
472 TOKEN is the token that represents the numeric constant to
473 classify.
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. */
479 unsigned int
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;
484 const uchar *limit;
485 unsigned int max_digit, result, radix;
486 enum {NOT_FLOAT = 0, AFTER_POINT, AFTER_EXPON} float_flag;
487 bool seen_digit;
488 bool seen_digit_sep;
490 if (ud_suffix)
491 *ud_suffix = NULL;
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;
500 max_digit = 0;
501 radix = 10;
502 seen_digit = false;
503 seen_digit_sep = false;
505 /* First, interpret the radix. */
506 if (*str == '0')
508 radix = 8;
509 str++;
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]))
516 radix = 16;
517 str++;
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')
527 radix = 2;
528 str++;
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. */
537 for (;;)
539 unsigned int c = *str++;
541 if (ISDIGIT (c) || (ISXDIGIT (c) && radix == 16))
543 seen_digit_sep = false;
544 seen_digit = true;
545 c = hex_value (c);
546 if (c > max_digit)
547 max_digit = c;
549 else if (DIGIT_SEP (c))
551 if (seen_digit_sep)
552 SYNTAX_ERROR_AT (virtual_location, "adjacent digit separators");
553 seen_digit_sep = true;
555 else if (c == '.')
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;
563 else
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;
574 break;
576 else
578 /* Start of suffix. */
579 str--;
580 break;
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. */
596 if (radix == 8)
597 radix = 10;
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");
602 goto syntax_ok;
604 else
605 result = 0;
608 if (float_flag != NOT_FLOAT && radix == 8)
609 radix = 10;
611 if (max_digit >= radix)
613 if (radix == 2)
614 SYNTAX_ERROR2_AT (virtual_location,
615 "invalid digit \"%c\" in binary constant", '0' + max_digit);
616 else
617 SYNTAX_ERROR2_AT (virtual_location,
618 "invalid digit \"%c\" in octal constant", '0' + max_digit);
621 if (float_flag != NOT_FLOAT)
623 if (radix == 2)
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");
640 else
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 == '-')
648 str++;
650 /* Exponent is decimal, even if string is a hex float. */
651 if (!ISDIGIT (*str))
653 if (DIGIT_SEP (*str))
654 SYNTAX_ERROR_AT (virtual_location,
655 "digit separator adjacent to exponent");
656 else
657 SYNTAX_ERROR_AT (virtual_location, "exponent has no digits");
661 seen_digit_sep = DIGIT_SEP (*str);
662 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");
670 if (seen_digit_sep)
671 SYNTAX_ERROR_AT (virtual_location,
672 "digit separator outside digit sequence");
674 result = interpret_float_suffix (pfile, str, limit - str);
675 if (result == 0)
677 if (CPP_OPTION (pfile, user_literals))
679 if (ud_suffix)
680 *ud_suffix = (const char *) str;
681 result = CPP_N_LARGE | CPP_N_USERDEF;
683 else
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. */
693 if (limit != str
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
702 later. */
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;
726 else
728 result = interpret_int_suffix (pfile, str, limit - str);
729 if (result == 0)
731 if (CPP_OPTION (pfile, user_literals))
733 if (ud_suffix)
734 *ud_suffix = (const char *) str;
735 result = CPP_N_UNSIGNED | CPP_N_LARGE | CPP_N_USERDEF;
737 else
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);
754 if (u_or_i || large)
755 cpp_warning_with_line (pfile, large ? CPP_W_LONG_LONG : CPP_W_TRADITIONAL,
756 virtual_location, 0,
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,
770 0, message);
771 else
772 cpp_pedwarning_with_line (pfile, CPP_W_LONG_LONG,
773 virtual_location, 0, message);
776 result |= CPP_N_INTEGER;
779 syntax_ok:
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");
783 if (radix == 2
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 "
789 "or GCC extension")
790 : N_("binary constants are a GCC extension"));
792 if (radix == 10)
793 result |= CPP_N_DECIMAL;
794 else if (radix == 16)
795 result |= CPP_N_HEX;
796 else if (radix == 2)
797 result |= CPP_N_BINARY;
798 else
799 result |= CPP_N_OCTAL;
801 return result;
803 syntax_error:
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. */
813 cpp_num
814 cpp_interpret_integer (cpp_reader *pfile, const cpp_token *token,
815 unsigned int type)
817 const uchar *p, *end;
818 cpp_num result;
820 result.low = 0;
821 result.high = 0;
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';
831 else
833 cpp_num_part max;
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)
840 base = 8;
841 p++;
843 else if ((type & CPP_N_RADIX) == CPP_N_HEX)
845 base = 16;
846 p += 2;
848 else if ((type & CPP_N_RADIX) == CPP_N_BINARY)
850 base = 2;
851 p += 2;
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;
861 for (; p < end; p++)
863 c = *p;
865 if (ISDIGIT (c) || (base == 16 && ISXDIGIT (c)))
866 c = hex_value (c);
867 else if (DIGIT_SEP (c))
868 continue;
869 else
870 break;
872 /* Strict inequality for when max is set to zero. */
873 if (result.low < max)
874 result.low = result.low * base + c;
875 else
877 result = append_digit (result, c, base, precision);
878 overflow |= result.overflow;
879 max = 0;
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
911 C90. */
912 if (base == 10)
913 cpp_error (pfile, (CPP_OPTION (pfile, c99)
914 ? CPP_DL_PEDWARN
915 : CPP_DL_WARNING),
916 "integer constant is so large that it is unsigned");
917 result.unsignedp = true;
921 return result;
924 /* Append DIGIT to NUM, a number of PRECISION bits being read in base BASE. */
925 static cpp_num
926 append_digit (cpp_num num, int digit, int base, size_t precision)
928 cpp_num result;
929 unsigned int shift;
930 bool overflow;
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. */
935 switch (base)
937 case 2:
938 shift = 1;
939 break;
941 case 16:
942 shift = 4;
943 break;
945 default:
946 shift = 3;
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;
954 if (base == 10)
956 add_low = num.low << 1;
957 add_high = (num.high << 1) + (num.low >> (PART_PRECISION - 1));
959 else
960 add_high = add_low = 0;
962 if (add_low + digit < add_low)
963 add_high++;
964 add_low += digit;
966 if (result.low + add_low < result.low)
967 add_high++;
968 if (result.high + add_high < result.high)
969 overflow = true;
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;
983 return result;
986 /* Handle meeting "defined" in a preprocessor expression. */
987 static cpp_num
988 parse_defined (cpp_reader *pfile)
990 cpp_num result;
991 int paren = 0;
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)
1002 paren = 1;
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\"");
1012 node = 0;
1015 else
1017 cpp_error (pfile, CPP_DL_ERROR,
1018 "operator \"defined\" requires an identifier");
1019 if (token->flags & NAMED_OP)
1021 cpp_token op;
1023 op.flags = 0;
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));
1032 if (node)
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);
1050 else
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
1067 bool. */
1068 result.unsignedp = false;
1069 result.high = 0;
1070 result.overflow = false;
1071 result.low = (node && node->type == NT_MACRO
1072 && (node->flags & NODE_CONDITIONAL) == 0);
1073 return result;
1076 /* Convert a token into a CPP_NUMBER (an interpreted preprocessing
1077 number or character constant, or the result of the "defined" or "#"
1078 operators). */
1079 static cpp_num
1080 eval_token (cpp_reader *pfile, const cpp_token *token,
1081 source_location virtual_location)
1083 cpp_num result;
1084 unsigned int temp;
1085 int unsignedp = 0;
1087 result.unsignedp = false;
1088 result.overflow = false;
1090 switch (token->type)
1092 case CPP_NUMBER:
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");
1102 break;
1103 case CPP_N_INTEGER:
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");
1108 break;
1110 case CPP_N_INVALID:
1111 /* Error already issued. */
1112 break;
1114 result.high = result.low = 0;
1115 break;
1117 case CPP_WCHAR:
1118 case CPP_CHAR:
1119 case CPP_CHAR16:
1120 case CPP_CHAR32:
1121 case CPP_UTF8CHAR:
1123 cppchar_t cc = cpp_interpret_charconst (pfile, token,
1124 &temp, &unsignedp);
1126 result.high = 0;
1127 result.low = cc;
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));
1138 break;
1140 case CPP_NAME:
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))
1151 result.high = 0;
1152 result.low = (token->val.node.node == pfile->spec_nodes.n_true);
1154 else
1156 result.high = 0;
1157 result.low = 0;
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));
1163 break;
1165 case CPP_HASH:
1166 if (!pfile->state.skipping)
1168 /* A pedantic warning takes precedence over a deprecated
1169 warning here. */
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);
1179 result.high = 0;
1180 result.low = temp;
1181 break;
1183 default:
1184 abort ();
1187 result.unsignedp = !!unsignedp;
1188 return result;
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
1223 uchar prio;
1224 uchar flags;
1225 } optab[] =
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(). */
1247 /* QUERY */ {4, 0},
1248 /* COLON */ {4, LEFT_ASSOC | CHECK_PROMOTION},
1249 /* COMMA */ {4, LEFT_ASSOC},
1250 /* OPEN_PAREN */ {1, NO_L_OPERAND},
1251 /* CLOSE_PAREN */ {0, 0},
1252 /* EOF */ {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. */
1272 bool
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;
1285 lex_count = 0;
1287 /* Lowest priority operator prevents further reductions. */
1288 top->op = CPP_EOF;
1290 for (;;)
1292 struct op op;
1294 lex_count++;
1295 op.token = cpp_get_token_with_location (pfile, &virtual_location);
1296 op.op = op.token->type;
1297 op.loc = virtual_location;
1299 switch (op.op)
1301 /* These tokens convert into values. */
1302 case CPP_NUMBER:
1303 case CPP_CHAR:
1304 case CPP_WCHAR:
1305 case CPP_CHAR16:
1306 case CPP_CHAR32:
1307 case CPP_UTF8CHAR:
1308 case CPP_NAME:
1309 case CPP_HASH:
1310 if (!want_value)
1311 SYNTAX_ERROR2_AT (op.loc,
1312 "missing binary operator before token \"%s\"",
1313 cpp_token_as_text (pfile, op.token));
1314 want_value = false;
1315 top->value = eval_token (pfile, op.token, op.loc);
1316 continue;
1318 case CPP_NOT:
1319 saw_leading_not = lex_count == 1;
1320 break;
1321 case CPP_PLUS:
1322 if (want_value)
1323 op.op = CPP_UPLUS;
1324 break;
1325 case CPP_MINUS:
1326 if (want_value)
1327 op.op = CPP_UMINUS;
1328 break;
1330 default:
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));
1335 break;
1338 /* Check we have a value or operator as appropriate. */
1339 if (optab[op.op].flags & NO_L_OPERAND)
1341 if (!want_value)
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. */;
1364 else
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);
1371 if (!top)
1372 goto syntax_error;
1374 if (op.op == CPP_EOF)
1375 break;
1377 switch (op.op)
1379 case CPP_CLOSE_PAREN:
1380 continue;
1381 case CPP_OR_OR:
1382 if (!num_zerop (top->value))
1383 pfile->state.skip_eval++;
1384 break;
1385 case CPP_AND_AND:
1386 case CPP_QUERY:
1387 if (num_zerop (top->value))
1388 pfile->state.skip_eval++;
1389 break;
1390 case CPP_COLON:
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++;
1396 else
1397 pfile->state.skip_eval--;
1398 default:
1399 break;
1402 want_value = true;
1404 /* Check for and handle stack overflow. */
1405 if (++top == pfile->op_limit)
1406 top = _cpp_expand_op_stack (pfile);
1408 top->op = op.op;
1409 top->token = op.token;
1410 top->loc = op.loc;
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");
1424 syntax_error:
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
1433 the stack. */
1434 static struct op *
1435 reduce (cpp_reader *pfile, struct op *top, enum cpp_ttype op)
1437 unsigned int prio;
1439 if (top->op <= CPP_EQ || top->op > CPP_LAST_CPP_OP + 2)
1441 bad_op:
1442 cpp_error (pfile, CPP_DL_ICE, "impossible operator '%u'", top->op);
1443 return 0;
1446 if (op == CPP_OPEN_PAREN)
1447 return top;
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);
1458 switch (top->op)
1460 case CPP_UPLUS:
1461 case CPP_UMINUS:
1462 case CPP_NOT:
1463 case CPP_COMPL:
1464 top[-1].value = num_unary_op (pfile, top->value, top->op);
1465 top[-1].loc = top->loc;
1466 break;
1468 case CPP_PLUS:
1469 case CPP_MINUS:
1470 case CPP_RSHIFT:
1471 case CPP_LSHIFT:
1472 case CPP_COMMA:
1473 top[-1].value = num_binary_op (pfile, top[-1].value,
1474 top->value, top->op);
1475 top[-1].loc = top->loc;
1476 break;
1478 case CPP_GREATER:
1479 case CPP_LESS:
1480 case CPP_GREATER_EQ:
1481 case CPP_LESS_EQ:
1482 top[-1].value
1483 = num_inequality_op (pfile, top[-1].value, top->value, top->op);
1484 top[-1].loc = top->loc;
1485 break;
1487 case CPP_EQ_EQ:
1488 case CPP_NOT_EQ:
1489 top[-1].value
1490 = num_equality_op (pfile, top[-1].value, top->value, top->op);
1491 top[-1].loc = top->loc;
1492 break;
1494 case CPP_AND:
1495 case CPP_OR:
1496 case CPP_XOR:
1497 top[-1].value
1498 = num_bitwise_op (pfile, top[-1].value, top->value, top->op);
1499 top[-1].loc = top->loc;
1500 break;
1502 case CPP_MULT:
1503 top[-1].value = num_mul (pfile, top[-1].value, top->value);
1504 top[-1].loc = top->loc;
1505 break;
1507 case CPP_DIV:
1508 case CPP_MOD:
1509 top[-1].value = num_div_op (pfile, top[-1].value,
1510 top->value, top->op, top->loc);
1511 top[-1].loc = top->loc;
1512 break;
1514 case CPP_OR_OR:
1515 top--;
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;
1524 continue;
1526 case CPP_AND_AND:
1527 top--;
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;
1536 continue;
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");
1544 return 0;
1546 top--;
1547 top->value = top[1].value;
1548 top->loc = top[1].loc;
1549 return top;
1551 case CPP_COLON:
1552 top -= 2;
1553 if (!num_zerop (top->value))
1555 pfile->state.skip_eval--;
1556 top->value = top[1].value;
1557 top->loc = top[1].loc;
1559 else
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);
1566 continue;
1568 case CPP_QUERY:
1569 /* COMMA and COLON should not reduce a QUERY operator. */
1570 if (op == CPP_COMMA || op == CPP_COLON)
1571 return top;
1572 cpp_error (pfile, CPP_DL_ERROR, "'?' without following ':'");
1573 return 0;
1575 default:
1576 goto bad_op;
1579 top--;
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");
1588 return 0;
1591 return top;
1594 /* Returns the position of the old top of stack after expansion. */
1595 struct op *
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. */
1609 static void
1610 check_promotion (cpp_reader *pfile, const struct op *op)
1612 if (op->value.unsignedp == op[-1].value.unsignedp)
1613 return;
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. */
1629 static cpp_num
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;
1638 else
1640 if (precision < PART_PRECISION)
1641 num.low &= ((cpp_num_part) 1 << precision) - 1;
1642 num.high = 0;
1645 return num;
1648 /* True iff A (presumed signed) >= 0. */
1649 static bool
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. */
1663 cpp_num
1664 cpp_num_sign_extend (cpp_num num, size_t precision)
1666 if (!num.unsignedp)
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;
1683 return num;
1686 /* Returns the negative of NUM. */
1687 static cpp_num
1688 num_negate (cpp_num num, size_t precision)
1690 cpp_num copy;
1692 copy = num;
1693 num.high = ~num.high;
1694 num.low = ~num.low;
1695 if (++num.low == 0)
1696 num.high++;
1697 num = num_trim (num, precision);
1698 num.overflow = (!num.unsignedp && num_eq (num, copy) && !num_zerop (num));
1700 return num;
1703 /* Returns true if A >= B. */
1704 static bool
1705 num_greater_eq (cpp_num pa, cpp_num pb, size_t precision)
1707 bool unsignedp;
1709 unsignedp = pa.unsignedp || pb.unsignedp;
1711 if (!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))
1718 return unsignedp;
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. */
1727 static cpp_num
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. */
1736 if (op == CPP_AND)
1738 lhs.low &= rhs.low;
1739 lhs.high &= rhs.high;
1741 else if (op == CPP_OR)
1743 lhs.low |= rhs.low;
1744 lhs.high |= rhs.high;
1746 else
1748 lhs.low ^= rhs.low;
1749 lhs.high ^= rhs.high;
1752 return lhs;
1755 /* Returns LHS OP RHS, where OP is an inequality. */
1756 static cpp_num
1757 num_inequality_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs,
1758 enum cpp_ttype op)
1760 bool gte = num_greater_eq (lhs, rhs, CPP_OPTION (pfile, precision));
1762 if (op == CPP_GREATER_EQ)
1763 lhs.low = gte;
1764 else if (op == CPP_LESS)
1765 lhs.low = !gte;
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);
1771 lhs.high = 0;
1772 lhs.overflow = false;
1773 lhs.unsignedp = false;
1774 return lhs;
1777 /* Returns LHS OP RHS, where OP is == or !=. */
1778 static cpp_num
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)
1785 eq = !eq;
1786 lhs.low = eq;
1787 lhs.high = 0;
1788 lhs.overflow = false;
1789 lhs.unsignedp = false;
1790 return lhs;
1793 /* Shift NUM, of width PRECISION, right by N bits. */
1794 static cpp_num
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)
1801 sign_mask = 0;
1802 else
1803 sign_mask = ~(cpp_num_part) 0;
1805 if (n >= precision)
1806 num.high = num.low = sign_mask;
1807 else
1809 /* Sign-extend. */
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;
1818 num.low = num.high;
1819 num.high = sign_mask;
1822 if (n)
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;
1831 return num;
1834 /* Shift NUM, of width PRECISION, left by N bits. */
1835 static cpp_num
1836 num_lshift (cpp_num num, size_t precision, size_t n)
1838 if (n >= precision)
1840 num.overflow = !num.unsignedp && !num_zerop (num);
1841 num.high = num.low = 0;
1843 else
1845 cpp_num orig, maybe_orig;
1846 size_t m = n;
1848 orig = num;
1849 if (m >= PART_PRECISION)
1851 m -= PART_PRECISION;
1852 num.high = num.low;
1853 num.low = 0;
1855 if (m)
1857 num.high = (num.high << m) | (num.low >> (PART_PRECISION - m));
1858 num.low <<= m;
1860 num = num_trim (num, precision);
1862 if (num.unsignedp)
1863 num.overflow = false;
1864 else
1866 maybe_orig = num_rshift (num, precision, n);
1867 num.overflow = !num_eq (orig, maybe_orig);
1871 return num;
1874 /* The four unary operators: +, -, ! and ~. */
1875 static cpp_num
1876 num_unary_op (cpp_reader *pfile, cpp_num num, enum cpp_ttype op)
1878 switch (op)
1880 case CPP_UPLUS:
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;
1885 break;
1887 case CPP_UMINUS:
1888 num = num_negate (num, CPP_OPTION (pfile, precision));
1889 break;
1891 case CPP_COMPL:
1892 num.high = ~num.high;
1893 num.low = ~num.low;
1894 num = num_trim (num, CPP_OPTION (pfile, precision));
1895 num.overflow = false;
1896 break;
1898 default: /* case CPP_NOT: */
1899 num.low = num_zerop (num);
1900 num.high = 0;
1901 num.overflow = false;
1902 num.unsignedp = false;
1903 break;
1906 return num;
1909 /* The various binary operators. */
1910 static cpp_num
1911 num_binary_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1913 cpp_num result;
1914 size_t precision = CPP_OPTION (pfile, precision);
1915 size_t n;
1917 switch (op)
1919 /* Shifts. */
1920 case CPP_LSHIFT:
1921 case CPP_RSHIFT:
1922 if (!rhs.unsignedp && !num_positive (rhs, precision))
1924 /* A negative shift is a positive shift the other way. */
1925 if (op == CPP_LSHIFT)
1926 op = CPP_RSHIFT;
1927 else
1928 op = CPP_LSHIFT;
1929 rhs = num_negate (rhs, precision);
1931 if (rhs.high)
1932 n = ~0; /* Maximal. */
1933 else
1934 n = rhs.low;
1935 if (op == CPP_LSHIFT)
1936 lhs = num_lshift (lhs, precision, n);
1937 else
1938 lhs = num_rshift (lhs, precision, n);
1939 break;
1941 /* Arithmetic. */
1942 case CPP_MINUS:
1943 result.low = lhs.low - rhs.low;
1944 result.high = lhs.high - rhs.high;
1945 if (result.low > lhs.low)
1946 result.high--;
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));
1957 return result;
1959 case CPP_PLUS:
1960 result.low = lhs.low + rhs.low;
1961 result.high = lhs.high + rhs.high;
1962 if (result.low < lhs.low)
1963 result.high++;
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));
1974 return result;
1976 /* Comma. */
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");
1982 lhs = rhs;
1983 break;
1986 return lhs;
1989 /* Multiplies two unsigned cpp_num_parts to give a cpp_num. This
1990 cannot overflow. */
1991 static cpp_num
1992 num_part_mul (cpp_num_part lhs, cpp_num_part rhs)
1994 cpp_num result;
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);
2003 temp = result.low;
2004 result.low += LOW_PART (middle[0]) << (PART_PRECISION / 2);
2005 if (result.low < temp)
2006 result.high++;
2008 temp = result.low;
2009 result.low += LOW_PART (middle[1]) << (PART_PRECISION / 2);
2010 if (result.low < temp)
2011 result.high++;
2013 result.high += HIGH_PART (middle[0]);
2014 result.high += HIGH_PART (middle[1]);
2015 result.unsignedp = true;
2016 result.overflow = false;
2018 return result;
2021 /* Multiply two preprocessing numbers. */
2022 static cpp_num
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. */
2031 if (!unsignedp)
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;
2044 if (temp.high)
2045 overflow = true;
2047 temp = num_part_mul (lhs.low, rhs.high);
2048 result.high += temp.low;
2049 if (temp.high)
2050 overflow = true;
2052 temp.low = result.low, temp.high = result.high;
2053 result = num_trim (result, precision);
2054 if (!num_eq (result, temp))
2055 overflow = true;
2057 if (negate)
2058 result = num_negate (result, precision);
2060 if (unsignedp)
2061 result.overflow = false;
2062 else
2063 result.overflow = overflow || (num_positive (result, precision) ^ !negate
2064 && !num_zerop (result));
2065 result.unsignedp = unsignedp;
2067 return result;
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). */
2074 static cpp_num
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;
2079 cpp_num_part mask;
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. */
2085 if (!unsignedp)
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. */
2094 if (rhs.high)
2096 i = precision - 1;
2097 mask = (cpp_num_part) 1 << (i - PART_PRECISION);
2098 for (; ; i--, mask >>= 1)
2099 if (rhs.high & mask)
2100 break;
2102 else if (rhs.low)
2104 if (precision > PART_PRECISION)
2105 i = precision - PART_PRECISION - 1;
2106 else
2107 i = precision - 1;
2108 mask = (cpp_num_part) 1 << i;
2109 for (; ; i--, mask >>= 1)
2110 if (rhs.low & mask)
2111 break;
2113 else
2115 if (!pfile->state.skip_eval)
2116 cpp_error_with_line (pfile, CPP_DL_ERROR, location, 0,
2117 "division by zero in #if");
2118 return lhs;
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;
2132 for (;;)
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);
2139 else
2140 result.low |= (cpp_num_part) 1 << i;
2142 if (i-- == 0)
2143 break;
2144 sub.low = (sub.low >> 1) | (sub.high << (PART_PRECISION - 1));
2145 sub.high >>= 1;
2148 /* We divide so that the remainder has the sign of the LHS. */
2149 if (op == CPP_DIV)
2151 result.unsignedp = unsignedp;
2152 result.overflow = false;
2153 if (!unsignedp)
2155 if (negate)
2156 result = num_negate (result, precision);
2157 result.overflow = (num_positive (result, precision) ^ !negate
2158 && !num_zerop (result));
2161 return result;
2164 /* CPP_MOD. */
2165 lhs.unsignedp = unsignedp;
2166 lhs.overflow = false;
2167 if (lhs_neg)
2168 lhs = num_negate (lhs, precision);
2170 return lhs;
2173 /* Handle meeting "__has_include__" in a preprocessor expression. */
2174 static cpp_num
2175 parse_has_include (cpp_reader *pfile, enum include_type type)
2177 cpp_num result;
2178 bool paren = false;
2179 cpp_hashnode *node = 0;
2180 const cpp_token *token;
2181 bool bracket = false;
2182 char *fname = 0;
2184 result.unsignedp = false;
2185 result.high = 0;
2186 result.overflow = false;
2187 result.low = 0;
2189 pfile->state.in__has_include__++;
2191 token = cpp_get_token (pfile);
2192 if (token->type == CPP_OPEN_PAREN)
2194 paren = true;
2195 token = cpp_get_token (pfile);
2198 if (token->type == CPP_STRING || token->type == CPP_HEADER_NAME)
2200 if (token->type == CPP_HEADER_NAME)
2201 bracket = true;
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)
2209 bracket = true;
2210 fname = _cpp_bracket_include (pfile);
2212 else
2213 cpp_error (pfile, CPP_DL_ERROR,
2214 "operator \"__has_include__\" requires a header string");
2216 if (fname)
2218 int angle_brackets = (bracket ? 1 : 0);
2220 if (_cpp_has_header (pfile, fname, angle_brackets, type))
2221 result.low = 1;
2222 else
2223 result.low = 0;
2225 XDELETEVEC (fname);
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. */
2234 if (node)
2235 pfile->mi_ind_cmacro = node;
2237 pfile->state.in__has_include__--;
2239 return result;