Daily bump.
[official-gcc.git] / libcpp / expr.c
blob147bd97c5ece83cd0f1ce6b6afbed89007fd112b
1 /* Parse C expressions for cpplib.
2 Copyright (C) 1987-2014 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 /* Token type abuse to create unary plus and minus operators. */
68 #define CPP_UPLUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 1))
69 #define CPP_UMINUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 2))
71 /* With -O2, gcc appears to produce nice code, moving the error
72 message load and subsequent jump completely out of the main path. */
73 #define SYNTAX_ERROR(msgid) \
74 do { cpp_error (pfile, CPP_DL_ERROR, msgid); goto syntax_error; } while(0)
75 #define SYNTAX_ERROR2(msgid, arg) \
76 do { cpp_error (pfile, CPP_DL_ERROR, msgid, arg); goto syntax_error; } \
77 while(0)
78 #define SYNTAX_ERROR_AT(loc, msgid) \
79 do { cpp_error_with_line (pfile, CPP_DL_ERROR, (loc), 0, msgid); goto syntax_error; } \
80 while(0)
81 #define SYNTAX_ERROR2_AT(loc, msgid, arg) \
82 do { cpp_error_with_line (pfile, CPP_DL_ERROR, (loc), 0, msgid, arg); goto syntax_error; } \
83 while(0)
85 /* Subroutine of cpp_classify_number. S points to a float suffix of
86 length LEN, possibly zero. Returns 0 for an invalid suffix, or a
87 flag vector describing the suffix. */
88 static unsigned int
89 interpret_float_suffix (cpp_reader *pfile, const uchar *s, size_t len)
91 size_t flags;
92 size_t f, d, l, w, q, i;
94 flags = 0;
95 f = d = l = w = q = i = 0;
97 /* Process decimal float suffixes, which are two letters starting
98 with d or D. Order and case are significant. */
99 if (len == 2 && (*s == 'd' || *s == 'D'))
101 bool uppercase = (*s == 'D');
102 switch (s[1])
104 case 'f': return (!uppercase ? (CPP_N_DFLOAT | CPP_N_SMALL): 0); break;
105 case 'F': return (uppercase ? (CPP_N_DFLOAT | CPP_N_SMALL) : 0); break;
106 case 'd': return (!uppercase ? (CPP_N_DFLOAT | CPP_N_MEDIUM): 0); break;
107 case 'D': return (uppercase ? (CPP_N_DFLOAT | CPP_N_MEDIUM) : 0); break;
108 case 'l': return (!uppercase ? (CPP_N_DFLOAT | CPP_N_LARGE) : 0); break;
109 case 'L': return (uppercase ? (CPP_N_DFLOAT | CPP_N_LARGE) : 0); break;
110 default:
111 /* Additional two-character suffixes beginning with D are not
112 for decimal float constants. */
113 break;
117 if (CPP_OPTION (pfile, ext_numeric_literals))
119 /* Recognize a fixed-point suffix. */
120 if (len != 0)
121 switch (s[len-1])
123 case 'k': case 'K': flags = CPP_N_ACCUM; break;
124 case 'r': case 'R': flags = CPP_N_FRACT; break;
125 default: break;
128 /* Continue processing a fixed-point suffix. The suffix is case
129 insensitive except for ll or LL. Order is significant. */
130 if (flags)
132 if (len == 1)
133 return flags;
134 len--;
136 if (*s == 'u' || *s == 'U')
138 flags |= CPP_N_UNSIGNED;
139 if (len == 1)
140 return flags;
141 len--;
142 s++;
145 switch (*s)
147 case 'h': case 'H':
148 if (len == 1)
149 return flags |= CPP_N_SMALL;
150 break;
151 case 'l':
152 if (len == 1)
153 return flags |= CPP_N_MEDIUM;
154 if (len == 2 && s[1] == 'l')
155 return flags |= CPP_N_LARGE;
156 break;
157 case 'L':
158 if (len == 1)
159 return flags |= CPP_N_MEDIUM;
160 if (len == 2 && s[1] == 'L')
161 return flags |= CPP_N_LARGE;
162 break;
163 default:
164 break;
166 /* Anything left at this point is invalid. */
167 return 0;
171 /* In any remaining valid suffix, the case and order don't matter. */
172 while (len--)
173 switch (s[len])
175 case 'f': case 'F': f++; break;
176 case 'd': case 'D': d++; break;
177 case 'l': case 'L': l++; break;
178 case 'w': case 'W': w++; break;
179 case 'q': case 'Q': q++; break;
180 case 'i': case 'I':
181 case 'j': case 'J': i++; break;
182 default:
183 return 0;
186 if (f + d + l + w + q > 1 || i > 1)
187 return 0;
189 if (i && !CPP_OPTION (pfile, ext_numeric_literals))
190 return 0;
192 if ((w || q) && !CPP_OPTION (pfile, ext_numeric_literals))
193 return 0;
195 return ((i ? CPP_N_IMAGINARY : 0)
196 | (f ? CPP_N_SMALL :
197 d ? CPP_N_MEDIUM :
198 l ? CPP_N_LARGE :
199 w ? CPP_N_MD_W :
200 q ? CPP_N_MD_Q : CPP_N_DEFAULT));
203 /* Return the classification flags for a float suffix. */
204 unsigned int
205 cpp_interpret_float_suffix (cpp_reader *pfile, const char *s, size_t len)
207 return interpret_float_suffix (pfile, (const unsigned char *)s, len);
210 /* Subroutine of cpp_classify_number. S points to an integer suffix
211 of length LEN, possibly zero. Returns 0 for an invalid suffix, or a
212 flag vector describing the suffix. */
213 static unsigned int
214 interpret_int_suffix (cpp_reader *pfile, const uchar *s, size_t len)
216 size_t u, l, i;
218 u = l = i = 0;
220 while (len--)
221 switch (s[len])
223 case 'u': case 'U': u++; break;
224 case 'i': case 'I':
225 case 'j': case 'J': i++; break;
226 case 'l': case 'L': l++;
227 /* If there are two Ls, they must be adjacent and the same case. */
228 if (l == 2 && s[len] != s[len + 1])
229 return 0;
230 break;
231 default:
232 return 0;
235 if (l > 2 || u > 1 || i > 1)
236 return 0;
238 if (i && !CPP_OPTION (pfile, ext_numeric_literals))
239 return 0;
241 return ((i ? CPP_N_IMAGINARY : 0)
242 | (u ? CPP_N_UNSIGNED : 0)
243 | ((l == 0) ? CPP_N_SMALL
244 : (l == 1) ? CPP_N_MEDIUM : CPP_N_LARGE));
247 /* Return the classification flags for an int suffix. */
248 unsigned int
249 cpp_interpret_int_suffix (cpp_reader *pfile, const char *s, size_t len)
251 return interpret_int_suffix (pfile, (const unsigned char *)s, len);
254 /* Return the string type corresponding to the the input user-defined string
255 literal type. If the input type is not a user-defined string literal
256 type return the input type. */
257 enum cpp_ttype
258 cpp_userdef_string_remove_type (enum cpp_ttype type)
260 if (type == CPP_STRING_USERDEF)
261 return CPP_STRING;
262 else if (type == CPP_WSTRING_USERDEF)
263 return CPP_WSTRING;
264 else if (type == CPP_STRING16_USERDEF)
265 return CPP_STRING16;
266 else if (type == CPP_STRING32_USERDEF)
267 return CPP_STRING32;
268 else if (type == CPP_UTF8STRING_USERDEF)
269 return CPP_UTF8STRING;
270 else
271 return type;
274 /* Return the user-defined string literal type corresponding to the input
275 string type. If the input type is not a string type return the input
276 type. */
277 enum cpp_ttype
278 cpp_userdef_string_add_type (enum cpp_ttype type)
280 if (type == CPP_STRING)
281 return CPP_STRING_USERDEF;
282 else if (type == CPP_WSTRING)
283 return CPP_WSTRING_USERDEF;
284 else if (type == CPP_STRING16)
285 return CPP_STRING16_USERDEF;
286 else if (type == CPP_STRING32)
287 return CPP_STRING32_USERDEF;
288 else if (type == CPP_UTF8STRING)
289 return CPP_UTF8STRING_USERDEF;
290 else
291 return type;
294 /* Return the char type corresponding to the the input user-defined char
295 literal type. If the input type is not a user-defined char literal
296 type return the input type. */
297 enum cpp_ttype
298 cpp_userdef_char_remove_type (enum cpp_ttype type)
300 if (type == CPP_CHAR_USERDEF)
301 return CPP_CHAR;
302 else if (type == CPP_WCHAR_USERDEF)
303 return CPP_WCHAR;
304 else if (type == CPP_CHAR16_USERDEF)
305 return CPP_CHAR16;
306 else if (type == CPP_CHAR32_USERDEF)
307 return CPP_CHAR32;
308 else
309 return type;
312 /* Return the user-defined char literal type corresponding to the input
313 char type. If the input type is not a char type return the input
314 type. */
315 enum cpp_ttype
316 cpp_userdef_char_add_type (enum cpp_ttype type)
318 if (type == CPP_CHAR)
319 return CPP_CHAR_USERDEF;
320 else if (type == CPP_WCHAR)
321 return CPP_WCHAR_USERDEF;
322 else if (type == CPP_CHAR16)
323 return CPP_CHAR16_USERDEF;
324 else if (type == CPP_CHAR32)
325 return CPP_CHAR32_USERDEF;
326 else
327 return type;
330 /* Return true if the token type is a user-defined string literal. */
331 bool
332 cpp_userdef_string_p (enum cpp_ttype type)
334 if (type == CPP_STRING_USERDEF
335 || type == CPP_WSTRING_USERDEF
336 || type == CPP_STRING16_USERDEF
337 || type == CPP_STRING32_USERDEF
338 || type == CPP_UTF8STRING_USERDEF)
339 return true;
340 else
341 return false;
344 /* Return true if the token type is a user-defined char literal. */
345 bool
346 cpp_userdef_char_p (enum cpp_ttype type)
348 if (type == CPP_CHAR_USERDEF
349 || type == CPP_WCHAR_USERDEF
350 || type == CPP_CHAR16_USERDEF
351 || type == CPP_CHAR32_USERDEF)
352 return true;
353 else
354 return false;
357 /* Extract the suffix from a user-defined literal string or char. */
358 const char *
359 cpp_get_userdef_suffix (const cpp_token *tok)
361 unsigned int len = tok->val.str.len;
362 const char *text = (const char *)tok->val.str.text;
363 char delim;
364 unsigned int i;
365 for (i = 0; i < len; ++i)
366 if (text[i] == '\'' || text[i] == '"')
367 break;
368 if (i == len)
369 return text + len;
370 delim = text[i];
371 for (i = len; i > 0; --i)
372 if (text[i - 1] == delim)
373 break;
374 return text + i;
377 /* Categorize numeric constants according to their field (integer,
378 floating point, or invalid), radix (decimal, octal, hexadecimal),
379 and type suffixes.
381 TOKEN is the token that represents the numeric constant to
382 classify.
384 In C++0X if UD_SUFFIX is non null it will be assigned
385 any unrecognized suffix for a user-defined literal.
387 VIRTUAL_LOCATION is the virtual location for TOKEN. */
388 unsigned int
389 cpp_classify_number (cpp_reader *pfile, const cpp_token *token,
390 const char **ud_suffix, source_location virtual_location)
392 const uchar *str = token->val.str.text;
393 const uchar *limit;
394 unsigned int max_digit, result, radix;
395 enum {NOT_FLOAT = 0, AFTER_POINT, AFTER_EXPON} float_flag;
396 bool seen_digit;
397 bool seen_digit_sep;
399 if (ud_suffix)
400 *ud_suffix = NULL;
402 /* If the lexer has done its job, length one can only be a single
403 digit. Fast-path this very common case. */
404 if (token->val.str.len == 1)
405 return CPP_N_INTEGER | CPP_N_SMALL | CPP_N_DECIMAL;
407 limit = str + token->val.str.len;
408 float_flag = NOT_FLOAT;
409 max_digit = 0;
410 radix = 10;
411 seen_digit = false;
412 seen_digit_sep = false;
414 /* First, interpret the radix. */
415 if (*str == '0')
417 radix = 8;
418 str++;
420 /* Require at least one hex digit to classify it as hex. */
421 if (*str == 'x' || *str == 'X')
423 if (str[1] == '.' || ISXDIGIT (str[1]))
425 radix = 16;
426 str++;
428 else if (DIGIT_SEP (str[1]))
429 SYNTAX_ERROR_AT (virtual_location,
430 "digit separator after base indicator");
432 else if (*str == 'b' || *str == 'B')
434 if (str[1] == '0' || str[1] == '1')
436 radix = 2;
437 str++;
439 else if (DIGIT_SEP (str[1]))
440 SYNTAX_ERROR_AT (virtual_location,
441 "digit separator after base indicator");
445 /* Now scan for a well-formed integer or float. */
446 for (;;)
448 unsigned int c = *str++;
450 if (ISDIGIT (c) || (ISXDIGIT (c) && radix == 16))
452 seen_digit_sep = false;
453 seen_digit = true;
454 c = hex_value (c);
455 if (c > max_digit)
456 max_digit = c;
458 else if (DIGIT_SEP (c))
460 if (seen_digit_sep)
461 SYNTAX_ERROR_AT (virtual_location, "adjacent digit separators");
462 seen_digit_sep = true;
464 else if (c == '.')
466 if (seen_digit_sep || DIGIT_SEP (*str))
467 SYNTAX_ERROR_AT (virtual_location,
468 "digit separator adjacent to decimal point");
469 seen_digit_sep = false;
470 if (float_flag == NOT_FLOAT)
471 float_flag = AFTER_POINT;
472 else
473 SYNTAX_ERROR_AT (virtual_location,
474 "too many decimal points in number");
476 else if ((radix <= 10 && (c == 'e' || c == 'E'))
477 || (radix == 16 && (c == 'p' || c == 'P')))
479 if (seen_digit_sep || DIGIT_SEP (*str))
480 SYNTAX_ERROR_AT (virtual_location,
481 "digit separator adjacent to exponent");
482 float_flag = AFTER_EXPON;
483 break;
485 else
487 /* Start of suffix. */
488 str--;
489 break;
493 if (seen_digit_sep && float_flag != AFTER_EXPON)
494 SYNTAX_ERROR_AT (virtual_location,
495 "digit separator outside digit sequence");
497 /* The suffix may be for decimal fixed-point constants without exponent. */
498 if (radix != 16 && float_flag == NOT_FLOAT)
500 result = interpret_float_suffix (pfile, str, limit - str);
501 if ((result & CPP_N_FRACT) || (result & CPP_N_ACCUM))
503 result |= CPP_N_FLOATING;
504 /* We need to restore the radix to 10, if the radix is 8. */
505 if (radix == 8)
506 radix = 10;
508 if (CPP_PEDANTIC (pfile))
509 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
510 "fixed-point constants are a GCC extension");
511 goto syntax_ok;
513 else
514 result = 0;
517 if (float_flag != NOT_FLOAT && radix == 8)
518 radix = 10;
520 if (max_digit >= radix)
522 if (radix == 2)
523 SYNTAX_ERROR2_AT (virtual_location,
524 "invalid digit \"%c\" in binary constant", '0' + max_digit);
525 else
526 SYNTAX_ERROR2_AT (virtual_location,
527 "invalid digit \"%c\" in octal constant", '0' + max_digit);
530 if (float_flag != NOT_FLOAT)
532 if (radix == 2)
534 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
535 "invalid prefix \"0b\" for floating constant");
536 return CPP_N_INVALID;
539 if (radix == 16 && !seen_digit)
540 SYNTAX_ERROR_AT (virtual_location,
541 "no digits in hexadecimal floating constant");
543 if (radix == 16 && CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, c99))
544 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
545 "use of C99 hexadecimal floating constant");
547 if (float_flag == AFTER_EXPON)
549 if (*str == '+' || *str == '-')
550 str++;
552 /* Exponent is decimal, even if string is a hex float. */
553 if (!ISDIGIT (*str))
555 if (DIGIT_SEP (*str))
556 SYNTAX_ERROR_AT (virtual_location,
557 "digit separator adjacent to exponent");
558 else
559 SYNTAX_ERROR_AT (virtual_location, "exponent has no digits");
563 seen_digit_sep = DIGIT_SEP (*str);
564 str++;
566 while (ISDIGIT (*str) || DIGIT_SEP (*str));
568 else if (radix == 16)
569 SYNTAX_ERROR_AT (virtual_location,
570 "hexadecimal floating constants require an exponent");
572 if (seen_digit_sep)
573 SYNTAX_ERROR_AT (virtual_location,
574 "digit separator outside digit sequence");
576 result = interpret_float_suffix (pfile, str, limit - str);
577 if (result == 0)
579 if (CPP_OPTION (pfile, user_literals))
581 if (ud_suffix)
582 *ud_suffix = (const char *) str;
583 result = CPP_N_LARGE | CPP_N_USERDEF;
585 else
587 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
588 "invalid suffix \"%.*s\" on floating constant",
589 (int) (limit - str), str);
590 return CPP_N_INVALID;
594 /* Traditional C didn't accept any floating suffixes. */
595 if (limit != str
596 && CPP_WTRADITIONAL (pfile)
597 && ! cpp_sys_macro_p (pfile))
598 cpp_warning_with_line (pfile, CPP_W_TRADITIONAL, virtual_location, 0,
599 "traditional C rejects the \"%.*s\" suffix",
600 (int) (limit - str), str);
602 /* A suffix for double is a GCC extension via decimal float support.
603 If the suffix also specifies an imaginary value we'll catch that
604 later. */
605 if ((result == CPP_N_MEDIUM) && CPP_PEDANTIC (pfile))
606 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
607 "suffix for double constant is a GCC extension");
609 /* Radix must be 10 for decimal floats. */
610 if ((result & CPP_N_DFLOAT) && radix != 10)
612 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
613 "invalid suffix \"%.*s\" with hexadecimal floating constant",
614 (int) (limit - str), str);
615 return CPP_N_INVALID;
618 if ((result & (CPP_N_FRACT | CPP_N_ACCUM)) && CPP_PEDANTIC (pfile))
619 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
620 "fixed-point constants are a GCC extension");
622 if ((result & CPP_N_DFLOAT) && CPP_PEDANTIC (pfile))
623 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
624 "decimal float constants are a GCC extension");
626 result |= CPP_N_FLOATING;
628 else
630 result = interpret_int_suffix (pfile, str, limit - str);
631 if (result == 0)
633 if (CPP_OPTION (pfile, user_literals))
635 if (ud_suffix)
636 *ud_suffix = (const char *) str;
637 result = CPP_N_UNSIGNED | CPP_N_LARGE | CPP_N_USERDEF;
639 else
641 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
642 "invalid suffix \"%.*s\" on integer constant",
643 (int) (limit - str), str);
644 return CPP_N_INVALID;
648 /* Traditional C only accepted the 'L' suffix.
649 Suppress warning about 'LL' with -Wno-long-long. */
650 if (CPP_WTRADITIONAL (pfile) && ! cpp_sys_macro_p (pfile))
652 int u_or_i = (result & (CPP_N_UNSIGNED|CPP_N_IMAGINARY));
653 int large = (result & CPP_N_WIDTH) == CPP_N_LARGE
654 && CPP_OPTION (pfile, cpp_warn_long_long);
656 if (u_or_i || large)
657 cpp_warning_with_line (pfile, large ? CPP_W_LONG_LONG : CPP_W_TRADITIONAL,
658 virtual_location, 0,
659 "traditional C rejects the \"%.*s\" suffix",
660 (int) (limit - str), str);
663 if ((result & CPP_N_WIDTH) == CPP_N_LARGE
664 && CPP_OPTION (pfile, cpp_warn_long_long))
666 const char *message = CPP_OPTION (pfile, cplusplus)
667 ? N_("use of C++11 long long integer constant")
668 : N_("use of C99 long long integer constant");
670 if (CPP_OPTION (pfile, c99))
671 cpp_warning_with_line (pfile, CPP_W_LONG_LONG, virtual_location,
672 0, message);
673 else
674 cpp_pedwarning_with_line (pfile, CPP_W_LONG_LONG,
675 virtual_location, 0, message);
678 result |= CPP_N_INTEGER;
681 syntax_ok:
682 if ((result & CPP_N_IMAGINARY) && CPP_PEDANTIC (pfile))
683 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
684 "imaginary constants are a GCC extension");
685 if (radix == 2
686 && !CPP_OPTION (pfile, binary_constants)
687 && CPP_PEDANTIC (pfile))
688 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
689 CPP_OPTION (pfile, cplusplus)
690 ? "binary constants are a C++1y feature "
691 "or GCC extension"
692 : "binary constants are a GCC extension");
694 if (radix == 10)
695 result |= CPP_N_DECIMAL;
696 else if (radix == 16)
697 result |= CPP_N_HEX;
698 else if (radix == 2)
699 result |= CPP_N_BINARY;
700 else
701 result |= CPP_N_OCTAL;
703 return result;
705 syntax_error:
706 return CPP_N_INVALID;
709 /* cpp_interpret_integer converts an integer constant into a cpp_num,
710 of precision options->precision.
712 We do not provide any interface for decimal->float conversion,
713 because the preprocessor doesn't need it and we don't want to
714 drag in GCC's floating point emulator. */
715 cpp_num
716 cpp_interpret_integer (cpp_reader *pfile, const cpp_token *token,
717 unsigned int type)
719 const uchar *p, *end;
720 cpp_num result;
722 result.low = 0;
723 result.high = 0;
724 result.unsignedp = !!(type & CPP_N_UNSIGNED);
725 result.overflow = false;
727 p = token->val.str.text;
728 end = p + token->val.str.len;
730 /* Common case of a single digit. */
731 if (token->val.str.len == 1)
732 result.low = p[0] - '0';
733 else
735 cpp_num_part max;
736 size_t precision = CPP_OPTION (pfile, precision);
737 unsigned int base = 10, c = 0;
738 bool overflow = false;
740 if ((type & CPP_N_RADIX) == CPP_N_OCTAL)
742 base = 8;
743 p++;
745 else if ((type & CPP_N_RADIX) == CPP_N_HEX)
747 base = 16;
748 p += 2;
750 else if ((type & CPP_N_RADIX) == CPP_N_BINARY)
752 base = 2;
753 p += 2;
756 /* We can add a digit to numbers strictly less than this without
757 needing the precision and slowness of double integers. */
758 max = ~(cpp_num_part) 0;
759 if (precision < PART_PRECISION)
760 max >>= PART_PRECISION - precision;
761 max = (max - base + 1) / base + 1;
763 for (; p < end; p++)
765 c = *p;
767 if (ISDIGIT (c) || (base == 16 && ISXDIGIT (c)))
768 c = hex_value (c);
769 else if (DIGIT_SEP (c))
770 continue;
771 else
772 break;
774 /* Strict inequality for when max is set to zero. */
775 if (result.low < max)
776 result.low = result.low * base + c;
777 else
779 result = append_digit (result, c, base, precision);
780 overflow |= result.overflow;
781 max = 0;
785 if (overflow && !(type & CPP_N_USERDEF))
786 cpp_error (pfile, CPP_DL_PEDWARN,
787 "integer constant is too large for its type");
788 /* If too big to be signed, consider it unsigned. Only warn for
789 decimal numbers. Traditional numbers were always signed (but
790 we still honor an explicit U suffix); but we only have
791 traditional semantics in directives. */
792 else if (!result.unsignedp
793 && !(CPP_OPTION (pfile, traditional)
794 && pfile->state.in_directive)
795 && !num_positive (result, precision))
797 /* This is for constants within the range of uintmax_t but
798 not that of intmax_t. For such decimal constants, a
799 diagnostic is required for C99 as the selected type must
800 be signed and not having a type is a constraint violation
801 (DR#298, TC3), so this must be a pedwarn. For C90,
802 unsigned long is specified to be used for a constant that
803 does not fit in signed long; if uintmax_t has the same
804 range as unsigned long this means only a warning is
805 appropriate here. C90 permits the preprocessor to use a
806 wider range than unsigned long in the compiler, so if
807 uintmax_t is wider than unsigned long no diagnostic is
808 required for such constants in preprocessor #if
809 expressions and the compiler will pedwarn for such
810 constants outside the range of unsigned long that reach
811 the compiler so a diagnostic is not required there
812 either; thus, pedwarn for C99 but use a plain warning for
813 C90. */
814 if (base == 10)
815 cpp_error (pfile, (CPP_OPTION (pfile, c99)
816 ? CPP_DL_PEDWARN
817 : CPP_DL_WARNING),
818 "integer constant is so large that it is unsigned");
819 result.unsignedp = true;
823 return result;
826 /* Append DIGIT to NUM, a number of PRECISION bits being read in base BASE. */
827 static cpp_num
828 append_digit (cpp_num num, int digit, int base, size_t precision)
830 cpp_num result;
831 unsigned int shift;
832 bool overflow;
833 cpp_num_part add_high, add_low;
835 /* Multiply by 2, 8 or 16. Catching this overflow here means we don't
836 need to worry about add_high overflowing. */
837 switch (base)
839 case 2:
840 shift = 1;
841 break;
843 case 16:
844 shift = 4;
845 break;
847 default:
848 shift = 3;
850 overflow = !!(num.high >> (PART_PRECISION - shift));
851 result.high = num.high << shift;
852 result.low = num.low << shift;
853 result.high |= num.low >> (PART_PRECISION - shift);
854 result.unsignedp = num.unsignedp;
856 if (base == 10)
858 add_low = num.low << 1;
859 add_high = (num.high << 1) + (num.low >> (PART_PRECISION - 1));
861 else
862 add_high = add_low = 0;
864 if (add_low + digit < add_low)
865 add_high++;
866 add_low += digit;
868 if (result.low + add_low < result.low)
869 add_high++;
870 if (result.high + add_high < result.high)
871 overflow = true;
873 result.low += add_low;
874 result.high += add_high;
875 result.overflow = overflow;
877 /* The above code catches overflow of a cpp_num type. This catches
878 overflow of the (possibly shorter) target precision. */
879 num.low = result.low;
880 num.high = result.high;
881 result = num_trim (result, precision);
882 if (!num_eq (result, num))
883 result.overflow = true;
885 return result;
888 /* Handle meeting "defined" in a preprocessor expression. */
889 static cpp_num
890 parse_defined (cpp_reader *pfile)
892 cpp_num result;
893 int paren = 0;
894 cpp_hashnode *node = 0;
895 const cpp_token *token;
896 cpp_context *initial_context = pfile->context;
898 /* Don't expand macros. */
899 pfile->state.prevent_expansion++;
901 token = cpp_get_token (pfile);
902 if (token->type == CPP_OPEN_PAREN)
904 paren = 1;
905 token = cpp_get_token (pfile);
908 if (token->type == CPP_NAME)
910 node = token->val.node.node;
911 if (paren && cpp_get_token (pfile)->type != CPP_CLOSE_PAREN)
913 cpp_error (pfile, CPP_DL_ERROR, "missing ')' after \"defined\"");
914 node = 0;
917 else
919 cpp_error (pfile, CPP_DL_ERROR,
920 "operator \"defined\" requires an identifier");
921 if (token->flags & NAMED_OP)
923 cpp_token op;
925 op.flags = 0;
926 op.type = token->type;
927 cpp_error (pfile, CPP_DL_ERROR,
928 "(\"%s\" is an alternative token for \"%s\" in C++)",
929 cpp_token_as_text (pfile, token),
930 cpp_token_as_text (pfile, &op));
934 if (node)
936 if (pfile->context != initial_context && CPP_PEDANTIC (pfile))
937 cpp_error (pfile, CPP_DL_WARNING,
938 "this use of \"defined\" may not be portable");
940 _cpp_mark_macro_used (node);
941 if (!(node->flags & NODE_USED))
943 node->flags |= NODE_USED;
944 if (node->type == NT_MACRO)
946 if ((node->flags & NODE_BUILTIN)
947 && pfile->cb.user_builtin_macro)
948 pfile->cb.user_builtin_macro (pfile, node);
949 if (pfile->cb.used_define)
950 pfile->cb.used_define (pfile, pfile->directive_line, node);
952 else
954 if (pfile->cb.used_undef)
955 pfile->cb.used_undef (pfile, pfile->directive_line, node);
959 /* A possible controlling macro of the form #if !defined ().
960 _cpp_parse_expr checks there was no other junk on the line. */
961 pfile->mi_ind_cmacro = node;
964 pfile->state.prevent_expansion--;
966 /* Do not treat conditional macros as being defined. This is due to the
967 powerpc and spu ports using conditional macros for 'vector', 'bool', and
968 'pixel' to act as conditional keywords. This messes up tests like #ifndef
969 bool. */
970 result.unsignedp = false;
971 result.high = 0;
972 result.overflow = false;
973 result.low = (node && node->type == NT_MACRO
974 && (node->flags & NODE_CONDITIONAL) == 0);
975 return result;
978 /* Convert a token into a CPP_NUMBER (an interpreted preprocessing
979 number or character constant, or the result of the "defined" or "#"
980 operators). */
981 static cpp_num
982 eval_token (cpp_reader *pfile, const cpp_token *token,
983 source_location virtual_location)
985 cpp_num result;
986 unsigned int temp;
987 int unsignedp = 0;
989 result.unsignedp = false;
990 result.overflow = false;
992 switch (token->type)
994 case CPP_NUMBER:
995 temp = cpp_classify_number (pfile, token, NULL, virtual_location);
996 if (temp & CPP_N_USERDEF)
997 cpp_error (pfile, CPP_DL_ERROR,
998 "user-defined literal in preprocessor expression");
999 switch (temp & CPP_N_CATEGORY)
1001 case CPP_N_FLOATING:
1002 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
1003 "floating constant in preprocessor expression");
1004 break;
1005 case CPP_N_INTEGER:
1006 if (!(temp & CPP_N_IMAGINARY))
1007 return cpp_interpret_integer (pfile, token, temp);
1008 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
1009 "imaginary number in preprocessor expression");
1010 break;
1012 case CPP_N_INVALID:
1013 /* Error already issued. */
1014 break;
1016 result.high = result.low = 0;
1017 break;
1019 case CPP_WCHAR:
1020 case CPP_CHAR:
1021 case CPP_CHAR16:
1022 case CPP_CHAR32:
1024 cppchar_t cc = cpp_interpret_charconst (pfile, token,
1025 &temp, &unsignedp);
1027 result.high = 0;
1028 result.low = cc;
1029 /* Sign-extend the result if necessary. */
1030 if (!unsignedp && (cppchar_signed_t) cc < 0)
1032 if (PART_PRECISION > BITS_PER_CPPCHAR_T)
1033 result.low |= ~(~(cpp_num_part) 0
1034 >> (PART_PRECISION - BITS_PER_CPPCHAR_T));
1035 result.high = ~(cpp_num_part) 0;
1036 result = num_trim (result, CPP_OPTION (pfile, precision));
1039 break;
1041 case CPP_NAME:
1042 if (token->val.node.node == pfile->spec_nodes.n_defined)
1043 return parse_defined (pfile);
1044 else if (CPP_OPTION (pfile, cplusplus)
1045 && (token->val.node.node == pfile->spec_nodes.n_true
1046 || token->val.node.node == pfile->spec_nodes.n_false))
1048 result.high = 0;
1049 result.low = (token->val.node.node == pfile->spec_nodes.n_true);
1051 else
1053 result.high = 0;
1054 result.low = 0;
1055 if (CPP_OPTION (pfile, warn_undef) && !pfile->state.skip_eval)
1056 cpp_warning_with_line (pfile, CPP_W_UNDEF, virtual_location, 0,
1057 "\"%s\" is not defined",
1058 NODE_NAME (token->val.node.node));
1060 break;
1062 case CPP_HASH:
1063 if (!pfile->state.skipping)
1065 /* A pedantic warning takes precedence over a deprecated
1066 warning here. */
1067 if (CPP_PEDANTIC (pfile))
1068 cpp_error_with_line (pfile, CPP_DL_PEDWARN,
1069 virtual_location, 0,
1070 "assertions are a GCC extension");
1071 else if (CPP_OPTION (pfile, cpp_warn_deprecated))
1072 cpp_warning_with_line (pfile, CPP_W_DEPRECATED, virtual_location, 0,
1073 "assertions are a deprecated extension");
1075 _cpp_test_assertion (pfile, &temp);
1076 result.high = 0;
1077 result.low = temp;
1078 break;
1080 default:
1081 abort ();
1084 result.unsignedp = !!unsignedp;
1085 return result;
1088 /* Operator precedence and flags table.
1090 After an operator is returned from the lexer, if it has priority less
1091 than the operator on the top of the stack, we reduce the stack by one
1092 operator and repeat the test. Since equal priorities do not reduce,
1093 this is naturally right-associative.
1095 We handle left-associative operators by decrementing the priority of
1096 just-lexed operators by one, but retaining the priority of operators
1097 already on the stack.
1099 The remaining cases are '(' and ')'. We handle '(' by skipping the
1100 reduction phase completely. ')' is given lower priority than
1101 everything else, including '(', effectively forcing a reduction of the
1102 parenthesized expression. If there is a matching '(', the routine
1103 reduce() exits immediately. If the normal exit route sees a ')', then
1104 there cannot have been a matching '(' and an error message is output.
1106 The parser assumes all shifted operators require a left operand unless
1107 the flag NO_L_OPERAND is set. These semantics are automatic; any
1108 extra semantics need to be handled with operator-specific code. */
1110 /* Flags. If CHECK_PROMOTION, we warn if the effective sign of an
1111 operand changes because of integer promotions. */
1112 #define NO_L_OPERAND (1 << 0)
1113 #define LEFT_ASSOC (1 << 1)
1114 #define CHECK_PROMOTION (1 << 2)
1116 /* Operator to priority map. Must be in the same order as the first
1117 N entries of enum cpp_ttype. */
1118 static const struct cpp_operator
1120 uchar prio;
1121 uchar flags;
1122 } optab[] =
1124 /* EQ */ {0, 0}, /* Shouldn't happen. */
1125 /* NOT */ {16, NO_L_OPERAND},
1126 /* GREATER */ {12, LEFT_ASSOC | CHECK_PROMOTION},
1127 /* LESS */ {12, LEFT_ASSOC | CHECK_PROMOTION},
1128 /* PLUS */ {14, LEFT_ASSOC | CHECK_PROMOTION},
1129 /* MINUS */ {14, LEFT_ASSOC | CHECK_PROMOTION},
1130 /* MULT */ {15, LEFT_ASSOC | CHECK_PROMOTION},
1131 /* DIV */ {15, LEFT_ASSOC | CHECK_PROMOTION},
1132 /* MOD */ {15, LEFT_ASSOC | CHECK_PROMOTION},
1133 /* AND */ {9, LEFT_ASSOC | CHECK_PROMOTION},
1134 /* OR */ {7, LEFT_ASSOC | CHECK_PROMOTION},
1135 /* XOR */ {8, LEFT_ASSOC | CHECK_PROMOTION},
1136 /* RSHIFT */ {13, LEFT_ASSOC},
1137 /* LSHIFT */ {13, LEFT_ASSOC},
1139 /* COMPL */ {16, NO_L_OPERAND},
1140 /* AND_AND */ {6, LEFT_ASSOC},
1141 /* OR_OR */ {5, LEFT_ASSOC},
1142 /* Note that QUERY, COLON, and COMMA must have the same precedence.
1143 However, there are some special cases for these in reduce(). */
1144 /* QUERY */ {4, 0},
1145 /* COLON */ {4, LEFT_ASSOC | CHECK_PROMOTION},
1146 /* COMMA */ {4, LEFT_ASSOC},
1147 /* OPEN_PAREN */ {1, NO_L_OPERAND},
1148 /* CLOSE_PAREN */ {0, 0},
1149 /* EOF */ {0, 0},
1150 /* EQ_EQ */ {11, LEFT_ASSOC},
1151 /* NOT_EQ */ {11, LEFT_ASSOC},
1152 /* GREATER_EQ */ {12, LEFT_ASSOC | CHECK_PROMOTION},
1153 /* LESS_EQ */ {12, LEFT_ASSOC | CHECK_PROMOTION},
1154 /* UPLUS */ {16, NO_L_OPERAND},
1155 /* UMINUS */ {16, NO_L_OPERAND}
1158 /* Parse and evaluate a C expression, reading from PFILE.
1159 Returns the truth value of the expression.
1161 The implementation is an operator precedence parser, i.e. a
1162 bottom-up parser, using a stack for not-yet-reduced tokens.
1164 The stack base is op_stack, and the current stack pointer is 'top'.
1165 There is a stack element for each operator (only), and the most
1166 recently pushed operator is 'top->op'. An operand (value) is
1167 stored in the 'value' field of the stack element of the operator
1168 that precedes it. */
1169 bool
1170 _cpp_parse_expr (cpp_reader *pfile, bool is_if)
1172 struct op *top = pfile->op_stack;
1173 unsigned int lex_count;
1174 bool saw_leading_not, want_value = true;
1175 source_location virtual_location = 0;
1177 pfile->state.skip_eval = 0;
1179 /* Set up detection of #if ! defined(). */
1180 pfile->mi_ind_cmacro = 0;
1181 saw_leading_not = false;
1182 lex_count = 0;
1184 /* Lowest priority operator prevents further reductions. */
1185 top->op = CPP_EOF;
1187 for (;;)
1189 struct op op;
1191 lex_count++;
1192 op.token = cpp_get_token_with_location (pfile, &virtual_location);
1193 op.op = op.token->type;
1194 op.loc = virtual_location;
1196 switch (op.op)
1198 /* These tokens convert into values. */
1199 case CPP_NUMBER:
1200 case CPP_CHAR:
1201 case CPP_WCHAR:
1202 case CPP_CHAR16:
1203 case CPP_CHAR32:
1204 case CPP_NAME:
1205 case CPP_HASH:
1206 if (!want_value)
1207 SYNTAX_ERROR2_AT (op.loc,
1208 "missing binary operator before token \"%s\"",
1209 cpp_token_as_text (pfile, op.token));
1210 want_value = false;
1211 top->value = eval_token (pfile, op.token, op.loc);
1212 continue;
1214 case CPP_NOT:
1215 saw_leading_not = lex_count == 1;
1216 break;
1217 case CPP_PLUS:
1218 if (want_value)
1219 op.op = CPP_UPLUS;
1220 break;
1221 case CPP_MINUS:
1222 if (want_value)
1223 op.op = CPP_UMINUS;
1224 break;
1226 default:
1227 if ((int) op.op <= (int) CPP_EQ || (int) op.op >= (int) CPP_PLUS_EQ)
1228 SYNTAX_ERROR2_AT (op.loc,
1229 "token \"%s\" is not valid in preprocessor expressions",
1230 cpp_token_as_text (pfile, op.token));
1231 break;
1234 /* Check we have a value or operator as appropriate. */
1235 if (optab[op.op].flags & NO_L_OPERAND)
1237 if (!want_value)
1238 SYNTAX_ERROR2_AT (op.loc,
1239 "missing binary operator before token \"%s\"",
1240 cpp_token_as_text (pfile, op.token));
1242 else if (want_value)
1244 /* We want a number (or expression) and haven't got one.
1245 Try to emit a specific diagnostic. */
1246 if (op.op == CPP_CLOSE_PAREN && top->op == CPP_OPEN_PAREN)
1247 SYNTAX_ERROR_AT (op.loc,
1248 "missing expression between '(' and ')'");
1250 if (op.op == CPP_EOF && top->op == CPP_EOF)
1251 SYNTAX_ERROR2_AT (op.loc,
1252 "%s with no expression", is_if ? "#if" : "#elif");
1254 if (top->op != CPP_EOF && top->op != CPP_OPEN_PAREN)
1255 SYNTAX_ERROR2_AT (op.loc,
1256 "operator '%s' has no right operand",
1257 cpp_token_as_text (pfile, top->token));
1258 else if (op.op == CPP_CLOSE_PAREN || op.op == CPP_EOF)
1259 /* Complain about missing paren during reduction. */;
1260 else
1261 SYNTAX_ERROR2_AT (op.loc,
1262 "operator '%s' has no left operand",
1263 cpp_token_as_text (pfile, op.token));
1266 top = reduce (pfile, top, op.op);
1267 if (!top)
1268 goto syntax_error;
1270 if (op.op == CPP_EOF)
1271 break;
1273 switch (op.op)
1275 case CPP_CLOSE_PAREN:
1276 continue;
1277 case CPP_OR_OR:
1278 if (!num_zerop (top->value))
1279 pfile->state.skip_eval++;
1280 break;
1281 case CPP_AND_AND:
1282 case CPP_QUERY:
1283 if (num_zerop (top->value))
1284 pfile->state.skip_eval++;
1285 break;
1286 case CPP_COLON:
1287 if (top->op != CPP_QUERY)
1288 SYNTAX_ERROR_AT (op.loc,
1289 " ':' without preceding '?'");
1290 if (!num_zerop (top[-1].value)) /* Was '?' condition true? */
1291 pfile->state.skip_eval++;
1292 else
1293 pfile->state.skip_eval--;
1294 default:
1295 break;
1298 want_value = true;
1300 /* Check for and handle stack overflow. */
1301 if (++top == pfile->op_limit)
1302 top = _cpp_expand_op_stack (pfile);
1304 top->op = op.op;
1305 top->token = op.token;
1306 top->loc = op.loc;
1309 /* The controlling macro expression is only valid if we called lex 3
1310 times: <!> <defined expression> and <EOF>. push_conditional ()
1311 checks that we are at top-of-file. */
1312 if (pfile->mi_ind_cmacro && !(saw_leading_not && lex_count == 3))
1313 pfile->mi_ind_cmacro = 0;
1315 if (top != pfile->op_stack)
1317 cpp_error_with_line (pfile, CPP_DL_ICE, top->loc, 0,
1318 "unbalanced stack in %s",
1319 is_if ? "#if" : "#elif");
1320 syntax_error:
1321 return false; /* Return false on syntax error. */
1324 return !num_zerop (top->value);
1327 /* Reduce the operator / value stack if possible, in preparation for
1328 pushing operator OP. Returns NULL on error, otherwise the top of
1329 the stack. */
1330 static struct op *
1331 reduce (cpp_reader *pfile, struct op *top, enum cpp_ttype op)
1333 unsigned int prio;
1335 if (top->op <= CPP_EQ || top->op > CPP_LAST_CPP_OP + 2)
1337 bad_op:
1338 cpp_error (pfile, CPP_DL_ICE, "impossible operator '%u'", top->op);
1339 return 0;
1342 if (op == CPP_OPEN_PAREN)
1343 return top;
1345 /* Decrement the priority of left-associative operators to force a
1346 reduction with operators of otherwise equal priority. */
1347 prio = optab[op].prio - ((optab[op].flags & LEFT_ASSOC) != 0);
1348 while (prio < optab[top->op].prio)
1350 if (CPP_OPTION (pfile, warn_num_sign_change)
1351 && optab[top->op].flags & CHECK_PROMOTION)
1352 check_promotion (pfile, top);
1354 switch (top->op)
1356 case CPP_UPLUS:
1357 case CPP_UMINUS:
1358 case CPP_NOT:
1359 case CPP_COMPL:
1360 top[-1].value = num_unary_op (pfile, top->value, top->op);
1361 top[-1].loc = top->loc;
1362 break;
1364 case CPP_PLUS:
1365 case CPP_MINUS:
1366 case CPP_RSHIFT:
1367 case CPP_LSHIFT:
1368 case CPP_COMMA:
1369 top[-1].value = num_binary_op (pfile, top[-1].value,
1370 top->value, top->op);
1371 top[-1].loc = top->loc;
1372 break;
1374 case CPP_GREATER:
1375 case CPP_LESS:
1376 case CPP_GREATER_EQ:
1377 case CPP_LESS_EQ:
1378 top[-1].value
1379 = num_inequality_op (pfile, top[-1].value, top->value, top->op);
1380 top[-1].loc = top->loc;
1381 break;
1383 case CPP_EQ_EQ:
1384 case CPP_NOT_EQ:
1385 top[-1].value
1386 = num_equality_op (pfile, top[-1].value, top->value, top->op);
1387 top[-1].loc = top->loc;
1388 break;
1390 case CPP_AND:
1391 case CPP_OR:
1392 case CPP_XOR:
1393 top[-1].value
1394 = num_bitwise_op (pfile, top[-1].value, top->value, top->op);
1395 top[-1].loc = top->loc;
1396 break;
1398 case CPP_MULT:
1399 top[-1].value = num_mul (pfile, top[-1].value, top->value);
1400 top[-1].loc = top->loc;
1401 break;
1403 case CPP_DIV:
1404 case CPP_MOD:
1405 top[-1].value = num_div_op (pfile, top[-1].value,
1406 top->value, top->op, top->loc);
1407 top[-1].loc = top->loc;
1408 break;
1410 case CPP_OR_OR:
1411 top--;
1412 if (!num_zerop (top->value))
1413 pfile->state.skip_eval--;
1414 top->value.low = (!num_zerop (top->value)
1415 || !num_zerop (top[1].value));
1416 top->value.high = 0;
1417 top->value.unsignedp = false;
1418 top->value.overflow = false;
1419 top->loc = top[1].loc;
1420 continue;
1422 case CPP_AND_AND:
1423 top--;
1424 if (num_zerop (top->value))
1425 pfile->state.skip_eval--;
1426 top->value.low = (!num_zerop (top->value)
1427 && !num_zerop (top[1].value));
1428 top->value.high = 0;
1429 top->value.unsignedp = false;
1430 top->value.overflow = false;
1431 top->loc = top[1].loc;
1432 continue;
1434 case CPP_OPEN_PAREN:
1435 if (op != CPP_CLOSE_PAREN)
1437 cpp_error_with_line (pfile, CPP_DL_ERROR,
1438 top->token->src_loc,
1439 0, "missing ')' in expression");
1440 return 0;
1442 top--;
1443 top->value = top[1].value;
1444 top->loc = top[1].loc;
1445 return top;
1447 case CPP_COLON:
1448 top -= 2;
1449 if (!num_zerop (top->value))
1451 pfile->state.skip_eval--;
1452 top->value = top[1].value;
1453 top->loc = top[1].loc;
1455 else
1457 top->value = top[2].value;
1458 top->loc = top[2].loc;
1460 top->value.unsignedp = (top[1].value.unsignedp
1461 || top[2].value.unsignedp);
1462 continue;
1464 case CPP_QUERY:
1465 /* COMMA and COLON should not reduce a QUERY operator. */
1466 if (op == CPP_COMMA || op == CPP_COLON)
1467 return top;
1468 cpp_error (pfile, CPP_DL_ERROR, "'?' without following ':'");
1469 return 0;
1471 default:
1472 goto bad_op;
1475 top--;
1476 if (top->value.overflow && !pfile->state.skip_eval)
1477 cpp_error (pfile, CPP_DL_PEDWARN,
1478 "integer overflow in preprocessor expression");
1481 if (op == CPP_CLOSE_PAREN)
1483 cpp_error (pfile, CPP_DL_ERROR, "missing '(' in expression");
1484 return 0;
1487 return top;
1490 /* Returns the position of the old top of stack after expansion. */
1491 struct op *
1492 _cpp_expand_op_stack (cpp_reader *pfile)
1494 size_t old_size = (size_t) (pfile->op_limit - pfile->op_stack);
1495 size_t new_size = old_size * 2 + 20;
1497 pfile->op_stack = XRESIZEVEC (struct op, pfile->op_stack, new_size);
1498 pfile->op_limit = pfile->op_stack + new_size;
1500 return pfile->op_stack + old_size;
1503 /* Emits a warning if the effective sign of either operand of OP
1504 changes because of integer promotions. */
1505 static void
1506 check_promotion (cpp_reader *pfile, const struct op *op)
1508 if (op->value.unsignedp == op[-1].value.unsignedp)
1509 return;
1511 if (op->value.unsignedp)
1513 if (!num_positive (op[-1].value, CPP_OPTION (pfile, precision)))
1514 cpp_error_with_line (pfile, CPP_DL_WARNING, op[-1].loc, 0,
1515 "the left operand of \"%s\" changes sign when promoted",
1516 cpp_token_as_text (pfile, op->token));
1518 else if (!num_positive (op->value, CPP_OPTION (pfile, precision)))
1519 cpp_error_with_line (pfile, CPP_DL_WARNING, op->loc, 0,
1520 "the right operand of \"%s\" changes sign when promoted",
1521 cpp_token_as_text (pfile, op->token));
1524 /* Clears the unused high order bits of the number pointed to by PNUM. */
1525 static cpp_num
1526 num_trim (cpp_num num, size_t precision)
1528 if (precision > PART_PRECISION)
1530 precision -= PART_PRECISION;
1531 if (precision < PART_PRECISION)
1532 num.high &= ((cpp_num_part) 1 << precision) - 1;
1534 else
1536 if (precision < PART_PRECISION)
1537 num.low &= ((cpp_num_part) 1 << precision) - 1;
1538 num.high = 0;
1541 return num;
1544 /* True iff A (presumed signed) >= 0. */
1545 static bool
1546 num_positive (cpp_num num, size_t precision)
1548 if (precision > PART_PRECISION)
1550 precision -= PART_PRECISION;
1551 return (num.high & (cpp_num_part) 1 << (precision - 1)) == 0;
1554 return (num.low & (cpp_num_part) 1 << (precision - 1)) == 0;
1557 /* Sign extend a number, with PRECISION significant bits and all
1558 others assumed clear, to fill out a cpp_num structure. */
1559 cpp_num
1560 cpp_num_sign_extend (cpp_num num, size_t precision)
1562 if (!num.unsignedp)
1564 if (precision > PART_PRECISION)
1566 precision -= PART_PRECISION;
1567 if (precision < PART_PRECISION
1568 && (num.high & (cpp_num_part) 1 << (precision - 1)))
1569 num.high |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1571 else if (num.low & (cpp_num_part) 1 << (precision - 1))
1573 if (precision < PART_PRECISION)
1574 num.low |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1575 num.high = ~(cpp_num_part) 0;
1579 return num;
1582 /* Returns the negative of NUM. */
1583 static cpp_num
1584 num_negate (cpp_num num, size_t precision)
1586 cpp_num copy;
1588 copy = num;
1589 num.high = ~num.high;
1590 num.low = ~num.low;
1591 if (++num.low == 0)
1592 num.high++;
1593 num = num_trim (num, precision);
1594 num.overflow = (!num.unsignedp && num_eq (num, copy) && !num_zerop (num));
1596 return num;
1599 /* Returns true if A >= B. */
1600 static bool
1601 num_greater_eq (cpp_num pa, cpp_num pb, size_t precision)
1603 bool unsignedp;
1605 unsignedp = pa.unsignedp || pb.unsignedp;
1607 if (!unsignedp)
1609 /* Both numbers have signed type. If they are of different
1610 sign, the answer is the sign of A. */
1611 unsignedp = num_positive (pa, precision);
1613 if (unsignedp != num_positive (pb, precision))
1614 return unsignedp;
1616 /* Otherwise we can do an unsigned comparison. */
1619 return (pa.high > pb.high) || (pa.high == pb.high && pa.low >= pb.low);
1622 /* Returns LHS OP RHS, where OP is a bit-wise operation. */
1623 static cpp_num
1624 num_bitwise_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1625 cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1627 lhs.overflow = false;
1628 lhs.unsignedp = lhs.unsignedp || rhs.unsignedp;
1630 /* As excess precision is zeroed, there is no need to num_trim () as
1631 these operations cannot introduce a set bit there. */
1632 if (op == CPP_AND)
1634 lhs.low &= rhs.low;
1635 lhs.high &= rhs.high;
1637 else if (op == CPP_OR)
1639 lhs.low |= rhs.low;
1640 lhs.high |= rhs.high;
1642 else
1644 lhs.low ^= rhs.low;
1645 lhs.high ^= rhs.high;
1648 return lhs;
1651 /* Returns LHS OP RHS, where OP is an inequality. */
1652 static cpp_num
1653 num_inequality_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs,
1654 enum cpp_ttype op)
1656 bool gte = num_greater_eq (lhs, rhs, CPP_OPTION (pfile, precision));
1658 if (op == CPP_GREATER_EQ)
1659 lhs.low = gte;
1660 else if (op == CPP_LESS)
1661 lhs.low = !gte;
1662 else if (op == CPP_GREATER)
1663 lhs.low = gte && !num_eq (lhs, rhs);
1664 else /* CPP_LESS_EQ. */
1665 lhs.low = !gte || num_eq (lhs, rhs);
1667 lhs.high = 0;
1668 lhs.overflow = false;
1669 lhs.unsignedp = false;
1670 return lhs;
1673 /* Returns LHS OP RHS, where OP is == or !=. */
1674 static cpp_num
1675 num_equality_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1676 cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1678 /* Work around a 3.0.4 bug; see PR 6950. */
1679 bool eq = num_eq (lhs, rhs);
1680 if (op == CPP_NOT_EQ)
1681 eq = !eq;
1682 lhs.low = eq;
1683 lhs.high = 0;
1684 lhs.overflow = false;
1685 lhs.unsignedp = false;
1686 return lhs;
1689 /* Shift NUM, of width PRECISION, right by N bits. */
1690 static cpp_num
1691 num_rshift (cpp_num num, size_t precision, size_t n)
1693 cpp_num_part sign_mask;
1694 bool x = num_positive (num, precision);
1696 if (num.unsignedp || x)
1697 sign_mask = 0;
1698 else
1699 sign_mask = ~(cpp_num_part) 0;
1701 if (n >= precision)
1702 num.high = num.low = sign_mask;
1703 else
1705 /* Sign-extend. */
1706 if (precision < PART_PRECISION)
1707 num.high = sign_mask, num.low |= sign_mask << precision;
1708 else if (precision < 2 * PART_PRECISION)
1709 num.high |= sign_mask << (precision - PART_PRECISION);
1711 if (n >= PART_PRECISION)
1713 n -= PART_PRECISION;
1714 num.low = num.high;
1715 num.high = sign_mask;
1718 if (n)
1720 num.low = (num.low >> n) | (num.high << (PART_PRECISION - n));
1721 num.high = (num.high >> n) | (sign_mask << (PART_PRECISION - n));
1725 num = num_trim (num, precision);
1726 num.overflow = false;
1727 return num;
1730 /* Shift NUM, of width PRECISION, left by N bits. */
1731 static cpp_num
1732 num_lshift (cpp_num num, size_t precision, size_t n)
1734 if (n >= precision)
1736 num.overflow = !num.unsignedp && !num_zerop (num);
1737 num.high = num.low = 0;
1739 else
1741 cpp_num orig, maybe_orig;
1742 size_t m = n;
1744 orig = num;
1745 if (m >= PART_PRECISION)
1747 m -= PART_PRECISION;
1748 num.high = num.low;
1749 num.low = 0;
1751 if (m)
1753 num.high = (num.high << m) | (num.low >> (PART_PRECISION - m));
1754 num.low <<= m;
1756 num = num_trim (num, precision);
1758 if (num.unsignedp)
1759 num.overflow = false;
1760 else
1762 maybe_orig = num_rshift (num, precision, n);
1763 num.overflow = !num_eq (orig, maybe_orig);
1767 return num;
1770 /* The four unary operators: +, -, ! and ~. */
1771 static cpp_num
1772 num_unary_op (cpp_reader *pfile, cpp_num num, enum cpp_ttype op)
1774 switch (op)
1776 case CPP_UPLUS:
1777 if (CPP_WTRADITIONAL (pfile) && !pfile->state.skip_eval)
1778 cpp_warning (pfile, CPP_W_TRADITIONAL,
1779 "traditional C rejects the unary plus operator");
1780 num.overflow = false;
1781 break;
1783 case CPP_UMINUS:
1784 num = num_negate (num, CPP_OPTION (pfile, precision));
1785 break;
1787 case CPP_COMPL:
1788 num.high = ~num.high;
1789 num.low = ~num.low;
1790 num = num_trim (num, CPP_OPTION (pfile, precision));
1791 num.overflow = false;
1792 break;
1794 default: /* case CPP_NOT: */
1795 num.low = num_zerop (num);
1796 num.high = 0;
1797 num.overflow = false;
1798 num.unsignedp = false;
1799 break;
1802 return num;
1805 /* The various binary operators. */
1806 static cpp_num
1807 num_binary_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1809 cpp_num result;
1810 size_t precision = CPP_OPTION (pfile, precision);
1811 size_t n;
1813 switch (op)
1815 /* Shifts. */
1816 case CPP_LSHIFT:
1817 case CPP_RSHIFT:
1818 if (!rhs.unsignedp && !num_positive (rhs, precision))
1820 /* A negative shift is a positive shift the other way. */
1821 if (op == CPP_LSHIFT)
1822 op = CPP_RSHIFT;
1823 else
1824 op = CPP_LSHIFT;
1825 rhs = num_negate (rhs, precision);
1827 if (rhs.high)
1828 n = ~0; /* Maximal. */
1829 else
1830 n = rhs.low;
1831 if (op == CPP_LSHIFT)
1832 lhs = num_lshift (lhs, precision, n);
1833 else
1834 lhs = num_rshift (lhs, precision, n);
1835 break;
1837 /* Arithmetic. */
1838 case CPP_MINUS:
1839 result.low = lhs.low - rhs.low;
1840 result.high = lhs.high - rhs.high;
1841 if (result.low > lhs.low)
1842 result.high--;
1843 result.unsignedp = lhs.unsignedp || rhs.unsignedp;
1844 result.overflow = false;
1846 result = num_trim (result, precision);
1847 if (!result.unsignedp)
1849 bool lhsp = num_positive (lhs, precision);
1850 result.overflow = (lhsp != num_positive (rhs, precision)
1851 && lhsp != num_positive (result, precision));
1853 return result;
1855 case CPP_PLUS:
1856 result.low = lhs.low + rhs.low;
1857 result.high = lhs.high + rhs.high;
1858 if (result.low < lhs.low)
1859 result.high++;
1860 result.unsignedp = lhs.unsignedp || rhs.unsignedp;
1861 result.overflow = false;
1863 result = num_trim (result, precision);
1864 if (!result.unsignedp)
1866 bool lhsp = num_positive (lhs, precision);
1867 result.overflow = (lhsp == num_positive (rhs, precision)
1868 && lhsp != num_positive (result, precision));
1870 return result;
1872 /* Comma. */
1873 default: /* case CPP_COMMA: */
1874 if (CPP_PEDANTIC (pfile) && (!CPP_OPTION (pfile, c99)
1875 || !pfile->state.skip_eval))
1876 cpp_error (pfile, CPP_DL_PEDWARN,
1877 "comma operator in operand of #if");
1878 lhs = rhs;
1879 break;
1882 return lhs;
1885 /* Multiplies two unsigned cpp_num_parts to give a cpp_num. This
1886 cannot overflow. */
1887 static cpp_num
1888 num_part_mul (cpp_num_part lhs, cpp_num_part rhs)
1890 cpp_num result;
1891 cpp_num_part middle[2], temp;
1893 result.low = LOW_PART (lhs) * LOW_PART (rhs);
1894 result.high = HIGH_PART (lhs) * HIGH_PART (rhs);
1896 middle[0] = LOW_PART (lhs) * HIGH_PART (rhs);
1897 middle[1] = HIGH_PART (lhs) * LOW_PART (rhs);
1899 temp = result.low;
1900 result.low += LOW_PART (middle[0]) << (PART_PRECISION / 2);
1901 if (result.low < temp)
1902 result.high++;
1904 temp = result.low;
1905 result.low += LOW_PART (middle[1]) << (PART_PRECISION / 2);
1906 if (result.low < temp)
1907 result.high++;
1909 result.high += HIGH_PART (middle[0]);
1910 result.high += HIGH_PART (middle[1]);
1911 result.unsignedp = true;
1912 result.overflow = false;
1914 return result;
1917 /* Multiply two preprocessing numbers. */
1918 static cpp_num
1919 num_mul (cpp_reader *pfile, cpp_num lhs, cpp_num rhs)
1921 cpp_num result, temp;
1922 bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1923 bool overflow, negate = false;
1924 size_t precision = CPP_OPTION (pfile, precision);
1926 /* Prepare for unsigned multiplication. */
1927 if (!unsignedp)
1929 if (!num_positive (lhs, precision))
1930 negate = !negate, lhs = num_negate (lhs, precision);
1931 if (!num_positive (rhs, precision))
1932 negate = !negate, rhs = num_negate (rhs, precision);
1935 overflow = lhs.high && rhs.high;
1936 result = num_part_mul (lhs.low, rhs.low);
1938 temp = num_part_mul (lhs.high, rhs.low);
1939 result.high += temp.low;
1940 if (temp.high)
1941 overflow = true;
1943 temp = num_part_mul (lhs.low, rhs.high);
1944 result.high += temp.low;
1945 if (temp.high)
1946 overflow = true;
1948 temp.low = result.low, temp.high = result.high;
1949 result = num_trim (result, precision);
1950 if (!num_eq (result, temp))
1951 overflow = true;
1953 if (negate)
1954 result = num_negate (result, precision);
1956 if (unsignedp)
1957 result.overflow = false;
1958 else
1959 result.overflow = overflow || (num_positive (result, precision) ^ !negate
1960 && !num_zerop (result));
1961 result.unsignedp = unsignedp;
1963 return result;
1966 /* Divide two preprocessing numbers, LHS and RHS, returning the answer
1967 or the remainder depending upon OP. LOCATION is the source location
1968 of this operator (for diagnostics). */
1970 static cpp_num
1971 num_div_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op,
1972 source_location location)
1974 cpp_num result, sub;
1975 cpp_num_part mask;
1976 bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1977 bool negate = false, lhs_neg = false;
1978 size_t i, precision = CPP_OPTION (pfile, precision);
1980 /* Prepare for unsigned division. */
1981 if (!unsignedp)
1983 if (!num_positive (lhs, precision))
1984 negate = !negate, lhs_neg = true, lhs = num_negate (lhs, precision);
1985 if (!num_positive (rhs, precision))
1986 negate = !negate, rhs = num_negate (rhs, precision);
1989 /* Find the high bit. */
1990 if (rhs.high)
1992 i = precision - 1;
1993 mask = (cpp_num_part) 1 << (i - PART_PRECISION);
1994 for (; ; i--, mask >>= 1)
1995 if (rhs.high & mask)
1996 break;
1998 else if (rhs.low)
2000 if (precision > PART_PRECISION)
2001 i = precision - PART_PRECISION - 1;
2002 else
2003 i = precision - 1;
2004 mask = (cpp_num_part) 1 << i;
2005 for (; ; i--, mask >>= 1)
2006 if (rhs.low & mask)
2007 break;
2009 else
2011 if (!pfile->state.skip_eval)
2012 cpp_error_with_line (pfile, CPP_DL_ERROR, location, 0,
2013 "division by zero in #if");
2014 return lhs;
2017 /* First nonzero bit of RHS is bit I. Do naive division by
2018 shifting the RHS fully left, and subtracting from LHS if LHS is
2019 at least as big, and then repeating but with one less shift.
2020 This is not very efficient, but is easy to understand. */
2022 rhs.unsignedp = true;
2023 lhs.unsignedp = true;
2024 i = precision - i - 1;
2025 sub = num_lshift (rhs, precision, i);
2027 result.high = result.low = 0;
2028 for (;;)
2030 if (num_greater_eq (lhs, sub, precision))
2032 lhs = num_binary_op (pfile, lhs, sub, CPP_MINUS);
2033 if (i >= PART_PRECISION)
2034 result.high |= (cpp_num_part) 1 << (i - PART_PRECISION);
2035 else
2036 result.low |= (cpp_num_part) 1 << i;
2038 if (i-- == 0)
2039 break;
2040 sub.low = (sub.low >> 1) | (sub.high << (PART_PRECISION - 1));
2041 sub.high >>= 1;
2044 /* We divide so that the remainder has the sign of the LHS. */
2045 if (op == CPP_DIV)
2047 result.unsignedp = unsignedp;
2048 result.overflow = false;
2049 if (!unsignedp)
2051 if (negate)
2052 result = num_negate (result, precision);
2053 result.overflow = (num_positive (result, precision) ^ !negate
2054 && !num_zerop (result));
2057 return result;
2060 /* CPP_MOD. */
2061 lhs.unsignedp = unsignedp;
2062 lhs.overflow = false;
2063 if (lhs_neg)
2064 lhs = num_negate (lhs, precision);
2066 return lhs;