blob: 07f1b2fb419aec7b44825f6ba4c0626856bf97cc [file] [log] [blame]
Zack Weinbergb0699da2000-03-07 20:58:47 +00001/* Parse C expressions for cpplib.
Richard Sandiford35c3d612014-01-02 22:24:45 +00002 Copyright (C) 1987-2014 Free Software Foundation, Inc.
Richard Kennere38992e2000-04-18 20:42:00 +00003 Contributed by Per Bothner, 1994.
Per Bothner7f2935c1995-03-16 13:59:07 -08004
5This program is free software; you can redistribute it and/or modify it
6under the terms of the GNU General Public License as published by the
Jakub Jelinek748086b2009-04-09 17:00:19 +02007Free Software Foundation; either version 3, or (at your option) any
Per Bothner7f2935c1995-03-16 13:59:07 -08008later version.
9
10This program is distributed in the hope that it will be useful,
11but WITHOUT ANY WARRANTY; without even the implied warranty of
12MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13GNU General Public License for more details.
14
15You should have received a copy of the GNU General Public License
Jakub Jelinek748086b2009-04-09 17:00:19 +020016along with this program; see the file COPYING3. If not see
17<http://www.gnu.org/licenses/>. */
Per Bothner7f2935c1995-03-16 13:59:07 -080018
Per Bothner7f2935c1995-03-16 13:59:07 -080019#include "config.h"
Kaveh R. Ghazib04cd5071998-03-30 12:05:54 +000020#include "system.h"
Kaveh R. Ghazi487a6e01998-05-19 08:42:48 +000021#include "cpplib.h"
Paolo Bonzini4f4e53dd2004-05-24 10:50:45 +000022#include "internal.h"
Per Bothner7f2935c1995-03-16 13:59:07 -080023
Neil Booth91318902002-05-26 18:42:21 +000024#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))
28
Zack Weinbergcf00a882000-07-08 02:33:00 +000029struct op
Zack Weinbergb0699da2000-03-07 20:58:47 +000030{
Neil Booth68e652752002-07-20 13:31:56 +000031 const cpp_token *token; /* The token forming op (for diagnostics). */
Neil Boothad28cff2002-07-18 22:08:35 +000032 cpp_num value; /* The value logically "right" of op. */
Manuel López-Ibáñez47960aa2008-10-31 22:00:37 +000033 source_location loc; /* The location of this value. */
Zack Weinbergcf00a882000-07-08 02:33:00 +000034 enum cpp_ttype op;
Per Bothner7f2935c1995-03-16 13:59:07 -080035};
Per Bothner7f2935c1995-03-16 13:59:07 -080036
Neil Booth91318902002-05-26 18:42:21 +000037/* 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)
Zack Weinberg6cf87ca2003-06-17 06:17:44 +000040static bool num_positive (cpp_num, size_t);
41static bool num_greater_eq (cpp_num, cpp_num, size_t);
42static cpp_num num_trim (cpp_num, size_t);
43static cpp_num num_part_mul (cpp_num_part, cpp_num_part);
Neil Booth91318902002-05-26 18:42:21 +000044
Zack Weinberg6cf87ca2003-06-17 06:17:44 +000045static cpp_num num_unary_op (cpp_reader *, cpp_num, enum cpp_ttype);
46static cpp_num num_binary_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);
47static cpp_num num_negate (cpp_num, size_t);
48static cpp_num num_bitwise_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);
49static cpp_num num_inequality_op (cpp_reader *, cpp_num, cpp_num,
50 enum cpp_ttype);
51static cpp_num num_equality_op (cpp_reader *, cpp_num, cpp_num,
52 enum cpp_ttype);
53static cpp_num num_mul (cpp_reader *, cpp_num, cpp_num);
Manuel López-Ibáñezb506a5a2009-06-18 15:10:23 +000054static cpp_num num_div_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype,
55 source_location);
Zack Weinberg6cf87ca2003-06-17 06:17:44 +000056static cpp_num num_lshift (cpp_num, size_t, size_t);
57static cpp_num num_rshift (cpp_num, size_t, size_t);
Neil Booth91318902002-05-26 18:42:21 +000058
Zack Weinberg6cf87ca2003-06-17 06:17:44 +000059static cpp_num append_digit (cpp_num, int, int, size_t);
60static cpp_num parse_defined (cpp_reader *);
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +000061static cpp_num eval_token (cpp_reader *, const cpp_token *, source_location);
Zack Weinberg6cf87ca2003-06-17 06:17:44 +000062static struct op *reduce (cpp_reader *, struct op *, enum cpp_ttype);
Ed Smith-Rowlanda4a00162012-11-10 00:08:49 +000063static unsigned int interpret_float_suffix (cpp_reader *, const uchar *, size_t);
64static unsigned int interpret_int_suffix (cpp_reader *, const uchar *, size_t);
Zack Weinberg6cf87ca2003-06-17 06:17:44 +000065static void check_promotion (cpp_reader *, const struct op *);
Neil Booth91318902002-05-26 18:42:21 +000066
Neil Boothcd7ab832002-05-29 17:15:42 +000067/* Token type abuse to create unary plus and minus operators. */
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +000068#define CPP_UPLUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 1))
69#define CPP_UMINUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 2))
Zack Weinbergcf00a882000-07-08 02:33:00 +000070
Zack Weinberg15dad1d2000-05-18 15:55:46 +000071/* With -O2, gcc appears to produce nice code, moving the error
72 message load and subsequent jump completely out of the main path. */
Zack Weinberg15dad1d2000-05-18 15:55:46 +000073#define SYNTAX_ERROR(msgid) \
John David Anglin0527bc42003-11-01 22:56:54 +000074 do { cpp_error (pfile, CPP_DL_ERROR, msgid); goto syntax_error; } while(0)
Zack Weinberg15dad1d2000-05-18 15:55:46 +000075#define SYNTAX_ERROR2(msgid, arg) \
John David Anglin0527bc42003-11-01 22:56:54 +000076 do { cpp_error (pfile, CPP_DL_ERROR, msgid, arg); goto syntax_error; } \
77 while(0)
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +000078#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)
Zack Weinberg15dad1d2000-05-18 15:55:46 +000084
Neil Boothcd7ab832002-05-29 17:15:42 +000085/* 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. */
88static unsigned int
Ed Smith-Rowlanda4a00162012-11-10 00:08:49 +000089interpret_float_suffix (cpp_reader *pfile, const uchar *s, size_t len)
Per Bothner7f2935c1995-03-16 13:59:07 -080090{
Janis Johnsoneec49112009-04-01 17:04:42 +000091 size_t flags;
Janis Johnson839a3b82009-04-01 17:31:26 +000092 size_t f, d, l, w, q, i;
Uros Bizjakc77cd3d2007-07-03 07:53:58 +020093
Janis Johnsoneec49112009-04-01 17:04:42 +000094 flags = 0;
Janis Johnson839a3b82009-04-01 17:31:26 +000095 f = d = l = w = q = i = 0;
Zack Weinbergcf00a882000-07-08 02:33:00 +000096
Janis Johnsoneec49112009-04-01 17:04:42 +000097 /* 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'))
100 {
101 bool uppercase = (*s == 'D');
102 switch (s[1])
103 {
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:
Janis Johnson839a3b82009-04-01 17:31:26 +0000111 /* Additional two-character suffixes beginning with D are not
112 for decimal float constants. */
113 break;
Janis Johnsoneec49112009-04-01 17:04:42 +0000114 }
115 }
116
Ed Smith-Rowlanda4a00162012-11-10 00:08:49 +0000117 if (CPP_OPTION (pfile, ext_numeric_literals))
Janis Johnsoneec49112009-04-01 17:04:42 +0000118 {
Ed Smith-Rowlanda4a00162012-11-10 00:08:49 +0000119 /* Recognize a fixed-point suffix. */
120 if (len != 0)
121 switch (s[len-1])
122 {
123 case 'k': case 'K': flags = CPP_N_ACCUM; break;
124 case 'r': case 'R': flags = CPP_N_FRACT; break;
125 default: break;
126 }
Janis Johnsoneec49112009-04-01 17:04:42 +0000127
Ed Smith-Rowlanda4a00162012-11-10 00:08:49 +0000128 /* Continue processing a fixed-point suffix. The suffix is case
129 insensitive except for ll or LL. Order is significant. */
130 if (flags)
Janis Johnsoneec49112009-04-01 17:04:42 +0000131 {
Janis Johnsoneec49112009-04-01 17:04:42 +0000132 if (len == 1)
133 return flags;
134 len--;
Janis Johnsoneec49112009-04-01 17:04:42 +0000135
Ed Smith-Rowlanda4a00162012-11-10 00:08:49 +0000136 if (*s == 'u' || *s == 'U')
137 {
138 flags |= CPP_N_UNSIGNED;
139 if (len == 1)
140 return flags;
141 len--;
142 s++;
143 }
144
145 switch (*s)
146 {
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;
165 }
166 /* Anything left at this point is invalid. */
167 return 0;
168 }
Janis Johnsoneec49112009-04-01 17:04:42 +0000169 }
170
171 /* In any remaining valid suffix, the case and order don't matter. */
Neil Boothcd7ab832002-05-29 17:15:42 +0000172 while (len--)
173 switch (s[len])
174 {
Janis Johnsoneec49112009-04-01 17:04:42 +0000175 case 'f': case 'F': f++; break;
Janis Johnson839a3b82009-04-01 17:31:26 +0000176 case 'd': case 'D': d++; break;
Janis Johnsoneec49112009-04-01 17:04:42 +0000177 case 'l': case 'L': l++; break;
178 case 'w': case 'W': w++; break;
179 case 'q': case 'Q': q++; break;
Neil Boothcd7ab832002-05-29 17:15:42 +0000180 case 'i': case 'I':
181 case 'j': case 'J': i++; break;
182 default:
183 return 0;
184 }
Zack Weinbergcf00a882000-07-08 02:33:00 +0000185
Janis Johnson839a3b82009-04-01 17:31:26 +0000186 if (f + d + l + w + q > 1 || i > 1)
Jon Grimmad6ed772005-12-06 23:13:15 +0000187 return 0;
188
Ed Smith-Rowlanda4a00162012-11-10 00:08:49 +0000189 if (i && !CPP_OPTION (pfile, ext_numeric_literals))
190 return 0;
191
192 if ((w || q) && !CPP_OPTION (pfile, ext_numeric_literals))
193 return 0;
194
Neil Boothcd7ab832002-05-29 17:15:42 +0000195 return ((i ? CPP_N_IMAGINARY : 0)
196 | (f ? CPP_N_SMALL :
Janis Johnson839a3b82009-04-01 17:31:26 +0000197 d ? CPP_N_MEDIUM :
Uros Bizjakc77cd3d2007-07-03 07:53:58 +0200198 l ? CPP_N_LARGE :
199 w ? CPP_N_MD_W :
Janis Johnson839a3b82009-04-01 17:31:26 +0000200 q ? CPP_N_MD_Q : CPP_N_DEFAULT));
Neil Boothcd7ab832002-05-29 17:15:42 +0000201}
202
Ed Smith-Rowland3ce4f9e2011-10-26 19:30:59 +0000203/* Return the classification flags for a float suffix. */
204unsigned int
Ed Smith-Rowlanda4a00162012-11-10 00:08:49 +0000205cpp_interpret_float_suffix (cpp_reader *pfile, const char *s, size_t len)
Ed Smith-Rowland3ce4f9e2011-10-26 19:30:59 +0000206{
Ed Smith-Rowlanda4a00162012-11-10 00:08:49 +0000207 return interpret_float_suffix (pfile, (const unsigned char *)s, len);
Ed Smith-Rowland3ce4f9e2011-10-26 19:30:59 +0000208}
209
Neil Boothcd7ab832002-05-29 17:15:42 +0000210/* 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. */
213static unsigned int
Ed Smith-Rowlanda4a00162012-11-10 00:08:49 +0000214interpret_int_suffix (cpp_reader *pfile, const uchar *s, size_t len)
Neil Boothcd7ab832002-05-29 17:15:42 +0000215{
216 size_t u, l, i;
217
218 u = l = i = 0;
219
220 while (len--)
221 switch (s[len])
222 {
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;
233 }
234
235 if (l > 2 || u > 1 || i > 1)
236 return 0;
237
Ed Smith-Rowlanda4a00162012-11-10 00:08:49 +0000238 if (i && !CPP_OPTION (pfile, ext_numeric_literals))
239 return 0;
240
Neil Boothcd7ab832002-05-29 17:15:42 +0000241 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));
245}
246
Ed Smith-Rowland3ce4f9e2011-10-26 19:30:59 +0000247/* Return the classification flags for an int suffix. */
248unsigned int
Ed Smith-Rowlanda4a00162012-11-10 00:08:49 +0000249cpp_interpret_int_suffix (cpp_reader *pfile, const char *s, size_t len)
Ed Smith-Rowland3ce4f9e2011-10-26 19:30:59 +0000250{
Ed Smith-Rowlanda4a00162012-11-10 00:08:49 +0000251 return interpret_int_suffix (pfile, (const unsigned char *)s, len);
Ed Smith-Rowland3ce4f9e2011-10-26 19:30:59 +0000252}
253
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. */
257enum cpp_ttype
258cpp_userdef_string_remove_type (enum cpp_ttype type)
259{
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;
272}
273
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. */
277enum cpp_ttype
278cpp_userdef_string_add_type (enum cpp_ttype type)
279{
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;
292}
293
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. */
297enum cpp_ttype
298cpp_userdef_char_remove_type (enum cpp_ttype type)
299{
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)
Ed Smith-Rowland7e74ce32011-11-21 19:27:30 +0000305 return CPP_CHAR16;
Ed Smith-Rowland3ce4f9e2011-10-26 19:30:59 +0000306 else if (type == CPP_CHAR32_USERDEF)
Ed Smith-Rowland7e74ce32011-11-21 19:27:30 +0000307 return CPP_CHAR32;
Ed Smith-Rowland3ce4f9e2011-10-26 19:30:59 +0000308 else
309 return type;
310}
311
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. */
315enum cpp_ttype
316cpp_userdef_char_add_type (enum cpp_ttype type)
317{
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;
328}
329
330/* Return true if the token type is a user-defined string literal. */
331bool
332cpp_userdef_string_p (enum cpp_ttype type)
333{
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;
342}
343
344/* Return true if the token type is a user-defined char literal. */
345bool
346cpp_userdef_char_p (enum cpp_ttype type)
347{
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;
355}
356
357/* Extract the suffix from a user-defined literal string or char. */
358const char *
359cpp_get_userdef_suffix (const cpp_token *tok)
360{
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;
375}
376
Neil Boothcd7ab832002-05-29 17:15:42 +0000377/* Categorize numeric constants according to their field (integer,
378 floating point, or invalid), radix (decimal, octal, hexadecimal),
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000379 and type suffixes.
380
381 TOKEN is the token that represents the numeric constant to
382 classify.
383
384 In C++0X if UD_SUFFIX is non null it will be assigned
385 any unrecognized suffix for a user-defined literal.
386
387 VIRTUAL_LOCATION is the virtual location for TOKEN. */
Neil Boothcd7ab832002-05-29 17:15:42 +0000388unsigned int
Ed Smith-Rowland3ce4f9e2011-10-26 19:30:59 +0000389cpp_classify_number (cpp_reader *pfile, const cpp_token *token,
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000390 const char **ud_suffix, source_location virtual_location)
Neil Boothcd7ab832002-05-29 17:15:42 +0000391{
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;
Joseph Myersdadab4f2010-01-01 18:08:17 +0000396 bool seen_digit;
Edward Smith-Rowland7057e642013-10-31 14:01:23 +0000397 bool seen_digit_sep;
Neil Boothcd7ab832002-05-29 17:15:42 +0000398
Ed Smith-Rowland3ce4f9e2011-10-26 19:30:59 +0000399 if (ud_suffix)
400 *ud_suffix = NULL;
401
Neil Boothcd7ab832002-05-29 17:15:42 +0000402 /* 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;
406
407 limit = str + token->val.str.len;
408 float_flag = NOT_FLOAT;
409 max_digit = 0;
410 radix = 10;
Joseph Myersdadab4f2010-01-01 18:08:17 +0000411 seen_digit = false;
Edward Smith-Rowland7057e642013-10-31 14:01:23 +0000412 seen_digit_sep = false;
Neil Boothcd7ab832002-05-29 17:15:42 +0000413
414 /* First, interpret the radix. */
415 if (*str == '0')
416 {
417 radix = 8;
418 str++;
419
420 /* Require at least one hex digit to classify it as hex. */
Edward Smith-Rowland7057e642013-10-31 14:01:23 +0000421 if (*str == 'x' || *str == 'X')
Neil Boothcd7ab832002-05-29 17:15:42 +0000422 {
Edward Smith-Rowland7057e642013-10-31 14:01:23 +0000423 if (str[1] == '.' || ISXDIGIT (str[1]))
424 {
425 radix = 16;
426 str++;
427 }
428 else if (DIGIT_SEP (str[1]))
429 SYNTAX_ERROR_AT (virtual_location,
430 "digit separator after base indicator");
Neil Boothcd7ab832002-05-29 17:15:42 +0000431 }
Edward Smith-Rowland7057e642013-10-31 14:01:23 +0000432 else if (*str == 'b' || *str == 'B')
Joerg Wunschf7fd7752007-06-05 22:25:27 +0000433 {
Edward Smith-Rowland7057e642013-10-31 14:01:23 +0000434 if (str[1] == '0' || str[1] == '1')
435 {
436 radix = 2;
437 str++;
438 }
439 else if (DIGIT_SEP (str[1]))
440 SYNTAX_ERROR_AT (virtual_location,
441 "digit separator after base indicator");
Joerg Wunschf7fd7752007-06-05 22:25:27 +0000442 }
Neil Boothcd7ab832002-05-29 17:15:42 +0000443 }
444
445 /* Now scan for a well-formed integer or float. */
446 for (;;)
447 {
448 unsigned int c = *str++;
449
450 if (ISDIGIT (c) || (ISXDIGIT (c) && radix == 16))
451 {
Edward Smith-Rowland7057e642013-10-31 14:01:23 +0000452 seen_digit_sep = false;
Joseph Myersdadab4f2010-01-01 18:08:17 +0000453 seen_digit = true;
Neil Boothcd7ab832002-05-29 17:15:42 +0000454 c = hex_value (c);
455 if (c > max_digit)
456 max_digit = c;
457 }
Edward Smith-Rowland7057e642013-10-31 14:01:23 +0000458 else if (DIGIT_SEP (c))
459 {
460 if (seen_digit_sep)
461 SYNTAX_ERROR_AT (virtual_location, "adjacent digit separators");
462 seen_digit_sep = true;
463 }
Neil Boothcd7ab832002-05-29 17:15:42 +0000464 else if (c == '.')
465 {
Edward Smith-Rowland7057e642013-10-31 14:01:23 +0000466 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;
Neil Boothcd7ab832002-05-29 17:15:42 +0000470 if (float_flag == NOT_FLOAT)
471 float_flag = AFTER_POINT;
472 else
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000473 SYNTAX_ERROR_AT (virtual_location,
474 "too many decimal points in number");
Neil Boothcd7ab832002-05-29 17:15:42 +0000475 }
476 else if ((radix <= 10 && (c == 'e' || c == 'E'))
477 || (radix == 16 && (c == 'p' || c == 'P')))
478 {
Edward Smith-Rowland7057e642013-10-31 14:01:23 +0000479 if (seen_digit_sep || DIGIT_SEP (*str))
480 SYNTAX_ERROR_AT (virtual_location,
481 "digit separator adjacent to exponent");
Neil Boothcd7ab832002-05-29 17:15:42 +0000482 float_flag = AFTER_EXPON;
483 break;
484 }
485 else
486 {
487 /* Start of suffix. */
488 str--;
489 break;
490 }
491 }
492
Edward Smith-Rowland7057e642013-10-31 14:01:23 +0000493 if (seen_digit_sep && float_flag != AFTER_EXPON)
494 SYNTAX_ERROR_AT (virtual_location,
495 "digit separator outside digit sequence");
496
Chao-ying Fuac6b1c62007-08-30 23:05:17 +0000497 /* The suffix may be for decimal fixed-point constants without exponent. */
498 if (radix != 16 && float_flag == NOT_FLOAT)
499 {
Ed Smith-Rowlanda4a00162012-11-10 00:08:49 +0000500 result = interpret_float_suffix (pfile, str, limit - str);
Chao-ying Fuac6b1c62007-08-30 23:05:17 +0000501 if ((result & CPP_N_FRACT) || (result & CPP_N_ACCUM))
502 {
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;
507
508 if (CPP_PEDANTIC (pfile))
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000509 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
510 "fixed-point constants are a GCC extension");
Chao-ying Fuac6b1c62007-08-30 23:05:17 +0000511 goto syntax_ok;
512 }
513 else
514 result = 0;
515 }
516
Neil Boothcd7ab832002-05-29 17:15:42 +0000517 if (float_flag != NOT_FLOAT && radix == 8)
518 radix = 10;
519
520 if (max_digit >= radix)
Joerg Wunschf7fd7752007-06-05 22:25:27 +0000521 {
522 if (radix == 2)
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000523 SYNTAX_ERROR2_AT (virtual_location,
524 "invalid digit \"%c\" in binary constant", '0' + max_digit);
Joerg Wunschf7fd7752007-06-05 22:25:27 +0000525 else
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000526 SYNTAX_ERROR2_AT (virtual_location,
527 "invalid digit \"%c\" in octal constant", '0' + max_digit);
Joerg Wunschf7fd7752007-06-05 22:25:27 +0000528 }
Neil Boothcd7ab832002-05-29 17:15:42 +0000529
530 if (float_flag != NOT_FLOAT)
531 {
Joerg Wunschf7fd7752007-06-05 22:25:27 +0000532 if (radix == 2)
533 {
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000534 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
535 "invalid prefix \"0b\" for floating constant");
Joerg Wunschf7fd7752007-06-05 22:25:27 +0000536 return CPP_N_INVALID;
537 }
538
Joseph Myersdadab4f2010-01-01 18:08:17 +0000539 if (radix == 16 && !seen_digit)
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000540 SYNTAX_ERROR_AT (virtual_location,
541 "no digits in hexadecimal floating constant");
Joseph Myersdadab4f2010-01-01 18:08:17 +0000542
Neil Boothcd7ab832002-05-29 17:15:42 +0000543 if (radix == 16 && CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, c99))
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000544 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
545 "use of C99 hexadecimal floating constant");
Neil Boothcd7ab832002-05-29 17:15:42 +0000546
547 if (float_flag == AFTER_EXPON)
548 {
549 if (*str == '+' || *str == '-')
550 str++;
551
552 /* Exponent is decimal, even if string is a hex float. */
553 if (!ISDIGIT (*str))
Edward Smith-Rowland7057e642013-10-31 14:01:23 +0000554 {
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");
560 }
Neil Boothcd7ab832002-05-29 17:15:42 +0000561 do
Edward Smith-Rowland7057e642013-10-31 14:01:23 +0000562 {
563 seen_digit_sep = DIGIT_SEP (*str);
564 str++;
565 }
566 while (ISDIGIT (*str) || DIGIT_SEP (*str));
Neil Boothcd7ab832002-05-29 17:15:42 +0000567 }
568 else if (radix == 16)
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000569 SYNTAX_ERROR_AT (virtual_location,
570 "hexadecimal floating constants require an exponent");
Neil Boothcd7ab832002-05-29 17:15:42 +0000571
Edward Smith-Rowland7057e642013-10-31 14:01:23 +0000572 if (seen_digit_sep)
573 SYNTAX_ERROR_AT (virtual_location,
574 "digit separator outside digit sequence");
575
Ed Smith-Rowlanda4a00162012-11-10 00:08:49 +0000576 result = interpret_float_suffix (pfile, str, limit - str);
Neil Boothcd7ab832002-05-29 17:15:42 +0000577 if (result == 0)
578 {
Ed Smith-Rowland3ce4f9e2011-10-26 19:30:59 +0000579 if (CPP_OPTION (pfile, user_literals))
580 {
581 if (ud_suffix)
582 *ud_suffix = (const char *) str;
583 result = CPP_N_LARGE | CPP_N_USERDEF;
584 }
585 else
586 {
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000587 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
588 "invalid suffix \"%.*s\" on floating constant",
589 (int) (limit - str), str);
Ed Smith-Rowland3ce4f9e2011-10-26 19:30:59 +0000590 return CPP_N_INVALID;
591 }
Neil Boothcd7ab832002-05-29 17:15:42 +0000592 }
593
594 /* Traditional C didn't accept any floating suffixes. */
595 if (limit != str
596 && CPP_WTRADITIONAL (pfile)
597 && ! cpp_sys_macro_p (pfile))
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000598 cpp_warning_with_line (pfile, CPP_W_TRADITIONAL, virtual_location, 0,
599 "traditional C rejects the \"%.*s\" suffix",
600 (int) (limit - str), str);
Neil Boothcd7ab832002-05-29 17:15:42 +0000601
Janis Johnson839a3b82009-04-01 17:31:26 +0000602 /* 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))
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000606 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
607 "suffix for double constant is a GCC extension");
Janis Johnson839a3b82009-04-01 17:31:26 +0000608
Jon Grimmad6ed772005-12-06 23:13:15 +0000609 /* Radix must be 10 for decimal floats. */
610 if ((result & CPP_N_DFLOAT) && radix != 10)
611 {
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000612 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
613 "invalid suffix \"%.*s\" with hexadecimal floating constant",
614 (int) (limit - str), str);
Jon Grimmad6ed772005-12-06 23:13:15 +0000615 return CPP_N_INVALID;
616 }
617
Chao-ying Fuac6b1c62007-08-30 23:05:17 +0000618 if ((result & (CPP_N_FRACT | CPP_N_ACCUM)) && CPP_PEDANTIC (pfile))
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000619 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
620 "fixed-point constants are a GCC extension");
Chao-ying Fuac6b1c62007-08-30 23:05:17 +0000621
Janis Johnson5a6bb572007-05-14 23:45:40 +0000622 if ((result & CPP_N_DFLOAT) && CPP_PEDANTIC (pfile))
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000623 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
624 "decimal float constants are a GCC extension");
Janis Johnson5a6bb572007-05-14 23:45:40 +0000625
Neil Boothcd7ab832002-05-29 17:15:42 +0000626 result |= CPP_N_FLOATING;
627 }
628 else
629 {
Ed Smith-Rowlanda4a00162012-11-10 00:08:49 +0000630 result = interpret_int_suffix (pfile, str, limit - str);
Neil Boothcd7ab832002-05-29 17:15:42 +0000631 if (result == 0)
632 {
Ed Smith-Rowland3ce4f9e2011-10-26 19:30:59 +0000633 if (CPP_OPTION (pfile, user_literals))
634 {
635 if (ud_suffix)
636 *ud_suffix = (const char *) str;
637 result = CPP_N_UNSIGNED | CPP_N_LARGE | CPP_N_USERDEF;
638 }
639 else
640 {
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000641 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
642 "invalid suffix \"%.*s\" on integer constant",
643 (int) (limit - str), str);
Ed Smith-Rowland3ce4f9e2011-10-26 19:30:59 +0000644 return CPP_N_INVALID;
645 }
Neil Boothcd7ab832002-05-29 17:15:42 +0000646 }
647
Zack Weinberg56da7202002-08-02 04:18:16 +0000648 /* 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))
651 {
652 int u_or_i = (result & (CPP_N_UNSIGNED|CPP_N_IMAGINARY));
Simon Baldwin87cf0652010-04-07 17:18:10 +0000653 int large = (result & CPP_N_WIDTH) == CPP_N_LARGE
Joseph Myerse3339d02010-09-29 15:49:14 +0100654 && CPP_OPTION (pfile, cpp_warn_long_long);
Zack Weinberg56da7202002-08-02 04:18:16 +0000655
Simon Baldwin87cf0652010-04-07 17:18:10 +0000656 if (u_or_i || large)
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000657 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);
Zack Weinberg56da7202002-08-02 04:18:16 +0000661 }
Neil Boothcd7ab832002-05-29 17:15:42 +0000662
663 if ((result & CPP_N_WIDTH) == CPP_N_LARGE
Joseph Myerse3339d02010-09-29 15:49:14 +0100664 && CPP_OPTION (pfile, cpp_warn_long_long))
Simon Baldwin87cf0652010-04-07 17:18:10 +0000665 {
666 const char *message = CPP_OPTION (pfile, cplusplus)
Jakub Jelinek01187df2013-04-28 23:36:57 +0200667 ? N_("use of C++11 long long integer constant")
Simon Baldwin87cf0652010-04-07 17:18:10 +0000668 : N_("use of C99 long long integer constant");
669
670 if (CPP_OPTION (pfile, c99))
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000671 cpp_warning_with_line (pfile, CPP_W_LONG_LONG, virtual_location,
672 0, message);
Simon Baldwin87cf0652010-04-07 17:18:10 +0000673 else
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000674 cpp_pedwarning_with_line (pfile, CPP_W_LONG_LONG,
675 virtual_location, 0, message);
Simon Baldwin87cf0652010-04-07 17:18:10 +0000676 }
Neil Boothcd7ab832002-05-29 17:15:42 +0000677
678 result |= CPP_N_INTEGER;
679 }
680
Chao-ying Fuac6b1c62007-08-30 23:05:17 +0000681 syntax_ok:
Neil Boothcd7ab832002-05-29 17:15:42 +0000682 if ((result & CPP_N_IMAGINARY) && CPP_PEDANTIC (pfile))
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000683 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
684 "imaginary constants are a GCC extension");
Jakub Jelinek01187df2013-04-28 23:36:57 +0200685 if (radix == 2
686 && !CPP_OPTION (pfile, binary_constants)
687 && CPP_PEDANTIC (pfile))
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000688 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
Jakub Jelinek01187df2013-04-28 23:36:57 +0200689 CPP_OPTION (pfile, cplusplus)
Edward Smith-Rowlande4276ba2014-08-23 16:50:22 +0000690 ? "binary constants are a C++14 feature "
Jakub Jelinek01187df2013-04-28 23:36:57 +0200691 "or GCC extension"
692 : "binary constants are a GCC extension");
Neil Boothcd7ab832002-05-29 17:15:42 +0000693
694 if (radix == 10)
695 result |= CPP_N_DECIMAL;
696 else if (radix == 16)
697 result |= CPP_N_HEX;
Joerg Wunschf7fd7752007-06-05 22:25:27 +0000698 else if (radix == 2)
699 result |= CPP_N_BINARY;
Neil Boothcd7ab832002-05-29 17:15:42 +0000700 else
701 result |= CPP_N_OCTAL;
702
703 return result;
704
705 syntax_error:
706 return CPP_N_INVALID;
707}
708
709/* cpp_interpret_integer converts an integer constant into a cpp_num,
710 of precision options->precision.
711
712 We do not provide any interface for decimal->float conversion,
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000713 because the preprocessor doesn't need it and we don't want to
714 drag in GCC's floating point emulator. */
Neil Boothcd7ab832002-05-29 17:15:42 +0000715cpp_num
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000716cpp_interpret_integer (cpp_reader *pfile, const cpp_token *token,
717 unsigned int type)
Neil Boothcd7ab832002-05-29 17:15:42 +0000718{
719 const uchar *p, *end;
720 cpp_num result;
721
722 result.low = 0;
723 result.high = 0;
Neil Booth23ff0222002-07-17 17:27:14 +0000724 result.unsignedp = !!(type & CPP_N_UNSIGNED);
725 result.overflow = false;
Neil Boothcd7ab832002-05-29 17:15:42 +0000726
727 p = token->val.str.text;
728 end = p + token->val.str.len;
729
730 /* Common case of a single digit. */
731 if (token->val.str.len == 1)
732 result.low = p[0] - '0';
733 else
734 {
735 cpp_num_part max;
736 size_t precision = CPP_OPTION (pfile, precision);
737 unsigned int base = 10, c = 0;
738 bool overflow = false;
739
740 if ((type & CPP_N_RADIX) == CPP_N_OCTAL)
741 {
742 base = 8;
743 p++;
744 }
745 else if ((type & CPP_N_RADIX) == CPP_N_HEX)
746 {
747 base = 16;
748 p += 2;
749 }
Joerg Wunschf7fd7752007-06-05 22:25:27 +0000750 else if ((type & CPP_N_RADIX) == CPP_N_BINARY)
751 {
752 base = 2;
753 p += 2;
754 }
Neil Boothcd7ab832002-05-29 17:15:42 +0000755
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;
762
763 for (; p < end; p++)
764 {
765 c = *p;
766
767 if (ISDIGIT (c) || (base == 16 && ISXDIGIT (c)))
768 c = hex_value (c);
Edward Smith-Rowland7057e642013-10-31 14:01:23 +0000769 else if (DIGIT_SEP (c))
770 continue;
Neil Boothcd7ab832002-05-29 17:15:42 +0000771 else
772 break;
773
774 /* Strict inequality for when max is set to zero. */
775 if (result.low < max)
776 result.low = result.low * base + c;
777 else
778 {
779 result = append_digit (result, c, base, precision);
780 overflow |= result.overflow;
781 max = 0;
782 }
783 }
784
Ed Smith-Rowland3ce4f9e2011-10-26 19:30:59 +0000785 if (overflow && !(type & CPP_N_USERDEF))
John David Anglin0527bc42003-11-01 22:56:54 +0000786 cpp_error (pfile, CPP_DL_PEDWARN,
Neil Boothcd7ab832002-05-29 17:15:42 +0000787 "integer constant is too large for its type");
Neil Booth017acb42002-06-20 20:34:19 +0000788 /* If too big to be signed, consider it unsigned. Only warn for
789 decimal numbers. Traditional numbers were always signed (but
Kazu Hirata8d9afc4e2002-09-16 11:42:00 +0000790 we still honor an explicit U suffix); but we only have
Neil Boothcd98faa2002-07-09 22:21:37 +0000791 traditional semantics in directives. */
Neil Booth017acb42002-06-20 20:34:19 +0000792 else if (!result.unsignedp
Neil Boothcd98faa2002-07-09 22:21:37 +0000793 && !(CPP_OPTION (pfile, traditional)
794 && pfile->state.in_directive)
Neil Booth017acb42002-06-20 20:34:19 +0000795 && !num_positive (result, precision))
Neil Boothcd7ab832002-05-29 17:15:42 +0000796 {
Joseph Myersf88d0772009-04-25 19:46:03 +0100797 /* This is for constants within the range of uintmax_t but
Joseph Myers813b9e72009-04-25 19:59:20 +0100798 not that of intmax_t. For such decimal constants, a
Joseph Myersf88d0772009-04-25 19:46:03 +0100799 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. */
Neil Boothcd7ab832002-05-29 17:15:42 +0000814 if (base == 10)
Joseph Myersf88d0772009-04-25 19:46:03 +0100815 cpp_error (pfile, (CPP_OPTION (pfile, c99)
816 ? CPP_DL_PEDWARN
817 : CPP_DL_WARNING),
Neil Boothcd7ab832002-05-29 17:15:42 +0000818 "integer constant is so large that it is unsigned");
Neil Booth23ff0222002-07-17 17:27:14 +0000819 result.unsignedp = true;
Neil Boothcd7ab832002-05-29 17:15:42 +0000820 }
821 }
822
823 return result;
824}
Zack Weinbergcf00a882000-07-08 02:33:00 +0000825
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000826/* Append DIGIT to NUM, a number of PRECISION bits being read in base BASE. */
Neil Booth91318902002-05-26 18:42:21 +0000827static cpp_num
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000828append_digit (cpp_num num, int digit, int base, size_t precision)
Neil Booth91318902002-05-26 18:42:21 +0000829{
830 cpp_num result;
Joerg Wunschf7fd7752007-06-05 22:25:27 +0000831 unsigned int shift;
Neil Booth91318902002-05-26 18:42:21 +0000832 bool overflow;
833 cpp_num_part add_high, add_low;
834
Joerg Wunschf7fd7752007-06-05 22:25:27 +0000835 /* Multiply by 2, 8 or 16. Catching this overflow here means we don't
Neil Booth91318902002-05-26 18:42:21 +0000836 need to worry about add_high overflowing. */
Joerg Wunschf7fd7752007-06-05 22:25:27 +0000837 switch (base)
838 {
839 case 2:
840 shift = 1;
841 break;
842
843 case 16:
844 shift = 4;
845 break;
846
847 default:
848 shift = 3;
849 }
Neil Booth23ff0222002-07-17 17:27:14 +0000850 overflow = !!(num.high >> (PART_PRECISION - shift));
Neil Booth91318902002-05-26 18:42:21 +0000851 result.high = num.high << shift;
852 result.low = num.low << shift;
853 result.high |= num.low >> (PART_PRECISION - shift);
Diego Novillo6de9cd92004-05-13 02:41:07 -0400854 result.unsignedp = num.unsignedp;
Neil Booth91318902002-05-26 18:42:21 +0000855
856 if (base == 10)
857 {
858 add_low = num.low << 1;
859 add_high = (num.high << 1) + (num.low >> (PART_PRECISION - 1));
860 }
861 else
862 add_high = add_low = 0;
863
864 if (add_low + digit < add_low)
865 add_high++;
866 add_low += digit;
Eric Christopher22a8a522007-05-02 21:57:50 +0000867
Neil Booth91318902002-05-26 18:42:21 +0000868 if (result.low + add_low < result.low)
869 add_high++;
870 if (result.high + add_high < result.high)
871 overflow = true;
872
873 result.low += add_low;
874 result.high += add_high;
Diego Novillo6de9cd92004-05-13 02:41:07 -0400875 result.overflow = overflow;
Neil Booth91318902002-05-26 18:42:21 +0000876
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))
Diego Novillo6de9cd92004-05-13 02:41:07 -0400883 result.overflow = true;
Neil Booth91318902002-05-26 18:42:21 +0000884
Neil Booth91318902002-05-26 18:42:21 +0000885 return result;
886}
887
Neil Booth5d8ebbd2002-01-03 21:43:09 +0000888/* Handle meeting "defined" in a preprocessor expression. */
Neil Booth91318902002-05-26 18:42:21 +0000889static cpp_num
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000890parse_defined (cpp_reader *pfile)
Zack Weinbergba412f12000-03-01 00:57:09 +0000891{
Neil Booth91318902002-05-26 18:42:21 +0000892 cpp_num result;
Neil Booth93c803682000-10-28 17:59:06 +0000893 int paren = 0;
894 cpp_hashnode *node = 0;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000895 const cpp_token *token;
Neil Booth63d75002001-11-05 22:26:13 +0000896 cpp_context *initial_context = pfile->context;
Zack Weinbergcf00a882000-07-08 02:33:00 +0000897
Neil Booth93c803682000-10-28 17:59:06 +0000898 /* Don't expand macros. */
899 pfile->state.prevent_expansion++;
900
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000901 token = cpp_get_token (pfile);
902 if (token->type == CPP_OPEN_PAREN)
Zack Weinbergcf00a882000-07-08 02:33:00 +0000903 {
904 paren = 1;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000905 token = cpp_get_token (pfile);
Zack Weinbergcf00a882000-07-08 02:33:00 +0000906 }
907
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000908 if (token->type == CPP_NAME)
Zack Weinberg041c3192000-07-04 01:58:21 +0000909 {
Joseph Myers9a0c6182009-05-10 15:27:32 +0100910 node = token->val.node.node;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000911 if (paren && cpp_get_token (pfile)->type != CPP_CLOSE_PAREN)
Neil Booth93c803682000-10-28 17:59:06 +0000912 {
John David Anglin0527bc42003-11-01 22:56:54 +0000913 cpp_error (pfile, CPP_DL_ERROR, "missing ')' after \"defined\"");
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000914 node = 0;
Neil Booth93c803682000-10-28 17:59:06 +0000915 }
Zack Weinberg041c3192000-07-04 01:58:21 +0000916 }
Neil Booth93c803682000-10-28 17:59:06 +0000917 else
Neil Booth3c8465d2001-02-06 20:07:07 +0000918 {
John David Anglin0527bc42003-11-01 22:56:54 +0000919 cpp_error (pfile, CPP_DL_ERROR,
Neil Boothebef4e82002-04-14 18:42:47 +0000920 "operator \"defined\" requires an identifier");
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000921 if (token->flags & NAMED_OP)
Neil Booth3c8465d2001-02-06 20:07:07 +0000922 {
923 cpp_token op;
924
925 op.flags = 0;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000926 op.type = token->type;
John David Anglin0527bc42003-11-01 22:56:54 +0000927 cpp_error (pfile, CPP_DL_ERROR,
Neil Booth3c8465d2001-02-06 20:07:07 +0000928 "(\"%s\" is an alternative token for \"%s\" in C++)",
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000929 cpp_token_as_text (pfile, token),
Neil Booth3c8465d2001-02-06 20:07:07 +0000930 cpp_token_as_text (pfile, &op));
931 }
932 }
Neil Booth93c803682000-10-28 17:59:06 +0000933
Neil Booth91318902002-05-26 18:42:21 +0000934 if (node)
Neil Booth93c803682000-10-28 17:59:06 +0000935 {
Neil Booth335d03e2003-08-03 12:23:46 +0000936 if (pfile->context != initial_context && CPP_PEDANTIC (pfile))
John David Anglin0527bc42003-11-01 22:56:54 +0000937 cpp_error (pfile, CPP_DL_WARNING,
Neil Boothebef4e82002-04-14 18:42:47 +0000938 "this use of \"defined\" may not be portable");
Neil Booth63d75002001-11-05 22:26:13 +0000939
Neil Bootha69cbaa2002-07-23 22:57:49 +0000940 _cpp_mark_macro_used (node);
Joseph Myers93d45d92008-04-02 20:42:53 +0100941 if (!(node->flags & NODE_USED))
942 {
943 node->flags |= NODE_USED;
944 if (node->type == NT_MACRO)
945 {
Jakub Jelineka69d2522010-09-01 00:47:25 +0200946 if ((node->flags & NODE_BUILTIN)
947 && pfile->cb.user_builtin_macro)
948 pfile->cb.user_builtin_macro (pfile, node);
Joseph Myers93d45d92008-04-02 20:42:53 +0100949 if (pfile->cb.used_define)
950 pfile->cb.used_define (pfile, pfile->directive_line, node);
951 }
952 else
953 {
954 if (pfile->cb.used_undef)
955 pfile->cb.used_undef (pfile, pfile->directive_line, node);
956 }
957 }
Neil Bootha69cbaa2002-07-23 22:57:49 +0000958
Neil Booth6d18adb2001-07-29 17:27:57 +0000959 /* 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;
Neil Booth93c803682000-10-28 17:59:06 +0000962 }
963
964 pfile->state.prevent_expansion--;
Neil Booth91318902002-05-26 18:42:21 +0000965
Michael Meissnerf3c33d92011-03-21 16:21:30 +0000966 /* 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. */
Neil Booth23ff0222002-07-17 17:27:14 +0000970 result.unsignedp = false;
Neil Booth91318902002-05-26 18:42:21 +0000971 result.high = 0;
Neil Booth23ff0222002-07-17 17:27:14 +0000972 result.overflow = false;
Michael Meissnerf3c33d92011-03-21 16:21:30 +0000973 result.low = (node && node->type == NT_MACRO
974 && (node->flags & NODE_CONDITIONAL) == 0);
Neil Booth91318902002-05-26 18:42:21 +0000975 return result;
Zack Weinberg15dad1d2000-05-18 15:55:46 +0000976}
977
Neil Booth60284a52002-04-28 23:14:56 +0000978/* Convert a token into a CPP_NUMBER (an interpreted preprocessing
979 number or character constant, or the result of the "defined" or "#"
Neil Boothcd7ab832002-05-29 17:15:42 +0000980 operators). */
Neil Booth91318902002-05-26 18:42:21 +0000981static cpp_num
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000982eval_token (cpp_reader *pfile, const cpp_token *token,
983 source_location virtual_location)
Per Bothner7f2935c1995-03-16 13:59:07 -0800984{
Neil Booth91318902002-05-26 18:42:21 +0000985 cpp_num result;
Neil Booth60284a52002-04-28 23:14:56 +0000986 unsigned int temp;
Neil Booth4268e8b2002-05-04 07:30:32 +0000987 int unsignedp = 0;
Zack Weinberg041c3192000-07-04 01:58:21 +0000988
Diego Novillo6de9cd92004-05-13 02:41:07 -0400989 result.unsignedp = false;
990 result.overflow = false;
991
Neil Booth93c803682000-10-28 17:59:06 +0000992 switch (token->type)
Zack Weinbergba412f12000-03-01 00:57:09 +0000993 {
Per Bothner7f2935c1995-03-16 13:59:07 -0800994 case CPP_NUMBER:
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +0000995 temp = cpp_classify_number (pfile, token, NULL, virtual_location);
Ed Smith-Rowland3ce4f9e2011-10-26 19:30:59 +0000996 if (temp & CPP_N_USERDEF)
997 cpp_error (pfile, CPP_DL_ERROR,
998 "user-defined literal in preprocessor expression");
Neil Boothcd7ab832002-05-29 17:15:42 +0000999 switch (temp & CPP_N_CATEGORY)
1000 {
1001 case CPP_N_FLOATING:
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +00001002 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
1003 "floating constant in preprocessor expression");
Neil Boothcd7ab832002-05-29 17:15:42 +00001004 break;
1005 case CPP_N_INTEGER:
1006 if (!(temp & CPP_N_IMAGINARY))
1007 return cpp_interpret_integer (pfile, token, temp);
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +00001008 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
1009 "imaginary number in preprocessor expression");
Neil Boothcd7ab832002-05-29 17:15:42 +00001010 break;
1011
1012 case CPP_N_INVALID:
1013 /* Error already issued. */
1014 break;
1015 }
1016 result.high = result.low = 0;
1017 break;
Neil Booth7f2f1a62000-11-14 18:32:06 +00001018
Alexandre Oliva525bc952000-02-23 19:21:07 +00001019 case CPP_WCHAR:
Neil Booth4268e8b2002-05-04 07:30:32 +00001020 case CPP_CHAR:
Kris Van Heesb6baa672008-04-18 13:58:08 +00001021 case CPP_CHAR16:
1022 case CPP_CHAR32:
Neil Bootha5a49442002-05-06 22:53:10 +00001023 {
Neil Booth91318902002-05-26 18:42:21 +00001024 cppchar_t cc = cpp_interpret_charconst (pfile, token,
1025 &temp, &unsignedp);
1026
1027 result.high = 0;
1028 result.low = cc;
Neil Bootha5a49442002-05-06 22:53:10 +00001029 /* Sign-extend the result if necessary. */
Neil Booth91318902002-05-26 18:42:21 +00001030 if (!unsignedp && (cppchar_signed_t) cc < 0)
1031 {
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));
1037 }
Neil Bootha5a49442002-05-06 22:53:10 +00001038 }
Neil Booth60284a52002-04-28 23:14:56 +00001039 break;
Zack Weinbergba412f12000-03-01 00:57:09 +00001040
Zack Weinberg92936ec2000-07-19 20:18:08 +00001041 case CPP_NAME:
Joseph Myers9a0c6182009-05-10 15:27:32 +01001042 if (token->val.node.node == pfile->spec_nodes.n_defined)
Neil Booth63d75002001-11-05 22:26:13 +00001043 return parse_defined (pfile);
Zack Weinberg7d4918a2001-02-07 18:32:42 +00001044 else if (CPP_OPTION (pfile, cplusplus)
Joseph Myers9a0c6182009-05-10 15:27:32 +01001045 && (token->val.node.node == pfile->spec_nodes.n_true
1046 || token->val.node.node == pfile->spec_nodes.n_false))
Zack Weinberg7d4918a2001-02-07 18:32:42 +00001047 {
Neil Booth91318902002-05-26 18:42:21 +00001048 result.high = 0;
Joseph Myers9a0c6182009-05-10 15:27:32 +01001049 result.low = (token->val.node.node == pfile->spec_nodes.n_true);
Zack Weinberg7d4918a2001-02-07 18:32:42 +00001050 }
1051 else
1052 {
Neil Booth91318902002-05-26 18:42:21 +00001053 result.high = 0;
1054 result.low = 0;
Neil Booth87ed1092002-04-28 19:42:54 +00001055 if (CPP_OPTION (pfile, warn_undef) && !pfile->state.skip_eval)
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +00001056 cpp_warning_with_line (pfile, CPP_W_UNDEF, virtual_location, 0,
1057 "\"%s\" is not defined",
1058 NODE_NAME (token->val.node.node));
Zack Weinberg7d4918a2001-02-07 18:32:42 +00001059 }
Neil Booth60284a52002-04-28 23:14:56 +00001060 break;
Zack Weinberg5dfa4da1999-02-08 20:27:27 +00001061
Tom Tromey899015a2008-05-13 14:50:27 +00001062 case CPP_HASH:
1063 if (!pfile->state.skipping)
1064 {
1065 /* A pedantic warning takes precedence over a deprecated
1066 warning here. */
1067 if (CPP_PEDANTIC (pfile))
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +00001068 cpp_error_with_line (pfile, CPP_DL_PEDWARN,
1069 virtual_location, 0,
1070 "assertions are a GCC extension");
Joseph Myerse3339d02010-09-29 15:49:14 +01001071 else if (CPP_OPTION (pfile, cpp_warn_deprecated))
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +00001072 cpp_warning_with_line (pfile, CPP_W_DEPRECATED, virtual_location, 0,
1073 "assertions are a deprecated extension");
Tom Tromey899015a2008-05-13 14:50:27 +00001074 }
Neil Booth91318902002-05-26 18:42:21 +00001075 _cpp_test_assertion (pfile, &temp);
1076 result.high = 0;
1077 result.low = temp;
Tom Tromey899015a2008-05-13 14:50:27 +00001078 break;
1079
1080 default:
1081 abort ();
Neil Booth93c803682000-10-28 17:59:06 +00001082 }
Per Bothner7f2935c1995-03-16 13:59:07 -08001083
Neil Booth23ff0222002-07-17 17:27:14 +00001084 result.unsignedp = !!unsignedp;
Neil Booth91318902002-05-26 18:42:21 +00001085 return result;
Per Bothner7f2935c1995-03-16 13:59:07 -08001086}
1087
Neil Booth4063b942000-04-02 08:27:23 +00001088/* Operator precedence and flags table.
Neil Boothdbac4af2000-04-01 07:48:59 +00001089
1090After an operator is returned from the lexer, if it has priority less
Neil Booth87ed1092002-04-28 19:42:54 +00001091than the operator on the top of the stack, we reduce the stack by one
1092operator and repeat the test. Since equal priorities do not reduce,
1093this is naturally right-associative.
Neil Boothdbac4af2000-04-01 07:48:59 +00001094
Neil Booth87ed1092002-04-28 19:42:54 +00001095We handle left-associative operators by decrementing the priority of
1096just-lexed operators by one, but retaining the priority of operators
1097already on the stack.
Neil Boothdbac4af2000-04-01 07:48:59 +00001098
1099The remaining cases are '(' and ')'. We handle '(' by skipping the
1100reduction phase completely. ')' is given lower priority than
1101everything else, including '(', effectively forcing a reduction of the
Kazu Hirata272d0be2002-12-19 05:18:13 +00001102parenthesized expression. If there is a matching '(', the routine
Neil Booth87ed1092002-04-28 19:42:54 +00001103reduce() exits immediately. If the normal exit route sees a ')', then
1104there cannot have been a matching '(' and an error message is output.
Neil Boothdbac4af2000-04-01 07:48:59 +00001105
Neil Boothf8b954f2002-04-26 06:32:50 +00001106The parser assumes all shifted operators require a left operand unless
1107the flag NO_L_OPERAND is set. These semantics are automatic; any
1108extra semantics need to be handled with operator-specific code. */
Per Bothner7f2935c1995-03-16 13:59:07 -08001109
Neil Booth68e652752002-07-20 13:31:56 +00001110/* Flags. If CHECK_PROMOTION, we warn if the effective sign of an
1111 operand changes because of integer promotions. */
Neil Booth87ed1092002-04-28 19:42:54 +00001112#define NO_L_OPERAND (1 << 0)
1113#define LEFT_ASSOC (1 << 1)
Neil Booth68e652752002-07-20 13:31:56 +00001114#define CHECK_PROMOTION (1 << 2)
Neil Bootheba30522000-03-31 22:23:59 +00001115
Zack Weinbergcf00a882000-07-08 02:33:00 +00001116/* Operator to priority map. Must be in the same order as the first
1117 N entries of enum cpp_ttype. */
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +00001118static const struct cpp_operator
Zack Weinbergcf00a882000-07-08 02:33:00 +00001119{
Neil Booth60284a52002-04-28 23:14:56 +00001120 uchar prio;
Neil Booth87ed1092002-04-28 19:42:54 +00001121 uchar flags;
1122} optab[] =
1123{
Neil Boothad28cff2002-07-18 22:08:35 +00001124 /* EQ */ {0, 0}, /* Shouldn't happen. */
1125 /* NOT */ {16, NO_L_OPERAND},
Neil Booth68e652752002-07-20 13:31:56 +00001126 /* 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},
Neil Boothad28cff2002-07-18 22:08:35 +00001136 /* RSHIFT */ {13, LEFT_ASSOC},
1137 /* LSHIFT */ {13, LEFT_ASSOC},
Zack Weinbergcf00a882000-07-08 02:33:00 +00001138
Neil Boothad28cff2002-07-18 22:08:35 +00001139 /* COMPL */ {16, NO_L_OPERAND},
Neil Booth75aef482002-07-19 19:24:43 +00001140 /* AND_AND */ {6, LEFT_ASSOC},
1141 /* OR_OR */ {5, LEFT_ASSOC},
Tom Tromey71c10032008-05-06 17:15:07 +00001142 /* 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},
Neil Booth68e652752002-07-20 13:31:56 +00001145 /* COLON */ {4, LEFT_ASSOC | CHECK_PROMOTION},
Tom Tromey71c10032008-05-06 17:15:07 +00001146 /* COMMA */ {4, LEFT_ASSOC},
Neil Booth75aef482002-07-19 19:24:43 +00001147 /* OPEN_PAREN */ {1, NO_L_OPERAND},
Neil Boothad28cff2002-07-18 22:08:35 +00001148 /* CLOSE_PAREN */ {0, 0},
1149 /* EOF */ {0, 0},
1150 /* EQ_EQ */ {11, LEFT_ASSOC},
1151 /* NOT_EQ */ {11, LEFT_ASSOC},
Neil Booth68e652752002-07-20 13:31:56 +00001152 /* GREATER_EQ */ {12, LEFT_ASSOC | CHECK_PROMOTION},
1153 /* LESS_EQ */ {12, LEFT_ASSOC | CHECK_PROMOTION},
Neil Boothad28cff2002-07-18 22:08:35 +00001154 /* UPLUS */ {16, NO_L_OPERAND},
1155 /* UMINUS */ {16, NO_L_OPERAND}
Zack Weinbergcf00a882000-07-08 02:33:00 +00001156};
1157
Per Bothner7f2935c1995-03-16 13:59:07 -08001158/* Parse and evaluate a C expression, reading from PFILE.
Kazu Hiratadf383482002-05-22 22:02:16 +00001159 Returns the truth value of the expression.
Neil Booth87ed1092002-04-28 19:42:54 +00001160
1161 The implementation is an operator precedence parser, i.e. a
1162 bottom-up parser, using a stack for not-yet-reduced tokens.
1163
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. */
1169bool
Tom Tromeyd7508872008-05-30 14:25:09 +00001170_cpp_parse_expr (cpp_reader *pfile, bool is_if)
Per Bothner7f2935c1995-03-16 13:59:07 -08001171{
Neil Booth87ed1092002-04-28 19:42:54 +00001172 struct op *top = pfile->op_stack;
1173 unsigned int lex_count;
1174 bool saw_leading_not, want_value = true;
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +00001175 source_location virtual_location = 0;
Per Bothner7f2935c1995-03-16 13:59:07 -08001176
Neil Booth87ed1092002-04-28 19:42:54 +00001177 pfile->state.skip_eval = 0;
Per Bothner7f2935c1995-03-16 13:59:07 -08001178
Neil Booth93c803682000-10-28 17:59:06 +00001179 /* Set up detection of #if ! defined(). */
Neil Booth6d18adb2001-07-29 17:27:57 +00001180 pfile->mi_ind_cmacro = 0;
Neil Booth87ed1092002-04-28 19:42:54 +00001181 saw_leading_not = false;
Neil Booth6d18adb2001-07-29 17:27:57 +00001182 lex_count = 0;
Neil Booth93c803682000-10-28 17:59:06 +00001183
Neil Booth87ed1092002-04-28 19:42:54 +00001184 /* Lowest priority operator prevents further reductions. */
Zack Weinbergcf00a882000-07-08 02:33:00 +00001185 top->op = CPP_EOF;
Neil Booth4063b942000-04-02 08:27:23 +00001186
Per Bothner7f2935c1995-03-16 13:59:07 -08001187 for (;;)
1188 {
Zack Weinbergcf00a882000-07-08 02:33:00 +00001189 struct op op;
Per Bothner7f2935c1995-03-16 13:59:07 -08001190
Neil Booth6d18adb2001-07-29 17:27:57 +00001191 lex_count++;
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +00001192 op.token = cpp_get_token_with_location (pfile, &virtual_location);
Neil Booth68e652752002-07-20 13:31:56 +00001193 op.op = op.token->type;
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +00001194 op.loc = virtual_location;
Per Bothner7f2935c1995-03-16 13:59:07 -08001195
Per Bothner7f2935c1995-03-16 13:59:07 -08001196 switch (op.op)
1197 {
Neil Booth60284a52002-04-28 23:14:56 +00001198 /* These tokens convert into values. */
Neil Boothc60e94a2001-07-19 06:12:50 +00001199 case CPP_NUMBER:
Neil Booth60284a52002-04-28 23:14:56 +00001200 case CPP_CHAR:
1201 case CPP_WCHAR:
Kris Van Heesb6baa672008-04-18 13:58:08 +00001202 case CPP_CHAR16:
1203 case CPP_CHAR32:
Neil Booth60284a52002-04-28 23:14:56 +00001204 case CPP_NAME:
1205 case CPP_HASH:
Neil Boothf8b954f2002-04-26 06:32:50 +00001206 if (!want_value)
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +00001207 SYNTAX_ERROR2_AT (op.loc,
1208 "missing binary operator before token \"%s\"",
1209 cpp_token_as_text (pfile, op.token));
Neil Boothf8b954f2002-04-26 06:32:50 +00001210 want_value = false;
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +00001211 top->value = eval_token (pfile, op.token, op.loc);
Neil Booth9ee703132000-04-01 07:42:37 +00001212 continue;
1213
Neil Booth6d18adb2001-07-29 17:27:57 +00001214 case CPP_NOT:
1215 saw_leading_not = lex_count == 1;
Neil Booth6d18adb2001-07-29 17:27:57 +00001216 break;
Zack Weinbergcf00a882000-07-08 02:33:00 +00001217 case CPP_PLUS:
Neil Boothf8b954f2002-04-26 06:32:50 +00001218 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;
Neil Booth60284a52002-04-28 23:14:56 +00001225
Neil Boothf8b954f2002-04-26 06:32:50 +00001226 default:
Neil Booth60284a52002-04-28 23:14:56 +00001227 if ((int) op.op <= (int) CPP_EQ || (int) op.op >= (int) CPP_PLUS_EQ)
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +00001228 SYNTAX_ERROR2_AT (op.loc,
1229 "token \"%s\" is not valid in preprocessor expressions",
1230 cpp_token_as_text (pfile, op.token));
Neil Boothf8b954f2002-04-26 06:32:50 +00001231 break;
Per Bothner7f2935c1995-03-16 13:59:07 -08001232 }
1233
Neil Booth87ed1092002-04-28 19:42:54 +00001234 /* Check we have a value or operator as appropriate. */
1235 if (optab[op.op].flags & NO_L_OPERAND)
Neil Booth4063b942000-04-02 08:27:23 +00001236 {
Neil Boothf8b954f2002-04-26 06:32:50 +00001237 if (!want_value)
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +00001238 SYNTAX_ERROR2_AT (op.loc,
1239 "missing binary operator before token \"%s\"",
1240 cpp_token_as_text (pfile, op.token));
Neil Boothb22ef132000-04-03 22:33:12 +00001241 }
Neil Booth87ed1092002-04-28 19:42:54 +00001242 else if (want_value)
Neil Boothb22ef132000-04-03 22:33:12 +00001243 {
Neil Bootha09d4742004-07-04 12:57:50 +00001244 /* 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)
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +00001247 SYNTAX_ERROR_AT (op.loc,
1248 "missing expression between '(' and ')'");
Neil Bootha09d4742004-07-04 12:57:50 +00001249
1250 if (op.op == CPP_EOF && top->op == CPP_EOF)
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +00001251 SYNTAX_ERROR2_AT (op.loc,
1252 "%s with no expression", is_if ? "#if" : "#elif");
Neil Bootha09d4742004-07-04 12:57:50 +00001253
1254 if (top->op != CPP_EOF && top->op != CPP_OPEN_PAREN)
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +00001255 SYNTAX_ERROR2_AT (op.loc,
1256 "operator '%s' has no right operand",
1257 cpp_token_as_text (pfile, top->token));
Neil Bootha09d4742004-07-04 12:57:50 +00001258 else if (op.op == CPP_CLOSE_PAREN || op.op == CPP_EOF)
1259 /* Complain about missing paren during reduction. */;
1260 else
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +00001261 SYNTAX_ERROR2_AT (op.loc,
1262 "operator '%s' has no left operand",
1263 cpp_token_as_text (pfile, op.token));
Neil Booth4063b942000-04-02 08:27:23 +00001264 }
Neil Booth87ed1092002-04-28 19:42:54 +00001265
1266 top = reduce (pfile, top, op.op);
1267 if (!top)
1268 goto syntax_error;
1269
Neil Booth60284a52002-04-28 23:14:56 +00001270 if (op.op == CPP_EOF)
1271 break;
1272
Neil Booth87ed1092002-04-28 19:42:54 +00001273 switch (op.op)
1274 {
1275 case CPP_CLOSE_PAREN:
1276 continue;
Neil Booth87ed1092002-04-28 19:42:54 +00001277 case CPP_OR_OR:
Neil Booth91318902002-05-26 18:42:21 +00001278 if (!num_zerop (top->value))
Neil Booth87ed1092002-04-28 19:42:54 +00001279 pfile->state.skip_eval++;
1280 break;
1281 case CPP_AND_AND:
1282 case CPP_QUERY:
Neil Booth91318902002-05-26 18:42:21 +00001283 if (num_zerop (top->value))
Neil Booth87ed1092002-04-28 19:42:54 +00001284 pfile->state.skip_eval++;
1285 break;
1286 case CPP_COLON:
Neil Booth60284a52002-04-28 23:14:56 +00001287 if (top->op != CPP_QUERY)
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +00001288 SYNTAX_ERROR_AT (op.loc,
1289 " ':' without preceding '?'");
Neil Booth91318902002-05-26 18:42:21 +00001290 if (!num_zerop (top[-1].value)) /* Was '?' condition true? */
Neil Booth87ed1092002-04-28 19:42:54 +00001291 pfile->state.skip_eval++;
1292 else
1293 pfile->state.skip_eval--;
1294 default:
1295 break;
1296 }
1297
Neil Boothf8b954f2002-04-26 06:32:50 +00001298 want_value = true;
Neil Booth4063b942000-04-02 08:27:23 +00001299
Mike Stump0f413021996-07-03 22:07:53 +00001300 /* Check for and handle stack overflow. */
Neil Booth87ed1092002-04-28 19:42:54 +00001301 if (++top == pfile->op_limit)
1302 top = _cpp_expand_op_stack (pfile);
Kazu Hiratadf383482002-05-22 22:02:16 +00001303
Per Bothner7f2935c1995-03-16 13:59:07 -08001304 top->op = op.op;
Neil Booth68e652752002-07-20 13:31:56 +00001305 top->token = op.token;
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +00001306 top->loc = op.loc;
Per Bothner7f2935c1995-03-16 13:59:07 -08001307 }
Neil Booth9ee703132000-04-01 07:42:37 +00001308
Neil Booth6d18adb2001-07-29 17:27:57 +00001309 /* 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;
1314
Neil Booth87ed1092002-04-28 19:42:54 +00001315 if (top != pfile->op_stack)
Neil Boothebef4e82002-04-14 18:42:47 +00001316 {
Dodji Seketeli0b2c4be2012-05-16 10:51:15 +00001317 cpp_error_with_line (pfile, CPP_DL_ICE, top->loc, 0,
1318 "unbalanced stack in %s",
1319 is_if ? "#if" : "#elif");
Neil Booth4063b942000-04-02 08:27:23 +00001320 syntax_error:
Neil Booth87ed1092002-04-28 19:42:54 +00001321 return false; /* Return false on syntax error. */
Neil Booth4063b942000-04-02 08:27:23 +00001322 }
Neil Booth9ee703132000-04-01 07:42:37 +00001323
Neil Booth91318902002-05-26 18:42:21 +00001324 return !num_zerop (top->value);
Neil Booth87ed1092002-04-28 19:42:54 +00001325}
1326
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. */
1330static struct op *
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001331reduce (cpp_reader *pfile, struct op *top, enum cpp_ttype op)
Neil Booth87ed1092002-04-28 19:42:54 +00001332{
1333 unsigned int prio;
1334
Neil Booth91318902002-05-26 18:42:21 +00001335 if (top->op <= CPP_EQ || top->op > CPP_LAST_CPP_OP + 2)
1336 {
1337 bad_op:
John David Anglin0527bc42003-11-01 22:56:54 +00001338 cpp_error (pfile, CPP_DL_ICE, "impossible operator '%u'", top->op);
Neil Booth91318902002-05-26 18:42:21 +00001339 return 0;
1340 }
1341
Neil Booth87ed1092002-04-28 19:42:54 +00001342 if (op == CPP_OPEN_PAREN)
1343 return top;
1344
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)
1349 {
Neil Booth68e652752002-07-20 13:31:56 +00001350 if (CPP_OPTION (pfile, warn_num_sign_change)
1351 && optab[top->op].flags & CHECK_PROMOTION)
1352 check_promotion (pfile, top);
1353
Neil Booth75aef482002-07-19 19:24:43 +00001354 switch (top->op)
1355 {
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);
Manuel López-Ibáñez47960aa2008-10-31 22:00:37 +00001361 top[-1].loc = top->loc;
Neil Booth75aef482002-07-19 19:24:43 +00001362 break;
Neil Booth91318902002-05-26 18:42:21 +00001363
Neil Booth75aef482002-07-19 19:24:43 +00001364 case CPP_PLUS:
1365 case CPP_MINUS:
1366 case CPP_RSHIFT:
1367 case CPP_LSHIFT:
Neil Booth75aef482002-07-19 19:24:43 +00001368 case CPP_COMMA:
1369 top[-1].value = num_binary_op (pfile, top[-1].value,
1370 top->value, top->op);
Manuel López-Ibáñez47960aa2008-10-31 22:00:37 +00001371 top[-1].loc = top->loc;
Neil Booth75aef482002-07-19 19:24:43 +00001372 break;
Neil Booth91318902002-05-26 18:42:21 +00001373
Neil Booth75aef482002-07-19 19:24:43 +00001374 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);
Manuel López-Ibáñez47960aa2008-10-31 22:00:37 +00001380 top[-1].loc = top->loc;
Neil Booth75aef482002-07-19 19:24:43 +00001381 break;
Neil Booth91318902002-05-26 18:42:21 +00001382
Neil Booth75aef482002-07-19 19:24:43 +00001383 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);
Manuel López-Ibáñez47960aa2008-10-31 22:00:37 +00001387 top[-1].loc = top->loc;
Neil Booth75aef482002-07-19 19:24:43 +00001388 break;
Neil Boothad28cff2002-07-18 22:08:35 +00001389
Neil Booth75aef482002-07-19 19:24:43 +00001390 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);
Manuel López-Ibáñez47960aa2008-10-31 22:00:37 +00001395 top[-1].loc = top->loc;
Neil Booth75aef482002-07-19 19:24:43 +00001396 break;
Neil Boothad28cff2002-07-18 22:08:35 +00001397
Neil Booth75aef482002-07-19 19:24:43 +00001398 case CPP_MULT:
1399 top[-1].value = num_mul (pfile, top[-1].value, top->value);
Manuel López-Ibáñez47960aa2008-10-31 22:00:37 +00001400 top[-1].loc = top->loc;
Neil Booth75aef482002-07-19 19:24:43 +00001401 break;
Neil Boothad28cff2002-07-18 22:08:35 +00001402
Neil Booth75aef482002-07-19 19:24:43 +00001403 case CPP_DIV:
1404 case CPP_MOD:
1405 top[-1].value = num_div_op (pfile, top[-1].value,
Manuel López-Ibáñezb506a5a2009-06-18 15:10:23 +00001406 top->value, top->op, top->loc);
Manuel López-Ibáñez47960aa2008-10-31 22:00:37 +00001407 top[-1].loc = top->loc;
Neil Booth75aef482002-07-19 19:24:43 +00001408 break;
Neil Boothad28cff2002-07-18 22:08:35 +00001409
Neil Booth75aef482002-07-19 19:24:43 +00001410 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;
Manuel López-Ibáñez47960aa2008-10-31 22:00:37 +00001419 top->loc = top[1].loc;
Neil Booth75aef482002-07-19 19:24:43 +00001420 continue;
1421
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;
Manuel López-Ibáñez47960aa2008-10-31 22:00:37 +00001431 top->loc = top[1].loc;
Neil Booth75aef482002-07-19 19:24:43 +00001432 continue;
1433
1434 case CPP_OPEN_PAREN:
1435 if (op != CPP_CLOSE_PAREN)
1436 {
Manuel López-Ibáñez47960aa2008-10-31 22:00:37 +00001437 cpp_error_with_line (pfile, CPP_DL_ERROR,
1438 top->token->src_loc,
1439 0, "missing ')' in expression");
Neil Booth75aef482002-07-19 19:24:43 +00001440 return 0;
1441 }
1442 top--;
1443 top->value = top[1].value;
Manuel López-Ibáñez47960aa2008-10-31 22:00:37 +00001444 top->loc = top[1].loc;
Neil Booth75aef482002-07-19 19:24:43 +00001445 return top;
1446
1447 case CPP_COLON:
1448 top -= 2;
1449 if (!num_zerop (top->value))
1450 {
Neil Booth91318902002-05-26 18:42:21 +00001451 pfile->state.skip_eval--;
Neil Booth75aef482002-07-19 19:24:43 +00001452 top->value = top[1].value;
Manuel López-Ibáñez47960aa2008-10-31 22:00:37 +00001453 top->loc = top[1].loc;
Neil Booth75aef482002-07-19 19:24:43 +00001454 }
1455 else
Manuel López-Ibáñez47960aa2008-10-31 22:00:37 +00001456 {
1457 top->value = top[2].value;
1458 top->loc = top[2].loc;
1459 }
Neil Booth75aef482002-07-19 19:24:43 +00001460 top->value.unsignedp = (top[1].value.unsignedp
1461 || top[2].value.unsignedp);
1462 continue;
Neil Booth91318902002-05-26 18:42:21 +00001463
Neil Booth75aef482002-07-19 19:24:43 +00001464 case CPP_QUERY:
Tom Tromey71c10032008-05-06 17:15:07 +00001465 /* COMMA and COLON should not reduce a QUERY operator. */
1466 if (op == CPP_COMMA || op == CPP_COLON)
1467 return top;
John David Anglin0527bc42003-11-01 22:56:54 +00001468 cpp_error (pfile, CPP_DL_ERROR, "'?' without following ':'");
Neil Booth75aef482002-07-19 19:24:43 +00001469 return 0;
Neil Booth91318902002-05-26 18:42:21 +00001470
Neil Booth75aef482002-07-19 19:24:43 +00001471 default:
1472 goto bad_op;
1473 }
Neil Boothad28cff2002-07-18 22:08:35 +00001474
1475 top--;
Neil Booth91318902002-05-26 18:42:21 +00001476 if (top->value.overflow && !pfile->state.skip_eval)
John David Anglin0527bc42003-11-01 22:56:54 +00001477 cpp_error (pfile, CPP_DL_PEDWARN,
Neil Booth91318902002-05-26 18:42:21 +00001478 "integer overflow in preprocessor expression");
Neil Booth87ed1092002-04-28 19:42:54 +00001479 }
1480
1481 if (op == CPP_CLOSE_PAREN)
1482 {
John David Anglin0527bc42003-11-01 22:56:54 +00001483 cpp_error (pfile, CPP_DL_ERROR, "missing '(' in expression");
Neil Booth87ed1092002-04-28 19:42:54 +00001484 return 0;
1485 }
1486
1487 return top;
1488}
1489
1490/* Returns the position of the old top of stack after expansion. */
1491struct op *
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001492_cpp_expand_op_stack (cpp_reader *pfile)
Neil Booth87ed1092002-04-28 19:42:54 +00001493{
Neil Booth32fa4562002-05-09 22:27:31 +00001494 size_t old_size = (size_t) (pfile->op_limit - pfile->op_stack);
1495 size_t new_size = old_size * 2 + 20;
Neil Booth87ed1092002-04-28 19:42:54 +00001496
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +00001497 pfile->op_stack = XRESIZEVEC (struct op, pfile->op_stack, new_size);
Neil Booth32fa4562002-05-09 22:27:31 +00001498 pfile->op_limit = pfile->op_stack + new_size;
Neil Booth87ed1092002-04-28 19:42:54 +00001499
Neil Booth32fa4562002-05-09 22:27:31 +00001500 return pfile->op_stack + old_size;
Per Bothner7f2935c1995-03-16 13:59:07 -08001501}
Neil Booth91318902002-05-26 18:42:21 +00001502
Neil Booth68e652752002-07-20 13:31:56 +00001503/* Emits a warning if the effective sign of either operand of OP
1504 changes because of integer promotions. */
1505static void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001506check_promotion (cpp_reader *pfile, const struct op *op)
Neil Booth68e652752002-07-20 13:31:56 +00001507{
1508 if (op->value.unsignedp == op[-1].value.unsignedp)
1509 return;
1510
1511 if (op->value.unsignedp)
1512 {
1513 if (!num_positive (op[-1].value, CPP_OPTION (pfile, precision)))
Manuel López-Ibáñez47960aa2008-10-31 22:00:37 +00001514 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));
Neil Booth68e652752002-07-20 13:31:56 +00001517 }
1518 else if (!num_positive (op->value, CPP_OPTION (pfile, precision)))
Manuel López-Ibáñez47960aa2008-10-31 22:00:37 +00001519 cpp_error_with_line (pfile, CPP_DL_WARNING, op->loc, 0,
Neil Booth68e652752002-07-20 13:31:56 +00001520 "the right operand of \"%s\" changes sign when promoted",
1521 cpp_token_as_text (pfile, op->token));
1522}
1523
Neil Booth91318902002-05-26 18:42:21 +00001524/* Clears the unused high order bits of the number pointed to by PNUM. */
1525static cpp_num
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001526num_trim (cpp_num num, size_t precision)
Neil Booth91318902002-05-26 18:42:21 +00001527{
1528 if (precision > PART_PRECISION)
1529 {
1530 precision -= PART_PRECISION;
1531 if (precision < PART_PRECISION)
Neil Booth359b0be2002-05-28 05:44:06 +00001532 num.high &= ((cpp_num_part) 1 << precision) - 1;
Neil Booth91318902002-05-26 18:42:21 +00001533 }
1534 else
1535 {
1536 if (precision < PART_PRECISION)
Neil Booth359b0be2002-05-28 05:44:06 +00001537 num.low &= ((cpp_num_part) 1 << precision) - 1;
Neil Booth91318902002-05-26 18:42:21 +00001538 num.high = 0;
1539 }
1540
1541 return num;
1542}
1543
1544/* True iff A (presumed signed) >= 0. */
1545static bool
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001546num_positive (cpp_num num, size_t precision)
Neil Booth91318902002-05-26 18:42:21 +00001547{
1548 if (precision > PART_PRECISION)
1549 {
1550 precision -= PART_PRECISION;
Neil Booth359b0be2002-05-28 05:44:06 +00001551 return (num.high & (cpp_num_part) 1 << (precision - 1)) == 0;
Neil Booth91318902002-05-26 18:42:21 +00001552 }
1553
Neil Booth359b0be2002-05-28 05:44:06 +00001554 return (num.low & (cpp_num_part) 1 << (precision - 1)) == 0;
Neil Booth91318902002-05-26 18:42:21 +00001555}
1556
Neil Boothceeedfc2002-06-02 19:37:34 +00001557/* Sign extend a number, with PRECISION significant bits and all
1558 others assumed clear, to fill out a cpp_num structure. */
1559cpp_num
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001560cpp_num_sign_extend (cpp_num num, size_t precision)
Neil Boothceeedfc2002-06-02 19:37:34 +00001561{
1562 if (!num.unsignedp)
1563 {
1564 if (precision > PART_PRECISION)
1565 {
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));
1570 }
1571 else if (num.low & (cpp_num_part) 1 << (precision - 1))
1572 {
1573 if (precision < PART_PRECISION)
1574 num.low |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1575 num.high = ~(cpp_num_part) 0;
1576 }
1577 }
1578
1579 return num;
1580}
1581
Neil Booth91318902002-05-26 18:42:21 +00001582/* Returns the negative of NUM. */
1583static cpp_num
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001584num_negate (cpp_num num, size_t precision)
Neil Booth91318902002-05-26 18:42:21 +00001585{
1586 cpp_num copy;
1587
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));
1595
1596 return num;
1597}
1598
1599/* Returns true if A >= B. */
1600static bool
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001601num_greater_eq (cpp_num pa, cpp_num pb, size_t precision)
Neil Booth91318902002-05-26 18:42:21 +00001602{
1603 bool unsignedp;
1604
1605 unsignedp = pa.unsignedp || pb.unsignedp;
1606
1607 if (!unsignedp)
1608 {
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);
1612
1613 if (unsignedp != num_positive (pb, precision))
1614 return unsignedp;
1615
1616 /* Otherwise we can do an unsigned comparison. */
1617 }
1618
1619 return (pa.high > pb.high) || (pa.high == pb.high && pa.low >= pb.low);
1620}
1621
1622/* Returns LHS OP RHS, where OP is a bit-wise operation. */
1623static cpp_num
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001624num_bitwise_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1625 cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
Neil Booth91318902002-05-26 18:42:21 +00001626{
1627 lhs.overflow = false;
1628 lhs.unsignedp = lhs.unsignedp || rhs.unsignedp;
1629
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)
1633 {
1634 lhs.low &= rhs.low;
1635 lhs.high &= rhs.high;
1636 }
1637 else if (op == CPP_OR)
1638 {
1639 lhs.low |= rhs.low;
1640 lhs.high |= rhs.high;
1641 }
1642 else
1643 {
1644 lhs.low ^= rhs.low;
1645 lhs.high ^= rhs.high;
1646 }
1647
1648 return lhs;
1649}
1650
1651/* Returns LHS OP RHS, where OP is an inequality. */
1652static cpp_num
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001653num_inequality_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs,
1654 enum cpp_ttype op)
Neil Booth91318902002-05-26 18:42:21 +00001655{
1656 bool gte = num_greater_eq (lhs, rhs, CPP_OPTION (pfile, precision));
1657
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);
1666
1667 lhs.high = 0;
1668 lhs.overflow = false;
1669 lhs.unsignedp = false;
1670 return lhs;
1671}
1672
1673/* Returns LHS OP RHS, where OP is == or !=. */
1674static cpp_num
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001675num_equality_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1676 cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
Neil Booth91318902002-05-26 18:42:21 +00001677{
Jason Merrill97459792002-06-07 09:29:17 -04001678 /* Work around a 3.0.4 bug; see PR 6950. */
1679 bool eq = num_eq (lhs, rhs);
Neil Booth91318902002-05-26 18:42:21 +00001680 if (op == CPP_NOT_EQ)
Jason Merrill97459792002-06-07 09:29:17 -04001681 eq = !eq;
1682 lhs.low = eq;
Neil Booth91318902002-05-26 18:42:21 +00001683 lhs.high = 0;
1684 lhs.overflow = false;
1685 lhs.unsignedp = false;
1686 return lhs;
1687}
1688
1689/* Shift NUM, of width PRECISION, right by N bits. */
1690static cpp_num
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001691num_rshift (cpp_num num, size_t precision, size_t n)
Neil Booth91318902002-05-26 18:42:21 +00001692{
1693 cpp_num_part sign_mask;
Diego Novillo6de9cd92004-05-13 02:41:07 -04001694 bool x = num_positive (num, precision);
Neil Booth91318902002-05-26 18:42:21 +00001695
Diego Novillo6de9cd92004-05-13 02:41:07 -04001696 if (num.unsignedp || x)
Neil Booth91318902002-05-26 18:42:21 +00001697 sign_mask = 0;
1698 else
1699 sign_mask = ~(cpp_num_part) 0;
1700
1701 if (n >= precision)
1702 num.high = num.low = sign_mask;
1703 else
1704 {
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);
1710
1711 if (n >= PART_PRECISION)
1712 {
1713 n -= PART_PRECISION;
1714 num.low = num.high;
1715 num.high = sign_mask;
1716 }
1717
1718 if (n)
1719 {
1720 num.low = (num.low >> n) | (num.high << (PART_PRECISION - n));
1721 num.high = (num.high >> n) | (sign_mask << (PART_PRECISION - n));
1722 }
1723 }
1724
1725 num = num_trim (num, precision);
1726 num.overflow = false;
1727 return num;
1728}
1729
1730/* Shift NUM, of width PRECISION, left by N bits. */
1731static cpp_num
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001732num_lshift (cpp_num num, size_t precision, size_t n)
Neil Booth91318902002-05-26 18:42:21 +00001733{
1734 if (n >= precision)
1735 {
1736 num.overflow = !num.unsignedp && !num_zerop (num);
1737 num.high = num.low = 0;
1738 }
1739 else
1740 {
1741 cpp_num orig, maybe_orig;
1742 size_t m = n;
1743
1744 orig = num;
1745 if (m >= PART_PRECISION)
1746 {
1747 m -= PART_PRECISION;
1748 num.high = num.low;
1749 num.low = 0;
1750 }
1751 if (m)
1752 {
1753 num.high = (num.high << m) | (num.low >> (PART_PRECISION - m));
1754 num.low <<= m;
1755 }
1756 num = num_trim (num, precision);
1757
1758 if (num.unsignedp)
1759 num.overflow = false;
1760 else
1761 {
1762 maybe_orig = num_rshift (num, precision, n);
1763 num.overflow = !num_eq (orig, maybe_orig);
1764 }
1765 }
1766
1767 return num;
1768}
1769
1770/* The four unary operators: +, -, ! and ~. */
1771static cpp_num
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001772num_unary_op (cpp_reader *pfile, cpp_num num, enum cpp_ttype op)
Neil Booth91318902002-05-26 18:42:21 +00001773{
1774 switch (op)
1775 {
1776 case CPP_UPLUS:
Neil Booth75aef482002-07-19 19:24:43 +00001777 if (CPP_WTRADITIONAL (pfile) && !pfile->state.skip_eval)
Simon Baldwin87cf0652010-04-07 17:18:10 +00001778 cpp_warning (pfile, CPP_W_TRADITIONAL,
1779 "traditional C rejects the unary plus operator");
Neil Booth91318902002-05-26 18:42:21 +00001780 num.overflow = false;
1781 break;
1782
1783 case CPP_UMINUS:
1784 num = num_negate (num, CPP_OPTION (pfile, precision));
1785 break;
1786
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;
1793
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;
1800 }
1801
1802 return num;
1803}
1804
1805/* The various binary operators. */
1806static cpp_num
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001807num_binary_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
Neil Booth91318902002-05-26 18:42:21 +00001808{
1809 cpp_num result;
1810 size_t precision = CPP_OPTION (pfile, precision);
Neil Booth91318902002-05-26 18:42:21 +00001811 size_t n;
1812
1813 switch (op)
1814 {
1815 /* Shifts. */
1816 case CPP_LSHIFT:
1817 case CPP_RSHIFT:
1818 if (!rhs.unsignedp && !num_positive (rhs, precision))
1819 {
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);
1826 }
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;
1836
Neil Booth91318902002-05-26 18:42:21 +00001837 /* Arithmetic. */
1838 case CPP_MINUS:
Joseph Myers3a4efce2013-12-10 01:23:37 +00001839 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;
1845
1846 result = num_trim (result, precision);
1847 if (!result.unsignedp)
1848 {
1849 bool lhsp = num_positive (lhs, precision);
1850 result.overflow = (lhsp != num_positive (rhs, precision)
1851 && lhsp != num_positive (result, precision));
1852 }
1853 return result;
1854
Neil Booth91318902002-05-26 18:42:21 +00001855 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++;
Diego Novillo6de9cd92004-05-13 02:41:07 -04001860 result.unsignedp = lhs.unsignedp || rhs.unsignedp;
1861 result.overflow = false;
Neil Booth91318902002-05-26 18:42:21 +00001862
1863 result = num_trim (result, precision);
Diego Novillo6de9cd92004-05-13 02:41:07 -04001864 if (!result.unsignedp)
Neil Booth91318902002-05-26 18:42:21 +00001865 {
1866 bool lhsp = num_positive (lhs, precision);
1867 result.overflow = (lhsp == num_positive (rhs, precision)
1868 && lhsp != num_positive (result, precision));
1869 }
1870 return result;
1871
1872 /* Comma. */
1873 default: /* case CPP_COMMA: */
Joseph Myers32e8aa92004-02-11 23:50:45 +00001874 if (CPP_PEDANTIC (pfile) && (!CPP_OPTION (pfile, c99)
1875 || !pfile->state.skip_eval))
John David Anglin0527bc42003-11-01 22:56:54 +00001876 cpp_error (pfile, CPP_DL_PEDWARN,
Neil Booth91318902002-05-26 18:42:21 +00001877 "comma operator in operand of #if");
1878 lhs = rhs;
1879 break;
1880 }
1881
1882 return lhs;
1883}
1884
1885/* Multiplies two unsigned cpp_num_parts to give a cpp_num. This
1886 cannot overflow. */
1887static cpp_num
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001888num_part_mul (cpp_num_part lhs, cpp_num_part rhs)
Neil Booth91318902002-05-26 18:42:21 +00001889{
1890 cpp_num result;
1891 cpp_num_part middle[2], temp;
1892
1893 result.low = LOW_PART (lhs) * LOW_PART (rhs);
1894 result.high = HIGH_PART (lhs) * HIGH_PART (rhs);
1895
1896 middle[0] = LOW_PART (lhs) * HIGH_PART (rhs);
1897 middle[1] = HIGH_PART (lhs) * LOW_PART (rhs);
1898
1899 temp = result.low;
1900 result.low += LOW_PART (middle[0]) << (PART_PRECISION / 2);
1901 if (result.low < temp)
1902 result.high++;
1903
1904 temp = result.low;
1905 result.low += LOW_PART (middle[1]) << (PART_PRECISION / 2);
1906 if (result.low < temp)
1907 result.high++;
1908
1909 result.high += HIGH_PART (middle[0]);
1910 result.high += HIGH_PART (middle[1]);
Diego Novillo6de9cd92004-05-13 02:41:07 -04001911 result.unsignedp = true;
1912 result.overflow = false;
Neil Booth91318902002-05-26 18:42:21 +00001913
1914 return result;
1915}
1916
1917/* Multiply two preprocessing numbers. */
1918static cpp_num
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001919num_mul (cpp_reader *pfile, cpp_num lhs, cpp_num rhs)
Neil Booth91318902002-05-26 18:42:21 +00001920{
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);
1925
1926 /* Prepare for unsigned multiplication. */
1927 if (!unsignedp)
1928 {
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);
1933 }
1934
1935 overflow = lhs.high && rhs.high;
1936 result = num_part_mul (lhs.low, rhs.low);
1937
1938 temp = num_part_mul (lhs.high, rhs.low);
1939 result.high += temp.low;
1940 if (temp.high)
1941 overflow = true;
1942
1943 temp = num_part_mul (lhs.low, rhs.high);
1944 result.high += temp.low;
1945 if (temp.high)
1946 overflow = true;
1947
1948 temp.low = result.low, temp.high = result.high;
1949 result = num_trim (result, precision);
1950 if (!num_eq (result, temp))
1951 overflow = true;
1952
1953 if (negate)
1954 result = num_negate (result, precision);
1955
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;
1962
1963 return result;
1964}
1965
Manuel López-Ibáñezb506a5a2009-06-18 15:10:23 +00001966/* 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). */
1969
Neil Booth91318902002-05-26 18:42:21 +00001970static cpp_num
Manuel López-Ibáñezb506a5a2009-06-18 15:10:23 +00001971num_div_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op,
1972 source_location location)
Neil Booth91318902002-05-26 18:42:21 +00001973{
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);
1979
1980 /* Prepare for unsigned division. */
1981 if (!unsignedp)
1982 {
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);
1987 }
1988
1989 /* Find the high bit. */
1990 if (rhs.high)
1991 {
1992 i = precision - 1;
Neil Booth359b0be2002-05-28 05:44:06 +00001993 mask = (cpp_num_part) 1 << (i - PART_PRECISION);
Neil Booth91318902002-05-26 18:42:21 +00001994 for (; ; i--, mask >>= 1)
1995 if (rhs.high & mask)
1996 break;
1997 }
1998 else if (rhs.low)
1999 {
2000 if (precision > PART_PRECISION)
2001 i = precision - PART_PRECISION - 1;
2002 else
2003 i = precision - 1;
Neil Booth359b0be2002-05-28 05:44:06 +00002004 mask = (cpp_num_part) 1 << i;
Neil Booth91318902002-05-26 18:42:21 +00002005 for (; ; i--, mask >>= 1)
2006 if (rhs.low & mask)
2007 break;
2008 }
2009 else
2010 {
Neil Booth75aef482002-07-19 19:24:43 +00002011 if (!pfile->state.skip_eval)
Manuel López-Ibáñezb506a5a2009-06-18 15:10:23 +00002012 cpp_error_with_line (pfile, CPP_DL_ERROR, location, 0,
2013 "division by zero in #if");
Neil Booth91318902002-05-26 18:42:21 +00002014 return lhs;
2015 }
2016
Kazu Hiratada7d8302002-09-22 02:03:17 +00002017 /* First nonzero bit of RHS is bit I. Do naive division by
Neil Booth91318902002-05-26 18:42:21 +00002018 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. */
2021
2022 rhs.unsignedp = true;
2023 lhs.unsignedp = true;
2024 i = precision - i - 1;
2025 sub = num_lshift (rhs, precision, i);
2026
2027 result.high = result.low = 0;
2028 for (;;)
2029 {
2030 if (num_greater_eq (lhs, sub, precision))
2031 {
2032 lhs = num_binary_op (pfile, lhs, sub, CPP_MINUS);
2033 if (i >= PART_PRECISION)
Neil Booth359b0be2002-05-28 05:44:06 +00002034 result.high |= (cpp_num_part) 1 << (i - PART_PRECISION);
Neil Booth91318902002-05-26 18:42:21 +00002035 else
Neil Booth359b0be2002-05-28 05:44:06 +00002036 result.low |= (cpp_num_part) 1 << i;
Neil Booth91318902002-05-26 18:42:21 +00002037 }
2038 if (i-- == 0)
2039 break;
2040 sub.low = (sub.low >> 1) | (sub.high << (PART_PRECISION - 1));
2041 sub.high >>= 1;
2042 }
2043
2044 /* We divide so that the remainder has the sign of the LHS. */
2045 if (op == CPP_DIV)
2046 {
2047 result.unsignedp = unsignedp;
Diego Novillo6de9cd92004-05-13 02:41:07 -04002048 result.overflow = false;
2049 if (!unsignedp)
Neil Booth91318902002-05-26 18:42:21 +00002050 {
2051 if (negate)
2052 result = num_negate (result, precision);
Eric Christopher22a8a522007-05-02 21:57:50 +00002053 result.overflow = (num_positive (result, precision) ^ !negate
2054 && !num_zerop (result));
Neil Booth91318902002-05-26 18:42:21 +00002055 }
2056
2057 return result;
2058 }
2059
2060 /* CPP_MOD. */
2061 lhs.unsignedp = unsignedp;
2062 lhs.overflow = false;
2063 if (lhs_neg)
2064 lhs = num_negate (lhs, precision);
2065
2066 return lhs;
2067}