1 |
270 |
jeremybenn |
/* Parse C expressions for cpplib.
|
2 |
|
|
Copyright (C) 1987, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2001,
|
3 |
|
|
2002, 2004, 2008, 2009, 2010 Free Software Foundation.
|
4 |
|
|
Contributed by Per Bothner, 1994.
|
5 |
|
|
|
6 |
|
|
This program is free software; you can redistribute it and/or modify it
|
7 |
|
|
under the terms of the GNU General Public License as published by the
|
8 |
|
|
Free Software Foundation; either version 3, or (at your option) any
|
9 |
|
|
later version.
|
10 |
|
|
|
11 |
|
|
This program is distributed in the hope that it will be useful,
|
12 |
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
13 |
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
14 |
|
|
GNU General Public License for more details.
|
15 |
|
|
|
16 |
|
|
You should have received a copy of the GNU General Public License
|
17 |
|
|
along with this program; see the file COPYING3. If not see
|
18 |
|
|
<http://www.gnu.org/licenses/>. */
|
19 |
|
|
|
20 |
|
|
#include "config.h"
|
21 |
|
|
#include "system.h"
|
22 |
|
|
#include "cpplib.h"
|
23 |
|
|
#include "internal.h"
|
24 |
|
|
|
25 |
|
|
#define PART_PRECISION (sizeof (cpp_num_part) * CHAR_BIT)
|
26 |
|
|
#define HALF_MASK (~(cpp_num_part) 0 >> (PART_PRECISION / 2))
|
27 |
|
|
#define LOW_PART(num_part) (num_part & HALF_MASK)
|
28 |
|
|
#define HIGH_PART(num_part) (num_part >> (PART_PRECISION / 2))
|
29 |
|
|
|
30 |
|
|
struct op
|
31 |
|
|
{
|
32 |
|
|
const cpp_token *token; /* The token forming op (for diagnostics). */
|
33 |
|
|
cpp_num value; /* The value logically "right" of op. */
|
34 |
|
|
source_location loc; /* The location of this value. */
|
35 |
|
|
enum cpp_ttype op;
|
36 |
|
|
};
|
37 |
|
|
|
38 |
|
|
/* Some simple utility routines on double integers. */
|
39 |
|
|
#define num_zerop(num) ((num.low | num.high) == 0)
|
40 |
|
|
#define num_eq(num1, num2) (num1.low == num2.low && num1.high == num2.high)
|
41 |
|
|
static bool num_positive (cpp_num, size_t);
|
42 |
|
|
static bool num_greater_eq (cpp_num, cpp_num, size_t);
|
43 |
|
|
static cpp_num num_trim (cpp_num, size_t);
|
44 |
|
|
static cpp_num num_part_mul (cpp_num_part, cpp_num_part);
|
45 |
|
|
|
46 |
|
|
static cpp_num num_unary_op (cpp_reader *, cpp_num, enum cpp_ttype);
|
47 |
|
|
static cpp_num num_binary_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);
|
48 |
|
|
static cpp_num num_negate (cpp_num, size_t);
|
49 |
|
|
static cpp_num num_bitwise_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);
|
50 |
|
|
static cpp_num num_inequality_op (cpp_reader *, cpp_num, cpp_num,
|
51 |
|
|
enum cpp_ttype);
|
52 |
|
|
static cpp_num num_equality_op (cpp_reader *, cpp_num, cpp_num,
|
53 |
|
|
enum cpp_ttype);
|
54 |
|
|
static cpp_num num_mul (cpp_reader *, cpp_num, cpp_num);
|
55 |
|
|
static cpp_num num_div_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype,
|
56 |
|
|
source_location);
|
57 |
|
|
static cpp_num num_lshift (cpp_num, size_t, size_t);
|
58 |
|
|
static cpp_num num_rshift (cpp_num, size_t, size_t);
|
59 |
|
|
|
60 |
|
|
static cpp_num append_digit (cpp_num, int, int, size_t);
|
61 |
|
|
static cpp_num parse_defined (cpp_reader *);
|
62 |
|
|
static cpp_num eval_token (cpp_reader *, const cpp_token *);
|
63 |
|
|
static struct op *reduce (cpp_reader *, struct op *, enum cpp_ttype);
|
64 |
|
|
static unsigned int interpret_float_suffix (const uchar *, size_t);
|
65 |
|
|
static unsigned int interpret_int_suffix (const uchar *, size_t);
|
66 |
|
|
static void check_promotion (cpp_reader *, const struct op *);
|
67 |
|
|
|
68 |
|
|
/* Token type abuse to create unary plus and minus operators. */
|
69 |
|
|
#define CPP_UPLUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 1))
|
70 |
|
|
#define CPP_UMINUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 2))
|
71 |
|
|
|
72 |
|
|
/* With -O2, gcc appears to produce nice code, moving the error
|
73 |
|
|
message load and subsequent jump completely out of the main path. */
|
74 |
|
|
#define SYNTAX_ERROR(msgid) \
|
75 |
|
|
do { cpp_error (pfile, CPP_DL_ERROR, msgid); goto syntax_error; } while(0)
|
76 |
|
|
#define SYNTAX_ERROR2(msgid, arg) \
|
77 |
|
|
do { cpp_error (pfile, CPP_DL_ERROR, msgid, arg); goto syntax_error; } \
|
78 |
|
|
while(0)
|
79 |
|
|
|
80 |
|
|
/* Subroutine of cpp_classify_number. S points to a float suffix of
|
81 |
|
|
length LEN, possibly zero. Returns 0 for an invalid suffix, or a
|
82 |
|
|
flag vector describing the suffix. */
|
83 |
|
|
static unsigned int
|
84 |
|
|
interpret_float_suffix (const uchar *s, size_t len)
|
85 |
|
|
{
|
86 |
|
|
size_t flags;
|
87 |
|
|
size_t f, d, l, w, q, i;
|
88 |
|
|
|
89 |
|
|
flags = 0;
|
90 |
|
|
f = d = l = w = q = i = 0;
|
91 |
|
|
|
92 |
|
|
/* Process decimal float suffixes, which are two letters starting
|
93 |
|
|
with d or D. Order and case are significant. */
|
94 |
|
|
if (len == 2 && (*s == 'd' || *s == 'D'))
|
95 |
|
|
{
|
96 |
|
|
bool uppercase = (*s == 'D');
|
97 |
|
|
switch (s[1])
|
98 |
|
|
{
|
99 |
|
|
case 'f': return (!uppercase ? (CPP_N_DFLOAT | CPP_N_SMALL): 0); break;
|
100 |
|
|
case 'F': return (uppercase ? (CPP_N_DFLOAT | CPP_N_SMALL) : 0); break;
|
101 |
|
|
case 'd': return (!uppercase ? (CPP_N_DFLOAT | CPP_N_MEDIUM): 0); break;
|
102 |
|
|
case 'D': return (uppercase ? (CPP_N_DFLOAT | CPP_N_MEDIUM) : 0); break;
|
103 |
|
|
case 'l': return (!uppercase ? (CPP_N_DFLOAT | CPP_N_LARGE) : 0); break;
|
104 |
|
|
case 'L': return (uppercase ? (CPP_N_DFLOAT | CPP_N_LARGE) : 0); break;
|
105 |
|
|
default:
|
106 |
|
|
/* Additional two-character suffixes beginning with D are not
|
107 |
|
|
for decimal float constants. */
|
108 |
|
|
break;
|
109 |
|
|
}
|
110 |
|
|
}
|
111 |
|
|
|
112 |
|
|
/* Recognize a fixed-point suffix. */
|
113 |
|
|
switch (s[len-1])
|
114 |
|
|
{
|
115 |
|
|
case 'k': case 'K': flags = CPP_N_ACCUM; break;
|
116 |
|
|
case 'r': case 'R': flags = CPP_N_FRACT; break;
|
117 |
|
|
default: break;
|
118 |
|
|
}
|
119 |
|
|
|
120 |
|
|
/* Continue processing a fixed-point suffix. The suffix is case
|
121 |
|
|
insensitive except for ll or LL. Order is significant. */
|
122 |
|
|
if (flags)
|
123 |
|
|
{
|
124 |
|
|
if (len == 1)
|
125 |
|
|
return flags;
|
126 |
|
|
len--;
|
127 |
|
|
|
128 |
|
|
if (*s == 'u' || *s == 'U')
|
129 |
|
|
{
|
130 |
|
|
flags |= CPP_N_UNSIGNED;
|
131 |
|
|
if (len == 1)
|
132 |
|
|
return flags;
|
133 |
|
|
len--;
|
134 |
|
|
s++;
|
135 |
|
|
}
|
136 |
|
|
|
137 |
|
|
switch (*s)
|
138 |
|
|
{
|
139 |
|
|
case 'h': case 'H':
|
140 |
|
|
if (len == 1)
|
141 |
|
|
return flags |= CPP_N_SMALL;
|
142 |
|
|
break;
|
143 |
|
|
case 'l':
|
144 |
|
|
if (len == 1)
|
145 |
|
|
return flags |= CPP_N_MEDIUM;
|
146 |
|
|
if (len == 2 && s[1] == 'l')
|
147 |
|
|
return flags |= CPP_N_LARGE;
|
148 |
|
|
break;
|
149 |
|
|
case 'L':
|
150 |
|
|
if (len == 1)
|
151 |
|
|
return flags |= CPP_N_MEDIUM;
|
152 |
|
|
if (len == 2 && s[1] == 'L')
|
153 |
|
|
return flags |= CPP_N_LARGE;
|
154 |
|
|
break;
|
155 |
|
|
default:
|
156 |
|
|
break;
|
157 |
|
|
}
|
158 |
|
|
/* Anything left at this point is invalid. */
|
159 |
|
|
return 0;
|
160 |
|
|
}
|
161 |
|
|
|
162 |
|
|
/* In any remaining valid suffix, the case and order don't matter. */
|
163 |
|
|
while (len--)
|
164 |
|
|
switch (s[len])
|
165 |
|
|
{
|
166 |
|
|
case 'f': case 'F': f++; break;
|
167 |
|
|
case 'd': case 'D': d++; break;
|
168 |
|
|
case 'l': case 'L': l++; break;
|
169 |
|
|
case 'w': case 'W': w++; break;
|
170 |
|
|
case 'q': case 'Q': q++; break;
|
171 |
|
|
case 'i': case 'I':
|
172 |
|
|
case 'j': case 'J': i++; break;
|
173 |
|
|
default:
|
174 |
|
|
return 0;
|
175 |
|
|
}
|
176 |
|
|
|
177 |
|
|
if (f + d + l + w + q > 1 || i > 1)
|
178 |
|
|
return 0;
|
179 |
|
|
|
180 |
|
|
return ((i ? CPP_N_IMAGINARY : 0)
|
181 |
|
|
| (f ? CPP_N_SMALL :
|
182 |
|
|
d ? CPP_N_MEDIUM :
|
183 |
|
|
l ? CPP_N_LARGE :
|
184 |
|
|
w ? CPP_N_MD_W :
|
185 |
|
|
q ? CPP_N_MD_Q : CPP_N_DEFAULT));
|
186 |
|
|
}
|
187 |
|
|
|
188 |
|
|
/* Subroutine of cpp_classify_number. S points to an integer suffix
|
189 |
|
|
of length LEN, possibly zero. Returns 0 for an invalid suffix, or a
|
190 |
|
|
flag vector describing the suffix. */
|
191 |
|
|
static unsigned int
|
192 |
|
|
interpret_int_suffix (const uchar *s, size_t len)
|
193 |
|
|
{
|
194 |
|
|
size_t u, l, i;
|
195 |
|
|
|
196 |
|
|
u = l = i = 0;
|
197 |
|
|
|
198 |
|
|
while (len--)
|
199 |
|
|
switch (s[len])
|
200 |
|
|
{
|
201 |
|
|
case 'u': case 'U': u++; break;
|
202 |
|
|
case 'i': case 'I':
|
203 |
|
|
case 'j': case 'J': i++; break;
|
204 |
|
|
case 'l': case 'L': l++;
|
205 |
|
|
/* If there are two Ls, they must be adjacent and the same case. */
|
206 |
|
|
if (l == 2 && s[len] != s[len + 1])
|
207 |
|
|
return 0;
|
208 |
|
|
break;
|
209 |
|
|
default:
|
210 |
|
|
return 0;
|
211 |
|
|
}
|
212 |
|
|
|
213 |
|
|
if (l > 2 || u > 1 || i > 1)
|
214 |
|
|
return 0;
|
215 |
|
|
|
216 |
|
|
return ((i ? CPP_N_IMAGINARY : 0)
|
217 |
|
|
| (u ? CPP_N_UNSIGNED : 0)
|
218 |
|
|
| ((l == 0) ? CPP_N_SMALL
|
219 |
|
|
: (l == 1) ? CPP_N_MEDIUM : CPP_N_LARGE));
|
220 |
|
|
}
|
221 |
|
|
|
222 |
|
|
/* Categorize numeric constants according to their field (integer,
|
223 |
|
|
floating point, or invalid), radix (decimal, octal, hexadecimal),
|
224 |
|
|
and type suffixes. */
|
225 |
|
|
unsigned int
|
226 |
|
|
cpp_classify_number (cpp_reader *pfile, const cpp_token *token)
|
227 |
|
|
{
|
228 |
|
|
const uchar *str = token->val.str.text;
|
229 |
|
|
const uchar *limit;
|
230 |
|
|
unsigned int max_digit, result, radix;
|
231 |
|
|
enum {NOT_FLOAT = 0, AFTER_POINT, AFTER_EXPON} float_flag;
|
232 |
|
|
bool seen_digit;
|
233 |
|
|
|
234 |
|
|
/* If the lexer has done its job, length one can only be a single
|
235 |
|
|
digit. Fast-path this very common case. */
|
236 |
|
|
if (token->val.str.len == 1)
|
237 |
|
|
return CPP_N_INTEGER | CPP_N_SMALL | CPP_N_DECIMAL;
|
238 |
|
|
|
239 |
|
|
limit = str + token->val.str.len;
|
240 |
|
|
float_flag = NOT_FLOAT;
|
241 |
|
|
max_digit = 0;
|
242 |
|
|
radix = 10;
|
243 |
|
|
seen_digit = false;
|
244 |
|
|
|
245 |
|
|
/* First, interpret the radix. */
|
246 |
|
|
if (*str == '0')
|
247 |
|
|
{
|
248 |
|
|
radix = 8;
|
249 |
|
|
str++;
|
250 |
|
|
|
251 |
|
|
/* Require at least one hex digit to classify it as hex. */
|
252 |
|
|
if ((*str == 'x' || *str == 'X')
|
253 |
|
|
&& (str[1] == '.' || ISXDIGIT (str[1])))
|
254 |
|
|
{
|
255 |
|
|
radix = 16;
|
256 |
|
|
str++;
|
257 |
|
|
}
|
258 |
|
|
else if ((*str == 'b' || *str == 'B') && (str[1] == '0' || str[1] == '1'))
|
259 |
|
|
{
|
260 |
|
|
radix = 2;
|
261 |
|
|
str++;
|
262 |
|
|
}
|
263 |
|
|
}
|
264 |
|
|
|
265 |
|
|
/* Now scan for a well-formed integer or float. */
|
266 |
|
|
for (;;)
|
267 |
|
|
{
|
268 |
|
|
unsigned int c = *str++;
|
269 |
|
|
|
270 |
|
|
if (ISDIGIT (c) || (ISXDIGIT (c) && radix == 16))
|
271 |
|
|
{
|
272 |
|
|
seen_digit = true;
|
273 |
|
|
c = hex_value (c);
|
274 |
|
|
if (c > max_digit)
|
275 |
|
|
max_digit = c;
|
276 |
|
|
}
|
277 |
|
|
else if (c == '.')
|
278 |
|
|
{
|
279 |
|
|
if (float_flag == NOT_FLOAT)
|
280 |
|
|
float_flag = AFTER_POINT;
|
281 |
|
|
else
|
282 |
|
|
SYNTAX_ERROR ("too many decimal points in number");
|
283 |
|
|
}
|
284 |
|
|
else if ((radix <= 10 && (c == 'e' || c == 'E'))
|
285 |
|
|
|| (radix == 16 && (c == 'p' || c == 'P')))
|
286 |
|
|
{
|
287 |
|
|
float_flag = AFTER_EXPON;
|
288 |
|
|
break;
|
289 |
|
|
}
|
290 |
|
|
else
|
291 |
|
|
{
|
292 |
|
|
/* Start of suffix. */
|
293 |
|
|
str--;
|
294 |
|
|
break;
|
295 |
|
|
}
|
296 |
|
|
}
|
297 |
|
|
|
298 |
|
|
/* The suffix may be for decimal fixed-point constants without exponent. */
|
299 |
|
|
if (radix != 16 && float_flag == NOT_FLOAT)
|
300 |
|
|
{
|
301 |
|
|
result = interpret_float_suffix (str, limit - str);
|
302 |
|
|
if ((result & CPP_N_FRACT) || (result & CPP_N_ACCUM))
|
303 |
|
|
{
|
304 |
|
|
result |= CPP_N_FLOATING;
|
305 |
|
|
/* We need to restore the radix to 10, if the radix is 8. */
|
306 |
|
|
if (radix == 8)
|
307 |
|
|
radix = 10;
|
308 |
|
|
|
309 |
|
|
if (CPP_PEDANTIC (pfile))
|
310 |
|
|
cpp_error (pfile, CPP_DL_PEDWARN,
|
311 |
|
|
"fixed-point constants are a GCC extension");
|
312 |
|
|
goto syntax_ok;
|
313 |
|
|
}
|
314 |
|
|
else
|
315 |
|
|
result = 0;
|
316 |
|
|
}
|
317 |
|
|
|
318 |
|
|
if (float_flag != NOT_FLOAT && radix == 8)
|
319 |
|
|
radix = 10;
|
320 |
|
|
|
321 |
|
|
if (max_digit >= radix)
|
322 |
|
|
{
|
323 |
|
|
if (radix == 2)
|
324 |
|
|
SYNTAX_ERROR2 ("invalid digit \"%c\" in binary constant", '0' + max_digit);
|
325 |
|
|
else
|
326 |
|
|
SYNTAX_ERROR2 ("invalid digit \"%c\" in octal constant", '0' + max_digit);
|
327 |
|
|
}
|
328 |
|
|
|
329 |
|
|
if (float_flag != NOT_FLOAT)
|
330 |
|
|
{
|
331 |
|
|
if (radix == 2)
|
332 |
|
|
{
|
333 |
|
|
cpp_error (pfile, CPP_DL_ERROR,
|
334 |
|
|
"invalid prefix \"0b\" for floating constant");
|
335 |
|
|
return CPP_N_INVALID;
|
336 |
|
|
}
|
337 |
|
|
|
338 |
|
|
if (radix == 16 && !seen_digit)
|
339 |
|
|
SYNTAX_ERROR ("no digits in hexadecimal floating constant");
|
340 |
|
|
|
341 |
|
|
if (radix == 16 && CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, c99))
|
342 |
|
|
cpp_error (pfile, CPP_DL_PEDWARN,
|
343 |
|
|
"use of C99 hexadecimal floating constant");
|
344 |
|
|
|
345 |
|
|
if (float_flag == AFTER_EXPON)
|
346 |
|
|
{
|
347 |
|
|
if (*str == '+' || *str == '-')
|
348 |
|
|
str++;
|
349 |
|
|
|
350 |
|
|
/* Exponent is decimal, even if string is a hex float. */
|
351 |
|
|
if (!ISDIGIT (*str))
|
352 |
|
|
SYNTAX_ERROR ("exponent has no digits");
|
353 |
|
|
|
354 |
|
|
do
|
355 |
|
|
str++;
|
356 |
|
|
while (ISDIGIT (*str));
|
357 |
|
|
}
|
358 |
|
|
else if (radix == 16)
|
359 |
|
|
SYNTAX_ERROR ("hexadecimal floating constants require an exponent");
|
360 |
|
|
|
361 |
|
|
result = interpret_float_suffix (str, limit - str);
|
362 |
|
|
if (result == 0)
|
363 |
|
|
{
|
364 |
|
|
cpp_error (pfile, CPP_DL_ERROR,
|
365 |
|
|
"invalid suffix \"%.*s\" on floating constant",
|
366 |
|
|
(int) (limit - str), str);
|
367 |
|
|
return CPP_N_INVALID;
|
368 |
|
|
}
|
369 |
|
|
|
370 |
|
|
/* Traditional C didn't accept any floating suffixes. */
|
371 |
|
|
if (limit != str
|
372 |
|
|
&& CPP_WTRADITIONAL (pfile)
|
373 |
|
|
&& ! cpp_sys_macro_p (pfile))
|
374 |
|
|
cpp_error (pfile, CPP_DL_WARNING,
|
375 |
|
|
"traditional C rejects the \"%.*s\" suffix",
|
376 |
|
|
(int) (limit - str), str);
|
377 |
|
|
|
378 |
|
|
/* A suffix for double is a GCC extension via decimal float support.
|
379 |
|
|
If the suffix also specifies an imaginary value we'll catch that
|
380 |
|
|
later. */
|
381 |
|
|
if ((result == CPP_N_MEDIUM) && CPP_PEDANTIC (pfile))
|
382 |
|
|
cpp_error (pfile, CPP_DL_PEDWARN,
|
383 |
|
|
"suffix for double constant is a GCC extension");
|
384 |
|
|
|
385 |
|
|
/* Radix must be 10 for decimal floats. */
|
386 |
|
|
if ((result & CPP_N_DFLOAT) && radix != 10)
|
387 |
|
|
{
|
388 |
|
|
cpp_error (pfile, CPP_DL_ERROR,
|
389 |
|
|
"invalid suffix \"%.*s\" with hexadecimal floating constant",
|
390 |
|
|
(int) (limit - str), str);
|
391 |
|
|
return CPP_N_INVALID;
|
392 |
|
|
}
|
393 |
|
|
|
394 |
|
|
if ((result & (CPP_N_FRACT | CPP_N_ACCUM)) && CPP_PEDANTIC (pfile))
|
395 |
|
|
cpp_error (pfile, CPP_DL_PEDWARN,
|
396 |
|
|
"fixed-point constants are a GCC extension");
|
397 |
|
|
|
398 |
|
|
if ((result & CPP_N_DFLOAT) && CPP_PEDANTIC (pfile))
|
399 |
|
|
cpp_error (pfile, CPP_DL_PEDWARN,
|
400 |
|
|
"decimal float constants are a GCC extension");
|
401 |
|
|
|
402 |
|
|
result |= CPP_N_FLOATING;
|
403 |
|
|
}
|
404 |
|
|
else
|
405 |
|
|
{
|
406 |
|
|
result = interpret_int_suffix (str, limit - str);
|
407 |
|
|
if (result == 0)
|
408 |
|
|
{
|
409 |
|
|
cpp_error (pfile, CPP_DL_ERROR,
|
410 |
|
|
"invalid suffix \"%.*s\" on integer constant",
|
411 |
|
|
(int) (limit - str), str);
|
412 |
|
|
return CPP_N_INVALID;
|
413 |
|
|
}
|
414 |
|
|
|
415 |
|
|
/* Traditional C only accepted the 'L' suffix.
|
416 |
|
|
Suppress warning about 'LL' with -Wno-long-long. */
|
417 |
|
|
if (CPP_WTRADITIONAL (pfile) && ! cpp_sys_macro_p (pfile))
|
418 |
|
|
{
|
419 |
|
|
int u_or_i = (result & (CPP_N_UNSIGNED|CPP_N_IMAGINARY));
|
420 |
|
|
int large = (result & CPP_N_WIDTH) == CPP_N_LARGE;
|
421 |
|
|
|
422 |
|
|
if (u_or_i || (large && CPP_OPTION (pfile, warn_long_long)))
|
423 |
|
|
cpp_error (pfile, CPP_DL_WARNING,
|
424 |
|
|
"traditional C rejects the \"%.*s\" suffix",
|
425 |
|
|
(int) (limit - str), str);
|
426 |
|
|
}
|
427 |
|
|
|
428 |
|
|
if ((result & CPP_N_WIDTH) == CPP_N_LARGE
|
429 |
|
|
&& CPP_OPTION (pfile, warn_long_long))
|
430 |
|
|
cpp_error (pfile,
|
431 |
|
|
CPP_OPTION (pfile, c99) ? CPP_DL_WARNING : CPP_DL_PEDWARN,
|
432 |
|
|
CPP_OPTION (pfile, cplusplus)
|
433 |
|
|
? "use of C++0x long long integer constant"
|
434 |
|
|
: "use of C99 long long integer constant");
|
435 |
|
|
|
436 |
|
|
result |= CPP_N_INTEGER;
|
437 |
|
|
}
|
438 |
|
|
|
439 |
|
|
syntax_ok:
|
440 |
|
|
if ((result & CPP_N_IMAGINARY) && CPP_PEDANTIC (pfile))
|
441 |
|
|
cpp_error (pfile, CPP_DL_PEDWARN,
|
442 |
|
|
"imaginary constants are a GCC extension");
|
443 |
|
|
if (radix == 2 && CPP_PEDANTIC (pfile))
|
444 |
|
|
cpp_error (pfile, CPP_DL_PEDWARN,
|
445 |
|
|
"binary constants are a GCC extension");
|
446 |
|
|
|
447 |
|
|
if (radix == 10)
|
448 |
|
|
result |= CPP_N_DECIMAL;
|
449 |
|
|
else if (radix == 16)
|
450 |
|
|
result |= CPP_N_HEX;
|
451 |
|
|
else if (radix == 2)
|
452 |
|
|
result |= CPP_N_BINARY;
|
453 |
|
|
else
|
454 |
|
|
result |= CPP_N_OCTAL;
|
455 |
|
|
|
456 |
|
|
return result;
|
457 |
|
|
|
458 |
|
|
syntax_error:
|
459 |
|
|
return CPP_N_INVALID;
|
460 |
|
|
}
|
461 |
|
|
|
462 |
|
|
/* cpp_interpret_integer converts an integer constant into a cpp_num,
|
463 |
|
|
of precision options->precision.
|
464 |
|
|
|
465 |
|
|
We do not provide any interface for decimal->float conversion,
|
466 |
|
|
because the preprocessor doesn't need it and we don't want to
|
467 |
|
|
drag in GCC's floating point emulator. */
|
468 |
|
|
cpp_num
|
469 |
|
|
cpp_interpret_integer (cpp_reader *pfile, const cpp_token *token,
|
470 |
|
|
unsigned int type)
|
471 |
|
|
{
|
472 |
|
|
const uchar *p, *end;
|
473 |
|
|
cpp_num result;
|
474 |
|
|
|
475 |
|
|
result.low = 0;
|
476 |
|
|
result.high = 0;
|
477 |
|
|
result.unsignedp = !!(type & CPP_N_UNSIGNED);
|
478 |
|
|
result.overflow = false;
|
479 |
|
|
|
480 |
|
|
p = token->val.str.text;
|
481 |
|
|
end = p + token->val.str.len;
|
482 |
|
|
|
483 |
|
|
/* Common case of a single digit. */
|
484 |
|
|
if (token->val.str.len == 1)
|
485 |
|
|
result.low = p[0] - '0';
|
486 |
|
|
else
|
487 |
|
|
{
|
488 |
|
|
cpp_num_part max;
|
489 |
|
|
size_t precision = CPP_OPTION (pfile, precision);
|
490 |
|
|
unsigned int base = 10, c = 0;
|
491 |
|
|
bool overflow = false;
|
492 |
|
|
|
493 |
|
|
if ((type & CPP_N_RADIX) == CPP_N_OCTAL)
|
494 |
|
|
{
|
495 |
|
|
base = 8;
|
496 |
|
|
p++;
|
497 |
|
|
}
|
498 |
|
|
else if ((type & CPP_N_RADIX) == CPP_N_HEX)
|
499 |
|
|
{
|
500 |
|
|
base = 16;
|
501 |
|
|
p += 2;
|
502 |
|
|
}
|
503 |
|
|
else if ((type & CPP_N_RADIX) == CPP_N_BINARY)
|
504 |
|
|
{
|
505 |
|
|
base = 2;
|
506 |
|
|
p += 2;
|
507 |
|
|
}
|
508 |
|
|
|
509 |
|
|
/* We can add a digit to numbers strictly less than this without
|
510 |
|
|
needing the precision and slowness of double integers. */
|
511 |
|
|
max = ~(cpp_num_part) 0;
|
512 |
|
|
if (precision < PART_PRECISION)
|
513 |
|
|
max >>= PART_PRECISION - precision;
|
514 |
|
|
max = (max - base + 1) / base + 1;
|
515 |
|
|
|
516 |
|
|
for (; p < end; p++)
|
517 |
|
|
{
|
518 |
|
|
c = *p;
|
519 |
|
|
|
520 |
|
|
if (ISDIGIT (c) || (base == 16 && ISXDIGIT (c)))
|
521 |
|
|
c = hex_value (c);
|
522 |
|
|
else
|
523 |
|
|
break;
|
524 |
|
|
|
525 |
|
|
/* Strict inequality for when max is set to zero. */
|
526 |
|
|
if (result.low < max)
|
527 |
|
|
result.low = result.low * base + c;
|
528 |
|
|
else
|
529 |
|
|
{
|
530 |
|
|
result = append_digit (result, c, base, precision);
|
531 |
|
|
overflow |= result.overflow;
|
532 |
|
|
max = 0;
|
533 |
|
|
}
|
534 |
|
|
}
|
535 |
|
|
|
536 |
|
|
if (overflow)
|
537 |
|
|
cpp_error (pfile, CPP_DL_PEDWARN,
|
538 |
|
|
"integer constant is too large for its type");
|
539 |
|
|
/* If too big to be signed, consider it unsigned. Only warn for
|
540 |
|
|
decimal numbers. Traditional numbers were always signed (but
|
541 |
|
|
we still honor an explicit U suffix); but we only have
|
542 |
|
|
traditional semantics in directives. */
|
543 |
|
|
else if (!result.unsignedp
|
544 |
|
|
&& !(CPP_OPTION (pfile, traditional)
|
545 |
|
|
&& pfile->state.in_directive)
|
546 |
|
|
&& !num_positive (result, precision))
|
547 |
|
|
{
|
548 |
|
|
/* This is for constants within the range of uintmax_t but
|
549 |
|
|
not that of intmax_t. For such decimal constants, a
|
550 |
|
|
diagnostic is required for C99 as the selected type must
|
551 |
|
|
be signed and not having a type is a constraint violation
|
552 |
|
|
(DR#298, TC3), so this must be a pedwarn. For C90,
|
553 |
|
|
unsigned long is specified to be used for a constant that
|
554 |
|
|
does not fit in signed long; if uintmax_t has the same
|
555 |
|
|
range as unsigned long this means only a warning is
|
556 |
|
|
appropriate here. C90 permits the preprocessor to use a
|
557 |
|
|
wider range than unsigned long in the compiler, so if
|
558 |
|
|
uintmax_t is wider than unsigned long no diagnostic is
|
559 |
|
|
required for such constants in preprocessor #if
|
560 |
|
|
expressions and the compiler will pedwarn for such
|
561 |
|
|
constants outside the range of unsigned long that reach
|
562 |
|
|
the compiler so a diagnostic is not required there
|
563 |
|
|
either; thus, pedwarn for C99 but use a plain warning for
|
564 |
|
|
C90. */
|
565 |
|
|
if (base == 10)
|
566 |
|
|
cpp_error (pfile, (CPP_OPTION (pfile, c99)
|
567 |
|
|
? CPP_DL_PEDWARN
|
568 |
|
|
: CPP_DL_WARNING),
|
569 |
|
|
"integer constant is so large that it is unsigned");
|
570 |
|
|
result.unsignedp = true;
|
571 |
|
|
}
|
572 |
|
|
}
|
573 |
|
|
|
574 |
|
|
return result;
|
575 |
|
|
}
|
576 |
|
|
|
577 |
|
|
/* Append DIGIT to NUM, a number of PRECISION bits being read in base BASE. */
|
578 |
|
|
static cpp_num
|
579 |
|
|
append_digit (cpp_num num, int digit, int base, size_t precision)
|
580 |
|
|
{
|
581 |
|
|
cpp_num result;
|
582 |
|
|
unsigned int shift;
|
583 |
|
|
bool overflow;
|
584 |
|
|
cpp_num_part add_high, add_low;
|
585 |
|
|
|
586 |
|
|
/* Multiply by 2, 8 or 16. Catching this overflow here means we don't
|
587 |
|
|
need to worry about add_high overflowing. */
|
588 |
|
|
switch (base)
|
589 |
|
|
{
|
590 |
|
|
case 2:
|
591 |
|
|
shift = 1;
|
592 |
|
|
break;
|
593 |
|
|
|
594 |
|
|
case 16:
|
595 |
|
|
shift = 4;
|
596 |
|
|
break;
|
597 |
|
|
|
598 |
|
|
default:
|
599 |
|
|
shift = 3;
|
600 |
|
|
}
|
601 |
|
|
overflow = !!(num.high >> (PART_PRECISION - shift));
|
602 |
|
|
result.high = num.high << shift;
|
603 |
|
|
result.low = num.low << shift;
|
604 |
|
|
result.high |= num.low >> (PART_PRECISION - shift);
|
605 |
|
|
result.unsignedp = num.unsignedp;
|
606 |
|
|
|
607 |
|
|
if (base == 10)
|
608 |
|
|
{
|
609 |
|
|
add_low = num.low << 1;
|
610 |
|
|
add_high = (num.high << 1) + (num.low >> (PART_PRECISION - 1));
|
611 |
|
|
}
|
612 |
|
|
else
|
613 |
|
|
add_high = add_low = 0;
|
614 |
|
|
|
615 |
|
|
if (add_low + digit < add_low)
|
616 |
|
|
add_high++;
|
617 |
|
|
add_low += digit;
|
618 |
|
|
|
619 |
|
|
if (result.low + add_low < result.low)
|
620 |
|
|
add_high++;
|
621 |
|
|
if (result.high + add_high < result.high)
|
622 |
|
|
overflow = true;
|
623 |
|
|
|
624 |
|
|
result.low += add_low;
|
625 |
|
|
result.high += add_high;
|
626 |
|
|
result.overflow = overflow;
|
627 |
|
|
|
628 |
|
|
/* The above code catches overflow of a cpp_num type. This catches
|
629 |
|
|
overflow of the (possibly shorter) target precision. */
|
630 |
|
|
num.low = result.low;
|
631 |
|
|
num.high = result.high;
|
632 |
|
|
result = num_trim (result, precision);
|
633 |
|
|
if (!num_eq (result, num))
|
634 |
|
|
result.overflow = true;
|
635 |
|
|
|
636 |
|
|
return result;
|
637 |
|
|
}
|
638 |
|
|
|
639 |
|
|
/* Handle meeting "defined" in a preprocessor expression. */
|
640 |
|
|
static cpp_num
|
641 |
|
|
parse_defined (cpp_reader *pfile)
|
642 |
|
|
{
|
643 |
|
|
cpp_num result;
|
644 |
|
|
int paren = 0;
|
645 |
|
|
cpp_hashnode *node = 0;
|
646 |
|
|
const cpp_token *token;
|
647 |
|
|
cpp_context *initial_context = pfile->context;
|
648 |
|
|
|
649 |
|
|
/* Don't expand macros. */
|
650 |
|
|
pfile->state.prevent_expansion++;
|
651 |
|
|
|
652 |
|
|
token = cpp_get_token (pfile);
|
653 |
|
|
if (token->type == CPP_OPEN_PAREN)
|
654 |
|
|
{
|
655 |
|
|
paren = 1;
|
656 |
|
|
token = cpp_get_token (pfile);
|
657 |
|
|
}
|
658 |
|
|
|
659 |
|
|
if (token->type == CPP_NAME)
|
660 |
|
|
{
|
661 |
|
|
node = token->val.node.node;
|
662 |
|
|
if (paren && cpp_get_token (pfile)->type != CPP_CLOSE_PAREN)
|
663 |
|
|
{
|
664 |
|
|
cpp_error (pfile, CPP_DL_ERROR, "missing ')' after \"defined\"");
|
665 |
|
|
node = 0;
|
666 |
|
|
}
|
667 |
|
|
}
|
668 |
|
|
else
|
669 |
|
|
{
|
670 |
|
|
cpp_error (pfile, CPP_DL_ERROR,
|
671 |
|
|
"operator \"defined\" requires an identifier");
|
672 |
|
|
if (token->flags & NAMED_OP)
|
673 |
|
|
{
|
674 |
|
|
cpp_token op;
|
675 |
|
|
|
676 |
|
|
op.flags = 0;
|
677 |
|
|
op.type = token->type;
|
678 |
|
|
cpp_error (pfile, CPP_DL_ERROR,
|
679 |
|
|
"(\"%s\" is an alternative token for \"%s\" in C++)",
|
680 |
|
|
cpp_token_as_text (pfile, token),
|
681 |
|
|
cpp_token_as_text (pfile, &op));
|
682 |
|
|
}
|
683 |
|
|
}
|
684 |
|
|
|
685 |
|
|
if (node)
|
686 |
|
|
{
|
687 |
|
|
if (pfile->context != initial_context && CPP_PEDANTIC (pfile))
|
688 |
|
|
cpp_error (pfile, CPP_DL_WARNING,
|
689 |
|
|
"this use of \"defined\" may not be portable");
|
690 |
|
|
|
691 |
|
|
_cpp_mark_macro_used (node);
|
692 |
|
|
if (!(node->flags & NODE_USED))
|
693 |
|
|
{
|
694 |
|
|
node->flags |= NODE_USED;
|
695 |
|
|
if (node->type == NT_MACRO)
|
696 |
|
|
{
|
697 |
|
|
if (pfile->cb.used_define)
|
698 |
|
|
pfile->cb.used_define (pfile, pfile->directive_line, node);
|
699 |
|
|
}
|
700 |
|
|
else
|
701 |
|
|
{
|
702 |
|
|
if (pfile->cb.used_undef)
|
703 |
|
|
pfile->cb.used_undef (pfile, pfile->directive_line, node);
|
704 |
|
|
}
|
705 |
|
|
}
|
706 |
|
|
|
707 |
|
|
/* A possible controlling macro of the form #if !defined ().
|
708 |
|
|
_cpp_parse_expr checks there was no other junk on the line. */
|
709 |
|
|
pfile->mi_ind_cmacro = node;
|
710 |
|
|
}
|
711 |
|
|
|
712 |
|
|
pfile->state.prevent_expansion--;
|
713 |
|
|
|
714 |
|
|
result.unsignedp = false;
|
715 |
|
|
result.high = 0;
|
716 |
|
|
result.overflow = false;
|
717 |
|
|
result.low = node && node->type == NT_MACRO;
|
718 |
|
|
return result;
|
719 |
|
|
}
|
720 |
|
|
|
721 |
|
|
/* Convert a token into a CPP_NUMBER (an interpreted preprocessing
|
722 |
|
|
number or character constant, or the result of the "defined" or "#"
|
723 |
|
|
operators). */
|
724 |
|
|
static cpp_num
|
725 |
|
|
eval_token (cpp_reader *pfile, const cpp_token *token)
|
726 |
|
|
{
|
727 |
|
|
cpp_num result;
|
728 |
|
|
unsigned int temp;
|
729 |
|
|
int unsignedp = 0;
|
730 |
|
|
|
731 |
|
|
result.unsignedp = false;
|
732 |
|
|
result.overflow = false;
|
733 |
|
|
|
734 |
|
|
switch (token->type)
|
735 |
|
|
{
|
736 |
|
|
case CPP_NUMBER:
|
737 |
|
|
temp = cpp_classify_number (pfile, token);
|
738 |
|
|
switch (temp & CPP_N_CATEGORY)
|
739 |
|
|
{
|
740 |
|
|
case CPP_N_FLOATING:
|
741 |
|
|
cpp_error (pfile, CPP_DL_ERROR,
|
742 |
|
|
"floating constant in preprocessor expression");
|
743 |
|
|
break;
|
744 |
|
|
case CPP_N_INTEGER:
|
745 |
|
|
if (!(temp & CPP_N_IMAGINARY))
|
746 |
|
|
return cpp_interpret_integer (pfile, token, temp);
|
747 |
|
|
cpp_error (pfile, CPP_DL_ERROR,
|
748 |
|
|
"imaginary number in preprocessor expression");
|
749 |
|
|
break;
|
750 |
|
|
|
751 |
|
|
case CPP_N_INVALID:
|
752 |
|
|
/* Error already issued. */
|
753 |
|
|
break;
|
754 |
|
|
}
|
755 |
|
|
result.high = result.low = 0;
|
756 |
|
|
break;
|
757 |
|
|
|
758 |
|
|
case CPP_WCHAR:
|
759 |
|
|
case CPP_CHAR:
|
760 |
|
|
case CPP_CHAR16:
|
761 |
|
|
case CPP_CHAR32:
|
762 |
|
|
{
|
763 |
|
|
cppchar_t cc = cpp_interpret_charconst (pfile, token,
|
764 |
|
|
&temp, &unsignedp);
|
765 |
|
|
|
766 |
|
|
result.high = 0;
|
767 |
|
|
result.low = cc;
|
768 |
|
|
/* Sign-extend the result if necessary. */
|
769 |
|
|
if (!unsignedp && (cppchar_signed_t) cc < 0)
|
770 |
|
|
{
|
771 |
|
|
if (PART_PRECISION > BITS_PER_CPPCHAR_T)
|
772 |
|
|
result.low |= ~(~(cpp_num_part) 0
|
773 |
|
|
>> (PART_PRECISION - BITS_PER_CPPCHAR_T));
|
774 |
|
|
result.high = ~(cpp_num_part) 0;
|
775 |
|
|
result = num_trim (result, CPP_OPTION (pfile, precision));
|
776 |
|
|
}
|
777 |
|
|
}
|
778 |
|
|
break;
|
779 |
|
|
|
780 |
|
|
case CPP_NAME:
|
781 |
|
|
if (token->val.node.node == pfile->spec_nodes.n_defined)
|
782 |
|
|
return parse_defined (pfile);
|
783 |
|
|
else if (CPP_OPTION (pfile, cplusplus)
|
784 |
|
|
&& (token->val.node.node == pfile->spec_nodes.n_true
|
785 |
|
|
|| token->val.node.node == pfile->spec_nodes.n_false))
|
786 |
|
|
{
|
787 |
|
|
result.high = 0;
|
788 |
|
|
result.low = (token->val.node.node == pfile->spec_nodes.n_true);
|
789 |
|
|
}
|
790 |
|
|
else
|
791 |
|
|
{
|
792 |
|
|
result.high = 0;
|
793 |
|
|
result.low = 0;
|
794 |
|
|
if (CPP_OPTION (pfile, warn_undef) && !pfile->state.skip_eval)
|
795 |
|
|
cpp_error (pfile, CPP_DL_WARNING, "\"%s\" is not defined",
|
796 |
|
|
NODE_NAME (token->val.node.node));
|
797 |
|
|
}
|
798 |
|
|
break;
|
799 |
|
|
|
800 |
|
|
case CPP_HASH:
|
801 |
|
|
if (!pfile->state.skipping)
|
802 |
|
|
{
|
803 |
|
|
/* A pedantic warning takes precedence over a deprecated
|
804 |
|
|
warning here. */
|
805 |
|
|
if (CPP_PEDANTIC (pfile))
|
806 |
|
|
cpp_error (pfile, CPP_DL_PEDWARN,
|
807 |
|
|
"assertions are a GCC extension");
|
808 |
|
|
else if (CPP_OPTION (pfile, warn_deprecated))
|
809 |
|
|
cpp_error (pfile, CPP_DL_WARNING,
|
810 |
|
|
"assertions are a deprecated extension");
|
811 |
|
|
}
|
812 |
|
|
_cpp_test_assertion (pfile, &temp);
|
813 |
|
|
result.high = 0;
|
814 |
|
|
result.low = temp;
|
815 |
|
|
break;
|
816 |
|
|
|
817 |
|
|
default:
|
818 |
|
|
abort ();
|
819 |
|
|
}
|
820 |
|
|
|
821 |
|
|
result.unsignedp = !!unsignedp;
|
822 |
|
|
return result;
|
823 |
|
|
}
|
824 |
|
|
|
825 |
|
|
/* Operator precedence and flags table.
|
826 |
|
|
|
827 |
|
|
After an operator is returned from the lexer, if it has priority less
|
828 |
|
|
than the operator on the top of the stack, we reduce the stack by one
|
829 |
|
|
operator and repeat the test. Since equal priorities do not reduce,
|
830 |
|
|
this is naturally right-associative.
|
831 |
|
|
|
832 |
|
|
We handle left-associative operators by decrementing the priority of
|
833 |
|
|
just-lexed operators by one, but retaining the priority of operators
|
834 |
|
|
already on the stack.
|
835 |
|
|
|
836 |
|
|
The remaining cases are '(' and ')'. We handle '(' by skipping the
|
837 |
|
|
reduction phase completely. ')' is given lower priority than
|
838 |
|
|
everything else, including '(', effectively forcing a reduction of the
|
839 |
|
|
parenthesized expression. If there is a matching '(', the routine
|
840 |
|
|
reduce() exits immediately. If the normal exit route sees a ')', then
|
841 |
|
|
there cannot have been a matching '(' and an error message is output.
|
842 |
|
|
|
843 |
|
|
The parser assumes all shifted operators require a left operand unless
|
844 |
|
|
the flag NO_L_OPERAND is set. These semantics are automatic; any
|
845 |
|
|
extra semantics need to be handled with operator-specific code. */
|
846 |
|
|
|
847 |
|
|
/* Flags. If CHECK_PROMOTION, we warn if the effective sign of an
|
848 |
|
|
operand changes because of integer promotions. */
|
849 |
|
|
#define NO_L_OPERAND (1 << 0)
|
850 |
|
|
#define LEFT_ASSOC (1 << 1)
|
851 |
|
|
#define CHECK_PROMOTION (1 << 2)
|
852 |
|
|
|
853 |
|
|
/* Operator to priority map. Must be in the same order as the first
|
854 |
|
|
N entries of enum cpp_ttype. */
|
855 |
|
|
static const struct cpp_operator
|
856 |
|
|
{
|
857 |
|
|
uchar prio;
|
858 |
|
|
uchar flags;
|
859 |
|
|
} optab[] =
|
860 |
|
|
{
|
861 |
|
|
/* EQ */ {0, 0}, /* Shouldn't happen. */
|
862 |
|
|
/* NOT */ {16, NO_L_OPERAND},
|
863 |
|
|
/* GREATER */ {12, LEFT_ASSOC | CHECK_PROMOTION},
|
864 |
|
|
/* LESS */ {12, LEFT_ASSOC | CHECK_PROMOTION},
|
865 |
|
|
/* PLUS */ {14, LEFT_ASSOC | CHECK_PROMOTION},
|
866 |
|
|
/* MINUS */ {14, LEFT_ASSOC | CHECK_PROMOTION},
|
867 |
|
|
/* MULT */ {15, LEFT_ASSOC | CHECK_PROMOTION},
|
868 |
|
|
/* DIV */ {15, LEFT_ASSOC | CHECK_PROMOTION},
|
869 |
|
|
/* MOD */ {15, LEFT_ASSOC | CHECK_PROMOTION},
|
870 |
|
|
/* AND */ {9, LEFT_ASSOC | CHECK_PROMOTION},
|
871 |
|
|
/* OR */ {7, LEFT_ASSOC | CHECK_PROMOTION},
|
872 |
|
|
/* XOR */ {8, LEFT_ASSOC | CHECK_PROMOTION},
|
873 |
|
|
/* RSHIFT */ {13, LEFT_ASSOC},
|
874 |
|
|
/* LSHIFT */ {13, LEFT_ASSOC},
|
875 |
|
|
|
876 |
|
|
/* COMPL */ {16, NO_L_OPERAND},
|
877 |
|
|
/* AND_AND */ {6, LEFT_ASSOC},
|
878 |
|
|
/* OR_OR */ {5, LEFT_ASSOC},
|
879 |
|
|
/* Note that QUERY, COLON, and COMMA must have the same precedence.
|
880 |
|
|
However, there are some special cases for these in reduce(). */
|
881 |
|
|
/* QUERY */ {4, 0},
|
882 |
|
|
/* COLON */ {4, LEFT_ASSOC | CHECK_PROMOTION},
|
883 |
|
|
/* COMMA */ {4, LEFT_ASSOC},
|
884 |
|
|
/* OPEN_PAREN */ {1, NO_L_OPERAND},
|
885 |
|
|
/* CLOSE_PAREN */ {0, 0},
|
886 |
|
|
/* EOF */ {0, 0},
|
887 |
|
|
/* EQ_EQ */ {11, LEFT_ASSOC},
|
888 |
|
|
/* NOT_EQ */ {11, LEFT_ASSOC},
|
889 |
|
|
/* GREATER_EQ */ {12, LEFT_ASSOC | CHECK_PROMOTION},
|
890 |
|
|
/* LESS_EQ */ {12, LEFT_ASSOC | CHECK_PROMOTION},
|
891 |
|
|
/* UPLUS */ {16, NO_L_OPERAND},
|
892 |
|
|
/* UMINUS */ {16, NO_L_OPERAND}
|
893 |
|
|
};
|
894 |
|
|
|
895 |
|
|
/* Parse and evaluate a C expression, reading from PFILE.
|
896 |
|
|
Returns the truth value of the expression.
|
897 |
|
|
|
898 |
|
|
The implementation is an operator precedence parser, i.e. a
|
899 |
|
|
bottom-up parser, using a stack for not-yet-reduced tokens.
|
900 |
|
|
|
901 |
|
|
The stack base is op_stack, and the current stack pointer is 'top'.
|
902 |
|
|
There is a stack element for each operator (only), and the most
|
903 |
|
|
recently pushed operator is 'top->op'. An operand (value) is
|
904 |
|
|
stored in the 'value' field of the stack element of the operator
|
905 |
|
|
that precedes it. */
|
906 |
|
|
bool
|
907 |
|
|
_cpp_parse_expr (cpp_reader *pfile, bool is_if)
|
908 |
|
|
{
|
909 |
|
|
struct op *top = pfile->op_stack;
|
910 |
|
|
unsigned int lex_count;
|
911 |
|
|
bool saw_leading_not, want_value = true;
|
912 |
|
|
|
913 |
|
|
pfile->state.skip_eval = 0;
|
914 |
|
|
|
915 |
|
|
/* Set up detection of #if ! defined(). */
|
916 |
|
|
pfile->mi_ind_cmacro = 0;
|
917 |
|
|
saw_leading_not = false;
|
918 |
|
|
lex_count = 0;
|
919 |
|
|
|
920 |
|
|
/* Lowest priority operator prevents further reductions. */
|
921 |
|
|
top->op = CPP_EOF;
|
922 |
|
|
|
923 |
|
|
for (;;)
|
924 |
|
|
{
|
925 |
|
|
struct op op;
|
926 |
|
|
|
927 |
|
|
lex_count++;
|
928 |
|
|
op.token = cpp_get_token (pfile);
|
929 |
|
|
op.op = op.token->type;
|
930 |
|
|
op.loc = op.token->src_loc;
|
931 |
|
|
|
932 |
|
|
switch (op.op)
|
933 |
|
|
{
|
934 |
|
|
/* These tokens convert into values. */
|
935 |
|
|
case CPP_NUMBER:
|
936 |
|
|
case CPP_CHAR:
|
937 |
|
|
case CPP_WCHAR:
|
938 |
|
|
case CPP_CHAR16:
|
939 |
|
|
case CPP_CHAR32:
|
940 |
|
|
case CPP_NAME:
|
941 |
|
|
case CPP_HASH:
|
942 |
|
|
if (!want_value)
|
943 |
|
|
SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
|
944 |
|
|
cpp_token_as_text (pfile, op.token));
|
945 |
|
|
want_value = false;
|
946 |
|
|
top->value = eval_token (pfile, op.token);
|
947 |
|
|
continue;
|
948 |
|
|
|
949 |
|
|
case CPP_NOT:
|
950 |
|
|
saw_leading_not = lex_count == 1;
|
951 |
|
|
break;
|
952 |
|
|
case CPP_PLUS:
|
953 |
|
|
if (want_value)
|
954 |
|
|
op.op = CPP_UPLUS;
|
955 |
|
|
break;
|
956 |
|
|
case CPP_MINUS:
|
957 |
|
|
if (want_value)
|
958 |
|
|
op.op = CPP_UMINUS;
|
959 |
|
|
break;
|
960 |
|
|
|
961 |
|
|
default:
|
962 |
|
|
if ((int) op.op <= (int) CPP_EQ || (int) op.op >= (int) CPP_PLUS_EQ)
|
963 |
|
|
SYNTAX_ERROR2 ("token \"%s\" is not valid in preprocessor expressions",
|
964 |
|
|
cpp_token_as_text (pfile, op.token));
|
965 |
|
|
break;
|
966 |
|
|
}
|
967 |
|
|
|
968 |
|
|
/* Check we have a value or operator as appropriate. */
|
969 |
|
|
if (optab[op.op].flags & NO_L_OPERAND)
|
970 |
|
|
{
|
971 |
|
|
if (!want_value)
|
972 |
|
|
SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
|
973 |
|
|
cpp_token_as_text (pfile, op.token));
|
974 |
|
|
}
|
975 |
|
|
else if (want_value)
|
976 |
|
|
{
|
977 |
|
|
/* We want a number (or expression) and haven't got one.
|
978 |
|
|
Try to emit a specific diagnostic. */
|
979 |
|
|
if (op.op == CPP_CLOSE_PAREN && top->op == CPP_OPEN_PAREN)
|
980 |
|
|
SYNTAX_ERROR ("missing expression between '(' and ')'");
|
981 |
|
|
|
982 |
|
|
if (op.op == CPP_EOF && top->op == CPP_EOF)
|
983 |
|
|
SYNTAX_ERROR2 ("%s with no expression", is_if ? "#if" : "#elif");
|
984 |
|
|
|
985 |
|
|
if (top->op != CPP_EOF && top->op != CPP_OPEN_PAREN)
|
986 |
|
|
SYNTAX_ERROR2 ("operator '%s' has no right operand",
|
987 |
|
|
cpp_token_as_text (pfile, top->token));
|
988 |
|
|
else if (op.op == CPP_CLOSE_PAREN || op.op == CPP_EOF)
|
989 |
|
|
/* Complain about missing paren during reduction. */;
|
990 |
|
|
else
|
991 |
|
|
SYNTAX_ERROR2 ("operator '%s' has no left operand",
|
992 |
|
|
cpp_token_as_text (pfile, op.token));
|
993 |
|
|
}
|
994 |
|
|
|
995 |
|
|
top = reduce (pfile, top, op.op);
|
996 |
|
|
if (!top)
|
997 |
|
|
goto syntax_error;
|
998 |
|
|
|
999 |
|
|
if (op.op == CPP_EOF)
|
1000 |
|
|
break;
|
1001 |
|
|
|
1002 |
|
|
switch (op.op)
|
1003 |
|
|
{
|
1004 |
|
|
case CPP_CLOSE_PAREN:
|
1005 |
|
|
continue;
|
1006 |
|
|
case CPP_OR_OR:
|
1007 |
|
|
if (!num_zerop (top->value))
|
1008 |
|
|
pfile->state.skip_eval++;
|
1009 |
|
|
break;
|
1010 |
|
|
case CPP_AND_AND:
|
1011 |
|
|
case CPP_QUERY:
|
1012 |
|
|
if (num_zerop (top->value))
|
1013 |
|
|
pfile->state.skip_eval++;
|
1014 |
|
|
break;
|
1015 |
|
|
case CPP_COLON:
|
1016 |
|
|
if (top->op != CPP_QUERY)
|
1017 |
|
|
SYNTAX_ERROR (" ':' without preceding '?'");
|
1018 |
|
|
if (!num_zerop (top[-1].value)) /* Was '?' condition true? */
|
1019 |
|
|
pfile->state.skip_eval++;
|
1020 |
|
|
else
|
1021 |
|
|
pfile->state.skip_eval--;
|
1022 |
|
|
default:
|
1023 |
|
|
break;
|
1024 |
|
|
}
|
1025 |
|
|
|
1026 |
|
|
want_value = true;
|
1027 |
|
|
|
1028 |
|
|
/* Check for and handle stack overflow. */
|
1029 |
|
|
if (++top == pfile->op_limit)
|
1030 |
|
|
top = _cpp_expand_op_stack (pfile);
|
1031 |
|
|
|
1032 |
|
|
top->op = op.op;
|
1033 |
|
|
top->token = op.token;
|
1034 |
|
|
top->loc = op.token->src_loc;
|
1035 |
|
|
}
|
1036 |
|
|
|
1037 |
|
|
/* The controlling macro expression is only valid if we called lex 3
|
1038 |
|
|
times: <!> <defined expression> and <EOF>. push_conditional ()
|
1039 |
|
|
checks that we are at top-of-file. */
|
1040 |
|
|
if (pfile->mi_ind_cmacro && !(saw_leading_not && lex_count == 3))
|
1041 |
|
|
pfile->mi_ind_cmacro = 0;
|
1042 |
|
|
|
1043 |
|
|
if (top != pfile->op_stack)
|
1044 |
|
|
{
|
1045 |
|
|
cpp_error (pfile, CPP_DL_ICE, "unbalanced stack in %s",
|
1046 |
|
|
is_if ? "#if" : "#elif");
|
1047 |
|
|
syntax_error:
|
1048 |
|
|
return false; /* Return false on syntax error. */
|
1049 |
|
|
}
|
1050 |
|
|
|
1051 |
|
|
return !num_zerop (top->value);
|
1052 |
|
|
}
|
1053 |
|
|
|
1054 |
|
|
/* Reduce the operator / value stack if possible, in preparation for
|
1055 |
|
|
pushing operator OP. Returns NULL on error, otherwise the top of
|
1056 |
|
|
the stack. */
|
1057 |
|
|
static struct op *
|
1058 |
|
|
reduce (cpp_reader *pfile, struct op *top, enum cpp_ttype op)
|
1059 |
|
|
{
|
1060 |
|
|
unsigned int prio;
|
1061 |
|
|
|
1062 |
|
|
if (top->op <= CPP_EQ || top->op > CPP_LAST_CPP_OP + 2)
|
1063 |
|
|
{
|
1064 |
|
|
bad_op:
|
1065 |
|
|
cpp_error (pfile, CPP_DL_ICE, "impossible operator '%u'", top->op);
|
1066 |
|
|
return 0;
|
1067 |
|
|
}
|
1068 |
|
|
|
1069 |
|
|
if (op == CPP_OPEN_PAREN)
|
1070 |
|
|
return top;
|
1071 |
|
|
|
1072 |
|
|
/* Decrement the priority of left-associative operators to force a
|
1073 |
|
|
reduction with operators of otherwise equal priority. */
|
1074 |
|
|
prio = optab[op].prio - ((optab[op].flags & LEFT_ASSOC) != 0);
|
1075 |
|
|
while (prio < optab[top->op].prio)
|
1076 |
|
|
{
|
1077 |
|
|
if (CPP_OPTION (pfile, warn_num_sign_change)
|
1078 |
|
|
&& optab[top->op].flags & CHECK_PROMOTION)
|
1079 |
|
|
check_promotion (pfile, top);
|
1080 |
|
|
|
1081 |
|
|
switch (top->op)
|
1082 |
|
|
{
|
1083 |
|
|
case CPP_UPLUS:
|
1084 |
|
|
case CPP_UMINUS:
|
1085 |
|
|
case CPP_NOT:
|
1086 |
|
|
case CPP_COMPL:
|
1087 |
|
|
top[-1].value = num_unary_op (pfile, top->value, top->op);
|
1088 |
|
|
top[-1].loc = top->loc;
|
1089 |
|
|
break;
|
1090 |
|
|
|
1091 |
|
|
case CPP_PLUS:
|
1092 |
|
|
case CPP_MINUS:
|
1093 |
|
|
case CPP_RSHIFT:
|
1094 |
|
|
case CPP_LSHIFT:
|
1095 |
|
|
case CPP_COMMA:
|
1096 |
|
|
top[-1].value = num_binary_op (pfile, top[-1].value,
|
1097 |
|
|
top->value, top->op);
|
1098 |
|
|
top[-1].loc = top->loc;
|
1099 |
|
|
break;
|
1100 |
|
|
|
1101 |
|
|
case CPP_GREATER:
|
1102 |
|
|
case CPP_LESS:
|
1103 |
|
|
case CPP_GREATER_EQ:
|
1104 |
|
|
case CPP_LESS_EQ:
|
1105 |
|
|
top[-1].value
|
1106 |
|
|
= num_inequality_op (pfile, top[-1].value, top->value, top->op);
|
1107 |
|
|
top[-1].loc = top->loc;
|
1108 |
|
|
break;
|
1109 |
|
|
|
1110 |
|
|
case CPP_EQ_EQ:
|
1111 |
|
|
case CPP_NOT_EQ:
|
1112 |
|
|
top[-1].value
|
1113 |
|
|
= num_equality_op (pfile, top[-1].value, top->value, top->op);
|
1114 |
|
|
top[-1].loc = top->loc;
|
1115 |
|
|
break;
|
1116 |
|
|
|
1117 |
|
|
case CPP_AND:
|
1118 |
|
|
case CPP_OR:
|
1119 |
|
|
case CPP_XOR:
|
1120 |
|
|
top[-1].value
|
1121 |
|
|
= num_bitwise_op (pfile, top[-1].value, top->value, top->op);
|
1122 |
|
|
top[-1].loc = top->loc;
|
1123 |
|
|
break;
|
1124 |
|
|
|
1125 |
|
|
case CPP_MULT:
|
1126 |
|
|
top[-1].value = num_mul (pfile, top[-1].value, top->value);
|
1127 |
|
|
top[-1].loc = top->loc;
|
1128 |
|
|
break;
|
1129 |
|
|
|
1130 |
|
|
case CPP_DIV:
|
1131 |
|
|
case CPP_MOD:
|
1132 |
|
|
top[-1].value = num_div_op (pfile, top[-1].value,
|
1133 |
|
|
top->value, top->op, top->loc);
|
1134 |
|
|
top[-1].loc = top->loc;
|
1135 |
|
|
break;
|
1136 |
|
|
|
1137 |
|
|
case CPP_OR_OR:
|
1138 |
|
|
top--;
|
1139 |
|
|
if (!num_zerop (top->value))
|
1140 |
|
|
pfile->state.skip_eval--;
|
1141 |
|
|
top->value.low = (!num_zerop (top->value)
|
1142 |
|
|
|| !num_zerop (top[1].value));
|
1143 |
|
|
top->value.high = 0;
|
1144 |
|
|
top->value.unsignedp = false;
|
1145 |
|
|
top->value.overflow = false;
|
1146 |
|
|
top->loc = top[1].loc;
|
1147 |
|
|
continue;
|
1148 |
|
|
|
1149 |
|
|
case CPP_AND_AND:
|
1150 |
|
|
top--;
|
1151 |
|
|
if (num_zerop (top->value))
|
1152 |
|
|
pfile->state.skip_eval--;
|
1153 |
|
|
top->value.low = (!num_zerop (top->value)
|
1154 |
|
|
&& !num_zerop (top[1].value));
|
1155 |
|
|
top->value.high = 0;
|
1156 |
|
|
top->value.unsignedp = false;
|
1157 |
|
|
top->value.overflow = false;
|
1158 |
|
|
top->loc = top[1].loc;
|
1159 |
|
|
continue;
|
1160 |
|
|
|
1161 |
|
|
case CPP_OPEN_PAREN:
|
1162 |
|
|
if (op != CPP_CLOSE_PAREN)
|
1163 |
|
|
{
|
1164 |
|
|
cpp_error_with_line (pfile, CPP_DL_ERROR,
|
1165 |
|
|
top->token->src_loc,
|
1166 |
|
|
0, "missing ')' in expression");
|
1167 |
|
|
return 0;
|
1168 |
|
|
}
|
1169 |
|
|
top--;
|
1170 |
|
|
top->value = top[1].value;
|
1171 |
|
|
top->loc = top[1].loc;
|
1172 |
|
|
return top;
|
1173 |
|
|
|
1174 |
|
|
case CPP_COLON:
|
1175 |
|
|
top -= 2;
|
1176 |
|
|
if (!num_zerop (top->value))
|
1177 |
|
|
{
|
1178 |
|
|
pfile->state.skip_eval--;
|
1179 |
|
|
top->value = top[1].value;
|
1180 |
|
|
top->loc = top[1].loc;
|
1181 |
|
|
}
|
1182 |
|
|
else
|
1183 |
|
|
{
|
1184 |
|
|
top->value = top[2].value;
|
1185 |
|
|
top->loc = top[2].loc;
|
1186 |
|
|
}
|
1187 |
|
|
top->value.unsignedp = (top[1].value.unsignedp
|
1188 |
|
|
|| top[2].value.unsignedp);
|
1189 |
|
|
continue;
|
1190 |
|
|
|
1191 |
|
|
case CPP_QUERY:
|
1192 |
|
|
/* COMMA and COLON should not reduce a QUERY operator. */
|
1193 |
|
|
if (op == CPP_COMMA || op == CPP_COLON)
|
1194 |
|
|
return top;
|
1195 |
|
|
cpp_error (pfile, CPP_DL_ERROR, "'?' without following ':'");
|
1196 |
|
|
return 0;
|
1197 |
|
|
|
1198 |
|
|
default:
|
1199 |
|
|
goto bad_op;
|
1200 |
|
|
}
|
1201 |
|
|
|
1202 |
|
|
top--;
|
1203 |
|
|
if (top->value.overflow && !pfile->state.skip_eval)
|
1204 |
|
|
cpp_error (pfile, CPP_DL_PEDWARN,
|
1205 |
|
|
"integer overflow in preprocessor expression");
|
1206 |
|
|
}
|
1207 |
|
|
|
1208 |
|
|
if (op == CPP_CLOSE_PAREN)
|
1209 |
|
|
{
|
1210 |
|
|
cpp_error (pfile, CPP_DL_ERROR, "missing '(' in expression");
|
1211 |
|
|
return 0;
|
1212 |
|
|
}
|
1213 |
|
|
|
1214 |
|
|
return top;
|
1215 |
|
|
}
|
1216 |
|
|
|
1217 |
|
|
/* Returns the position of the old top of stack after expansion. */
|
1218 |
|
|
struct op *
|
1219 |
|
|
_cpp_expand_op_stack (cpp_reader *pfile)
|
1220 |
|
|
{
|
1221 |
|
|
size_t old_size = (size_t) (pfile->op_limit - pfile->op_stack);
|
1222 |
|
|
size_t new_size = old_size * 2 + 20;
|
1223 |
|
|
|
1224 |
|
|
pfile->op_stack = XRESIZEVEC (struct op, pfile->op_stack, new_size);
|
1225 |
|
|
pfile->op_limit = pfile->op_stack + new_size;
|
1226 |
|
|
|
1227 |
|
|
return pfile->op_stack + old_size;
|
1228 |
|
|
}
|
1229 |
|
|
|
1230 |
|
|
/* Emits a warning if the effective sign of either operand of OP
|
1231 |
|
|
changes because of integer promotions. */
|
1232 |
|
|
static void
|
1233 |
|
|
check_promotion (cpp_reader *pfile, const struct op *op)
|
1234 |
|
|
{
|
1235 |
|
|
if (op->value.unsignedp == op[-1].value.unsignedp)
|
1236 |
|
|
return;
|
1237 |
|
|
|
1238 |
|
|
if (op->value.unsignedp)
|
1239 |
|
|
{
|
1240 |
|
|
if (!num_positive (op[-1].value, CPP_OPTION (pfile, precision)))
|
1241 |
|
|
cpp_error_with_line (pfile, CPP_DL_WARNING, op[-1].loc, 0,
|
1242 |
|
|
"the left operand of \"%s\" changes sign when promoted",
|
1243 |
|
|
cpp_token_as_text (pfile, op->token));
|
1244 |
|
|
}
|
1245 |
|
|
else if (!num_positive (op->value, CPP_OPTION (pfile, precision)))
|
1246 |
|
|
cpp_error_with_line (pfile, CPP_DL_WARNING, op->loc, 0,
|
1247 |
|
|
"the right operand of \"%s\" changes sign when promoted",
|
1248 |
|
|
cpp_token_as_text (pfile, op->token));
|
1249 |
|
|
}
|
1250 |
|
|
|
1251 |
|
|
/* Clears the unused high order bits of the number pointed to by PNUM. */
|
1252 |
|
|
static cpp_num
|
1253 |
|
|
num_trim (cpp_num num, size_t precision)
|
1254 |
|
|
{
|
1255 |
|
|
if (precision > PART_PRECISION)
|
1256 |
|
|
{
|
1257 |
|
|
precision -= PART_PRECISION;
|
1258 |
|
|
if (precision < PART_PRECISION)
|
1259 |
|
|
num.high &= ((cpp_num_part) 1 << precision) - 1;
|
1260 |
|
|
}
|
1261 |
|
|
else
|
1262 |
|
|
{
|
1263 |
|
|
if (precision < PART_PRECISION)
|
1264 |
|
|
num.low &= ((cpp_num_part) 1 << precision) - 1;
|
1265 |
|
|
num.high = 0;
|
1266 |
|
|
}
|
1267 |
|
|
|
1268 |
|
|
return num;
|
1269 |
|
|
}
|
1270 |
|
|
|
1271 |
|
|
/* True iff A (presumed signed) >= 0. */
|
1272 |
|
|
static bool
|
1273 |
|
|
num_positive (cpp_num num, size_t precision)
|
1274 |
|
|
{
|
1275 |
|
|
if (precision > PART_PRECISION)
|
1276 |
|
|
{
|
1277 |
|
|
precision -= PART_PRECISION;
|
1278 |
|
|
return (num.high & (cpp_num_part) 1 << (precision - 1)) == 0;
|
1279 |
|
|
}
|
1280 |
|
|
|
1281 |
|
|
return (num.low & (cpp_num_part) 1 << (precision - 1)) == 0;
|
1282 |
|
|
}
|
1283 |
|
|
|
1284 |
|
|
/* Sign extend a number, with PRECISION significant bits and all
|
1285 |
|
|
others assumed clear, to fill out a cpp_num structure. */
|
1286 |
|
|
cpp_num
|
1287 |
|
|
cpp_num_sign_extend (cpp_num num, size_t precision)
|
1288 |
|
|
{
|
1289 |
|
|
if (!num.unsignedp)
|
1290 |
|
|
{
|
1291 |
|
|
if (precision > PART_PRECISION)
|
1292 |
|
|
{
|
1293 |
|
|
precision -= PART_PRECISION;
|
1294 |
|
|
if (precision < PART_PRECISION
|
1295 |
|
|
&& (num.high & (cpp_num_part) 1 << (precision - 1)))
|
1296 |
|
|
num.high |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
|
1297 |
|
|
}
|
1298 |
|
|
else if (num.low & (cpp_num_part) 1 << (precision - 1))
|
1299 |
|
|
{
|
1300 |
|
|
if (precision < PART_PRECISION)
|
1301 |
|
|
num.low |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
|
1302 |
|
|
num.high = ~(cpp_num_part) 0;
|
1303 |
|
|
}
|
1304 |
|
|
}
|
1305 |
|
|
|
1306 |
|
|
return num;
|
1307 |
|
|
}
|
1308 |
|
|
|
1309 |
|
|
/* Returns the negative of NUM. */
|
1310 |
|
|
static cpp_num
|
1311 |
|
|
num_negate (cpp_num num, size_t precision)
|
1312 |
|
|
{
|
1313 |
|
|
cpp_num copy;
|
1314 |
|
|
|
1315 |
|
|
copy = num;
|
1316 |
|
|
num.high = ~num.high;
|
1317 |
|
|
num.low = ~num.low;
|
1318 |
|
|
if (++num.low == 0)
|
1319 |
|
|
num.high++;
|
1320 |
|
|
num = num_trim (num, precision);
|
1321 |
|
|
num.overflow = (!num.unsignedp && num_eq (num, copy) && !num_zerop (num));
|
1322 |
|
|
|
1323 |
|
|
return num;
|
1324 |
|
|
}
|
1325 |
|
|
|
1326 |
|
|
/* Returns true if A >= B. */
|
1327 |
|
|
static bool
|
1328 |
|
|
num_greater_eq (cpp_num pa, cpp_num pb, size_t precision)
|
1329 |
|
|
{
|
1330 |
|
|
bool unsignedp;
|
1331 |
|
|
|
1332 |
|
|
unsignedp = pa.unsignedp || pb.unsignedp;
|
1333 |
|
|
|
1334 |
|
|
if (!unsignedp)
|
1335 |
|
|
{
|
1336 |
|
|
/* Both numbers have signed type. If they are of different
|
1337 |
|
|
sign, the answer is the sign of A. */
|
1338 |
|
|
unsignedp = num_positive (pa, precision);
|
1339 |
|
|
|
1340 |
|
|
if (unsignedp != num_positive (pb, precision))
|
1341 |
|
|
return unsignedp;
|
1342 |
|
|
|
1343 |
|
|
/* Otherwise we can do an unsigned comparison. */
|
1344 |
|
|
}
|
1345 |
|
|
|
1346 |
|
|
return (pa.high > pb.high) || (pa.high == pb.high && pa.low >= pb.low);
|
1347 |
|
|
}
|
1348 |
|
|
|
1349 |
|
|
/* Returns LHS OP RHS, where OP is a bit-wise operation. */
|
1350 |
|
|
static cpp_num
|
1351 |
|
|
num_bitwise_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
|
1352 |
|
|
cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
|
1353 |
|
|
{
|
1354 |
|
|
lhs.overflow = false;
|
1355 |
|
|
lhs.unsignedp = lhs.unsignedp || rhs.unsignedp;
|
1356 |
|
|
|
1357 |
|
|
/* As excess precision is zeroed, there is no need to num_trim () as
|
1358 |
|
|
these operations cannot introduce a set bit there. */
|
1359 |
|
|
if (op == CPP_AND)
|
1360 |
|
|
{
|
1361 |
|
|
lhs.low &= rhs.low;
|
1362 |
|
|
lhs.high &= rhs.high;
|
1363 |
|
|
}
|
1364 |
|
|
else if (op == CPP_OR)
|
1365 |
|
|
{
|
1366 |
|
|
lhs.low |= rhs.low;
|
1367 |
|
|
lhs.high |= rhs.high;
|
1368 |
|
|
}
|
1369 |
|
|
else
|
1370 |
|
|
{
|
1371 |
|
|
lhs.low ^= rhs.low;
|
1372 |
|
|
lhs.high ^= rhs.high;
|
1373 |
|
|
}
|
1374 |
|
|
|
1375 |
|
|
return lhs;
|
1376 |
|
|
}
|
1377 |
|
|
|
1378 |
|
|
/* Returns LHS OP RHS, where OP is an inequality. */
|
1379 |
|
|
static cpp_num
|
1380 |
|
|
num_inequality_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs,
|
1381 |
|
|
enum cpp_ttype op)
|
1382 |
|
|
{
|
1383 |
|
|
bool gte = num_greater_eq (lhs, rhs, CPP_OPTION (pfile, precision));
|
1384 |
|
|
|
1385 |
|
|
if (op == CPP_GREATER_EQ)
|
1386 |
|
|
lhs.low = gte;
|
1387 |
|
|
else if (op == CPP_LESS)
|
1388 |
|
|
lhs.low = !gte;
|
1389 |
|
|
else if (op == CPP_GREATER)
|
1390 |
|
|
lhs.low = gte && !num_eq (lhs, rhs);
|
1391 |
|
|
else /* CPP_LESS_EQ. */
|
1392 |
|
|
lhs.low = !gte || num_eq (lhs, rhs);
|
1393 |
|
|
|
1394 |
|
|
lhs.high = 0;
|
1395 |
|
|
lhs.overflow = false;
|
1396 |
|
|
lhs.unsignedp = false;
|
1397 |
|
|
return lhs;
|
1398 |
|
|
}
|
1399 |
|
|
|
1400 |
|
|
/* Returns LHS OP RHS, where OP is == or !=. */
|
1401 |
|
|
static cpp_num
|
1402 |
|
|
num_equality_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
|
1403 |
|
|
cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
|
1404 |
|
|
{
|
1405 |
|
|
/* Work around a 3.0.4 bug; see PR 6950. */
|
1406 |
|
|
bool eq = num_eq (lhs, rhs);
|
1407 |
|
|
if (op == CPP_NOT_EQ)
|
1408 |
|
|
eq = !eq;
|
1409 |
|
|
lhs.low = eq;
|
1410 |
|
|
lhs.high = 0;
|
1411 |
|
|
lhs.overflow = false;
|
1412 |
|
|
lhs.unsignedp = false;
|
1413 |
|
|
return lhs;
|
1414 |
|
|
}
|
1415 |
|
|
|
1416 |
|
|
/* Shift NUM, of width PRECISION, right by N bits. */
|
1417 |
|
|
static cpp_num
|
1418 |
|
|
num_rshift (cpp_num num, size_t precision, size_t n)
|
1419 |
|
|
{
|
1420 |
|
|
cpp_num_part sign_mask;
|
1421 |
|
|
bool x = num_positive (num, precision);
|
1422 |
|
|
|
1423 |
|
|
if (num.unsignedp || x)
|
1424 |
|
|
sign_mask = 0;
|
1425 |
|
|
else
|
1426 |
|
|
sign_mask = ~(cpp_num_part) 0;
|
1427 |
|
|
|
1428 |
|
|
if (n >= precision)
|
1429 |
|
|
num.high = num.low = sign_mask;
|
1430 |
|
|
else
|
1431 |
|
|
{
|
1432 |
|
|
/* Sign-extend. */
|
1433 |
|
|
if (precision < PART_PRECISION)
|
1434 |
|
|
num.high = sign_mask, num.low |= sign_mask << precision;
|
1435 |
|
|
else if (precision < 2 * PART_PRECISION)
|
1436 |
|
|
num.high |= sign_mask << (precision - PART_PRECISION);
|
1437 |
|
|
|
1438 |
|
|
if (n >= PART_PRECISION)
|
1439 |
|
|
{
|
1440 |
|
|
n -= PART_PRECISION;
|
1441 |
|
|
num.low = num.high;
|
1442 |
|
|
num.high = sign_mask;
|
1443 |
|
|
}
|
1444 |
|
|
|
1445 |
|
|
if (n)
|
1446 |
|
|
{
|
1447 |
|
|
num.low = (num.low >> n) | (num.high << (PART_PRECISION - n));
|
1448 |
|
|
num.high = (num.high >> n) | (sign_mask << (PART_PRECISION - n));
|
1449 |
|
|
}
|
1450 |
|
|
}
|
1451 |
|
|
|
1452 |
|
|
num = num_trim (num, precision);
|
1453 |
|
|
num.overflow = false;
|
1454 |
|
|
return num;
|
1455 |
|
|
}
|
1456 |
|
|
|
1457 |
|
|
/* Shift NUM, of width PRECISION, left by N bits. */
|
1458 |
|
|
static cpp_num
|
1459 |
|
|
num_lshift (cpp_num num, size_t precision, size_t n)
|
1460 |
|
|
{
|
1461 |
|
|
if (n >= precision)
|
1462 |
|
|
{
|
1463 |
|
|
num.overflow = !num.unsignedp && !num_zerop (num);
|
1464 |
|
|
num.high = num.low = 0;
|
1465 |
|
|
}
|
1466 |
|
|
else
|
1467 |
|
|
{
|
1468 |
|
|
cpp_num orig, maybe_orig;
|
1469 |
|
|
size_t m = n;
|
1470 |
|
|
|
1471 |
|
|
orig = num;
|
1472 |
|
|
if (m >= PART_PRECISION)
|
1473 |
|
|
{
|
1474 |
|
|
m -= PART_PRECISION;
|
1475 |
|
|
num.high = num.low;
|
1476 |
|
|
num.low = 0;
|
1477 |
|
|
}
|
1478 |
|
|
if (m)
|
1479 |
|
|
{
|
1480 |
|
|
num.high = (num.high << m) | (num.low >> (PART_PRECISION - m));
|
1481 |
|
|
num.low <<= m;
|
1482 |
|
|
}
|
1483 |
|
|
num = num_trim (num, precision);
|
1484 |
|
|
|
1485 |
|
|
if (num.unsignedp)
|
1486 |
|
|
num.overflow = false;
|
1487 |
|
|
else
|
1488 |
|
|
{
|
1489 |
|
|
maybe_orig = num_rshift (num, precision, n);
|
1490 |
|
|
num.overflow = !num_eq (orig, maybe_orig);
|
1491 |
|
|
}
|
1492 |
|
|
}
|
1493 |
|
|
|
1494 |
|
|
return num;
|
1495 |
|
|
}
|
1496 |
|
|
|
1497 |
|
|
/* The four unary operators: +, -, ! and ~. */
|
1498 |
|
|
static cpp_num
|
1499 |
|
|
num_unary_op (cpp_reader *pfile, cpp_num num, enum cpp_ttype op)
|
1500 |
|
|
{
|
1501 |
|
|
switch (op)
|
1502 |
|
|
{
|
1503 |
|
|
case CPP_UPLUS:
|
1504 |
|
|
if (CPP_WTRADITIONAL (pfile) && !pfile->state.skip_eval)
|
1505 |
|
|
cpp_error (pfile, CPP_DL_WARNING,
|
1506 |
|
|
"traditional C rejects the unary plus operator");
|
1507 |
|
|
num.overflow = false;
|
1508 |
|
|
break;
|
1509 |
|
|
|
1510 |
|
|
case CPP_UMINUS:
|
1511 |
|
|
num = num_negate (num, CPP_OPTION (pfile, precision));
|
1512 |
|
|
break;
|
1513 |
|
|
|
1514 |
|
|
case CPP_COMPL:
|
1515 |
|
|
num.high = ~num.high;
|
1516 |
|
|
num.low = ~num.low;
|
1517 |
|
|
num = num_trim (num, CPP_OPTION (pfile, precision));
|
1518 |
|
|
num.overflow = false;
|
1519 |
|
|
break;
|
1520 |
|
|
|
1521 |
|
|
default: /* case CPP_NOT: */
|
1522 |
|
|
num.low = num_zerop (num);
|
1523 |
|
|
num.high = 0;
|
1524 |
|
|
num.overflow = false;
|
1525 |
|
|
num.unsignedp = false;
|
1526 |
|
|
break;
|
1527 |
|
|
}
|
1528 |
|
|
|
1529 |
|
|
return num;
|
1530 |
|
|
}
|
1531 |
|
|
|
1532 |
|
|
/* The various binary operators. */
|
1533 |
|
|
static cpp_num
|
1534 |
|
|
num_binary_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
|
1535 |
|
|
{
|
1536 |
|
|
cpp_num result;
|
1537 |
|
|
size_t precision = CPP_OPTION (pfile, precision);
|
1538 |
|
|
size_t n;
|
1539 |
|
|
|
1540 |
|
|
switch (op)
|
1541 |
|
|
{
|
1542 |
|
|
/* Shifts. */
|
1543 |
|
|
case CPP_LSHIFT:
|
1544 |
|
|
case CPP_RSHIFT:
|
1545 |
|
|
if (!rhs.unsignedp && !num_positive (rhs, precision))
|
1546 |
|
|
{
|
1547 |
|
|
/* A negative shift is a positive shift the other way. */
|
1548 |
|
|
if (op == CPP_LSHIFT)
|
1549 |
|
|
op = CPP_RSHIFT;
|
1550 |
|
|
else
|
1551 |
|
|
op = CPP_LSHIFT;
|
1552 |
|
|
rhs = num_negate (rhs, precision);
|
1553 |
|
|
}
|
1554 |
|
|
if (rhs.high)
|
1555 |
|
|
n = ~0; /* Maximal. */
|
1556 |
|
|
else
|
1557 |
|
|
n = rhs.low;
|
1558 |
|
|
if (op == CPP_LSHIFT)
|
1559 |
|
|
lhs = num_lshift (lhs, precision, n);
|
1560 |
|
|
else
|
1561 |
|
|
lhs = num_rshift (lhs, precision, n);
|
1562 |
|
|
break;
|
1563 |
|
|
|
1564 |
|
|
/* Arithmetic. */
|
1565 |
|
|
case CPP_MINUS:
|
1566 |
|
|
rhs = num_negate (rhs, precision);
|
1567 |
|
|
case CPP_PLUS:
|
1568 |
|
|
result.low = lhs.low + rhs.low;
|
1569 |
|
|
result.high = lhs.high + rhs.high;
|
1570 |
|
|
if (result.low < lhs.low)
|
1571 |
|
|
result.high++;
|
1572 |
|
|
result.unsignedp = lhs.unsignedp || rhs.unsignedp;
|
1573 |
|
|
result.overflow = false;
|
1574 |
|
|
|
1575 |
|
|
result = num_trim (result, precision);
|
1576 |
|
|
if (!result.unsignedp)
|
1577 |
|
|
{
|
1578 |
|
|
bool lhsp = num_positive (lhs, precision);
|
1579 |
|
|
result.overflow = (lhsp == num_positive (rhs, precision)
|
1580 |
|
|
&& lhsp != num_positive (result, precision));
|
1581 |
|
|
}
|
1582 |
|
|
return result;
|
1583 |
|
|
|
1584 |
|
|
/* Comma. */
|
1585 |
|
|
default: /* case CPP_COMMA: */
|
1586 |
|
|
if (CPP_PEDANTIC (pfile) && (!CPP_OPTION (pfile, c99)
|
1587 |
|
|
|| !pfile->state.skip_eval))
|
1588 |
|
|
cpp_error (pfile, CPP_DL_PEDWARN,
|
1589 |
|
|
"comma operator in operand of #if");
|
1590 |
|
|
lhs = rhs;
|
1591 |
|
|
break;
|
1592 |
|
|
}
|
1593 |
|
|
|
1594 |
|
|
return lhs;
|
1595 |
|
|
}
|
1596 |
|
|
|
1597 |
|
|
/* Multiplies two unsigned cpp_num_parts to give a cpp_num. This
|
1598 |
|
|
cannot overflow. */
|
1599 |
|
|
static cpp_num
|
1600 |
|
|
num_part_mul (cpp_num_part lhs, cpp_num_part rhs)
|
1601 |
|
|
{
|
1602 |
|
|
cpp_num result;
|
1603 |
|
|
cpp_num_part middle[2], temp;
|
1604 |
|
|
|
1605 |
|
|
result.low = LOW_PART (lhs) * LOW_PART (rhs);
|
1606 |
|
|
result.high = HIGH_PART (lhs) * HIGH_PART (rhs);
|
1607 |
|
|
|
1608 |
|
|
middle[0] = LOW_PART (lhs) * HIGH_PART (rhs);
|
1609 |
|
|
middle[1] = HIGH_PART (lhs) * LOW_PART (rhs);
|
1610 |
|
|
|
1611 |
|
|
temp = result.low;
|
1612 |
|
|
result.low += LOW_PART (middle[0]) << (PART_PRECISION / 2);
|
1613 |
|
|
if (result.low < temp)
|
1614 |
|
|
result.high++;
|
1615 |
|
|
|
1616 |
|
|
temp = result.low;
|
1617 |
|
|
result.low += LOW_PART (middle[1]) << (PART_PRECISION / 2);
|
1618 |
|
|
if (result.low < temp)
|
1619 |
|
|
result.high++;
|
1620 |
|
|
|
1621 |
|
|
result.high += HIGH_PART (middle[0]);
|
1622 |
|
|
result.high += HIGH_PART (middle[1]);
|
1623 |
|
|
result.unsignedp = true;
|
1624 |
|
|
result.overflow = false;
|
1625 |
|
|
|
1626 |
|
|
return result;
|
1627 |
|
|
}
|
1628 |
|
|
|
1629 |
|
|
/* Multiply two preprocessing numbers. */
|
1630 |
|
|
static cpp_num
|
1631 |
|
|
num_mul (cpp_reader *pfile, cpp_num lhs, cpp_num rhs)
|
1632 |
|
|
{
|
1633 |
|
|
cpp_num result, temp;
|
1634 |
|
|
bool unsignedp = lhs.unsignedp || rhs.unsignedp;
|
1635 |
|
|
bool overflow, negate = false;
|
1636 |
|
|
size_t precision = CPP_OPTION (pfile, precision);
|
1637 |
|
|
|
1638 |
|
|
/* Prepare for unsigned multiplication. */
|
1639 |
|
|
if (!unsignedp)
|
1640 |
|
|
{
|
1641 |
|
|
if (!num_positive (lhs, precision))
|
1642 |
|
|
negate = !negate, lhs = num_negate (lhs, precision);
|
1643 |
|
|
if (!num_positive (rhs, precision))
|
1644 |
|
|
negate = !negate, rhs = num_negate (rhs, precision);
|
1645 |
|
|
}
|
1646 |
|
|
|
1647 |
|
|
overflow = lhs.high && rhs.high;
|
1648 |
|
|
result = num_part_mul (lhs.low, rhs.low);
|
1649 |
|
|
|
1650 |
|
|
temp = num_part_mul (lhs.high, rhs.low);
|
1651 |
|
|
result.high += temp.low;
|
1652 |
|
|
if (temp.high)
|
1653 |
|
|
overflow = true;
|
1654 |
|
|
|
1655 |
|
|
temp = num_part_mul (lhs.low, rhs.high);
|
1656 |
|
|
result.high += temp.low;
|
1657 |
|
|
if (temp.high)
|
1658 |
|
|
overflow = true;
|
1659 |
|
|
|
1660 |
|
|
temp.low = result.low, temp.high = result.high;
|
1661 |
|
|
result = num_trim (result, precision);
|
1662 |
|
|
if (!num_eq (result, temp))
|
1663 |
|
|
overflow = true;
|
1664 |
|
|
|
1665 |
|
|
if (negate)
|
1666 |
|
|
result = num_negate (result, precision);
|
1667 |
|
|
|
1668 |
|
|
if (unsignedp)
|
1669 |
|
|
result.overflow = false;
|
1670 |
|
|
else
|
1671 |
|
|
result.overflow = overflow || (num_positive (result, precision) ^ !negate
|
1672 |
|
|
&& !num_zerop (result));
|
1673 |
|
|
result.unsignedp = unsignedp;
|
1674 |
|
|
|
1675 |
|
|
return result;
|
1676 |
|
|
}
|
1677 |
|
|
|
1678 |
|
|
/* Divide two preprocessing numbers, LHS and RHS, returning the answer
|
1679 |
|
|
or the remainder depending upon OP. LOCATION is the source location
|
1680 |
|
|
of this operator (for diagnostics). */
|
1681 |
|
|
|
1682 |
|
|
static cpp_num
|
1683 |
|
|
num_div_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op,
|
1684 |
|
|
source_location location)
|
1685 |
|
|
{
|
1686 |
|
|
cpp_num result, sub;
|
1687 |
|
|
cpp_num_part mask;
|
1688 |
|
|
bool unsignedp = lhs.unsignedp || rhs.unsignedp;
|
1689 |
|
|
bool negate = false, lhs_neg = false;
|
1690 |
|
|
size_t i, precision = CPP_OPTION (pfile, precision);
|
1691 |
|
|
|
1692 |
|
|
/* Prepare for unsigned division. */
|
1693 |
|
|
if (!unsignedp)
|
1694 |
|
|
{
|
1695 |
|
|
if (!num_positive (lhs, precision))
|
1696 |
|
|
negate = !negate, lhs_neg = true, lhs = num_negate (lhs, precision);
|
1697 |
|
|
if (!num_positive (rhs, precision))
|
1698 |
|
|
negate = !negate, rhs = num_negate (rhs, precision);
|
1699 |
|
|
}
|
1700 |
|
|
|
1701 |
|
|
/* Find the high bit. */
|
1702 |
|
|
if (rhs.high)
|
1703 |
|
|
{
|
1704 |
|
|
i = precision - 1;
|
1705 |
|
|
mask = (cpp_num_part) 1 << (i - PART_PRECISION);
|
1706 |
|
|
for (; ; i--, mask >>= 1)
|
1707 |
|
|
if (rhs.high & mask)
|
1708 |
|
|
break;
|
1709 |
|
|
}
|
1710 |
|
|
else if (rhs.low)
|
1711 |
|
|
{
|
1712 |
|
|
if (precision > PART_PRECISION)
|
1713 |
|
|
i = precision - PART_PRECISION - 1;
|
1714 |
|
|
else
|
1715 |
|
|
i = precision - 1;
|
1716 |
|
|
mask = (cpp_num_part) 1 << i;
|
1717 |
|
|
for (; ; i--, mask >>= 1)
|
1718 |
|
|
if (rhs.low & mask)
|
1719 |
|
|
break;
|
1720 |
|
|
}
|
1721 |
|
|
else
|
1722 |
|
|
{
|
1723 |
|
|
if (!pfile->state.skip_eval)
|
1724 |
|
|
cpp_error_with_line (pfile, CPP_DL_ERROR, location, 0,
|
1725 |
|
|
"division by zero in #if");
|
1726 |
|
|
return lhs;
|
1727 |
|
|
}
|
1728 |
|
|
|
1729 |
|
|
/* First nonzero bit of RHS is bit I. Do naive division by
|
1730 |
|
|
shifting the RHS fully left, and subtracting from LHS if LHS is
|
1731 |
|
|
at least as big, and then repeating but with one less shift.
|
1732 |
|
|
This is not very efficient, but is easy to understand. */
|
1733 |
|
|
|
1734 |
|
|
rhs.unsignedp = true;
|
1735 |
|
|
lhs.unsignedp = true;
|
1736 |
|
|
i = precision - i - 1;
|
1737 |
|
|
sub = num_lshift (rhs, precision, i);
|
1738 |
|
|
|
1739 |
|
|
result.high = result.low = 0;
|
1740 |
|
|
for (;;)
|
1741 |
|
|
{
|
1742 |
|
|
if (num_greater_eq (lhs, sub, precision))
|
1743 |
|
|
{
|
1744 |
|
|
lhs = num_binary_op (pfile, lhs, sub, CPP_MINUS);
|
1745 |
|
|
if (i >= PART_PRECISION)
|
1746 |
|
|
result.high |= (cpp_num_part) 1 << (i - PART_PRECISION);
|
1747 |
|
|
else
|
1748 |
|
|
result.low |= (cpp_num_part) 1 << i;
|
1749 |
|
|
}
|
1750 |
|
|
if (i-- == 0)
|
1751 |
|
|
break;
|
1752 |
|
|
sub.low = (sub.low >> 1) | (sub.high << (PART_PRECISION - 1));
|
1753 |
|
|
sub.high >>= 1;
|
1754 |
|
|
}
|
1755 |
|
|
|
1756 |
|
|
/* We divide so that the remainder has the sign of the LHS. */
|
1757 |
|
|
if (op == CPP_DIV)
|
1758 |
|
|
{
|
1759 |
|
|
result.unsignedp = unsignedp;
|
1760 |
|
|
result.overflow = false;
|
1761 |
|
|
if (!unsignedp)
|
1762 |
|
|
{
|
1763 |
|
|
if (negate)
|
1764 |
|
|
result = num_negate (result, precision);
|
1765 |
|
|
result.overflow = (num_positive (result, precision) ^ !negate
|
1766 |
|
|
&& !num_zerop (result));
|
1767 |
|
|
}
|
1768 |
|
|
|
1769 |
|
|
return result;
|
1770 |
|
|
}
|
1771 |
|
|
|
1772 |
|
|
/* CPP_MOD. */
|
1773 |
|
|
lhs.unsignedp = unsignedp;
|
1774 |
|
|
lhs.overflow = false;
|
1775 |
|
|
if (lhs_neg)
|
1776 |
|
|
lhs = num_negate (lhs, precision);
|
1777 |
|
|
|
1778 |
|
|
return lhs;
|
1779 |
|
|
}
|