1	/* Parse C expressions for cpplib.
2	Copyright (C) 1987-2024 Free Software Foundation, Inc.
3	Contributed by Per Bothner, 1994.
4
5	This program is free software; you can redistribute it and/or modify it
6	under the terms of the GNU General Public License as published by the
7	Free Software Foundation; either version 3, or (at your option) any
8	later version.
9
10	This program is distributed in the hope that it will be useful,
11	but WITHOUT ANY WARRANTY; without even the implied warranty of
12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	GNU General Public License for more details.
14
15	You should have received a copy of the GNU General Public License
16	along with this program; see the file COPYING3. If not see
17	<http://www.gnu.org/licenses/>. */
18
19	#include "config.h"
20	#include "system.h"
21	#include "cpplib.h"
22	#include "internal.h"
23
24	#define PART_PRECISION (sizeof (cpp_num_part) * CHAR_BIT)
25	#define HALF_MASK (~(cpp_num_part) 0 >> (PART_PRECISION / 2))
26	#define LOW_PART(num_part) (num_part & HALF_MASK)
27	#define HIGH_PART(num_part) (num_part >> (PART_PRECISION / 2))
28
29	struct op
30	{
31	const cpp_token *token; /* The token forming op (for diagnostics). */
32	cpp_num value; /* The value logically "right" of op. */
33	location_t loc; /* The location of this value. */
34	enum cpp_ttype op;
35	};
36
37	/* Some simple utility routines on double integers. */
38	#define num_zerop(num) ((num.low | num.high) == 0)
39	#define num_eq(num1, num2) (num1.low == num2.low && num1.high == num2.high)
40	static bool num_positive (cpp_num, size_t);
41	static bool num_greater_eq (cpp_num, cpp_num, size_t);
42	static cpp_num num_trim (cpp_num, size_t);
43	static cpp_num num_part_mul (cpp_num_part, cpp_num_part);
44
45	static cpp_num num_unary_op (cpp_reader *, cpp_num, enum cpp_ttype);
46	static cpp_num num_binary_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);
47	static cpp_num num_negate (cpp_num, size_t);
48	static cpp_num num_bitwise_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);
49	static cpp_num num_inequality_op (cpp_reader *, cpp_num, cpp_num,
50	enum cpp_ttype);
51	static cpp_num num_equality_op (cpp_reader *, cpp_num, cpp_num,
52	enum cpp_ttype);
53	static cpp_num num_mul (cpp_reader *, cpp_num, cpp_num);
54	static cpp_num num_div_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype,
55	location_t);
56	static cpp_num num_lshift (cpp_num, size_t, size_t);
57	static cpp_num num_rshift (cpp_num, size_t, size_t);
58
59	static cpp_num append_digit (cpp_num, int, int, size_t);
60	static cpp_num parse_defined (cpp_reader *);
61	static cpp_num eval_token (cpp_reader *, const cpp_token *, location_t);
62	static struct op *reduce (cpp_reader *, struct op *, enum cpp_ttype);
63	static unsigned int interpret_float_suffix (cpp_reader *, const uchar *, size_t);
64	static unsigned int interpret_int_suffix (cpp_reader *, const uchar *, size_t);
65	static void check_promotion (cpp_reader *, const struct op *);
66
67	/* Token type abuse to create unary plus and minus operators. */
68	#define CPP_UPLUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 1))
69	#define CPP_UMINUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 2))
70
71	/* With -O2, gcc appears to produce nice code, moving the error
72	message load and subsequent jump completely out of the main path. */
73	#define SYNTAX_ERROR(msgid) \
74	do { cpp_error (pfile, CPP_DL_ERROR, msgid); goto syntax_error; } while(0)
75	#define SYNTAX_ERROR2(msgid, arg) \
76	do { cpp_error (pfile, CPP_DL_ERROR, msgid, arg); goto syntax_error; } \
77	while(0)
78	#define SYNTAX_ERROR_AT(loc, msgid) \
79	do { cpp_error_with_line (pfile, CPP_DL_ERROR, (loc), 0, msgid); goto syntax_error; } \
80	while(0)
81	#define SYNTAX_ERROR2_AT(loc, msgid, arg) \
82	do { cpp_error_with_line (pfile, CPP_DL_ERROR, (loc), 0, msgid, arg); goto syntax_error; } \
83	while(0)
84
85	/* Subroutine of cpp_classify_number. S points to a float suffix of
86	length LEN, possibly zero. Returns 0 for an invalid suffix, or a
87	flag vector (of CPP_N_* bits) describing the suffix. */
88	static unsigned int
89	interpret_float_suffix (cpp_reader *pfile, const uchar *s, size_t len)
90	{
91	size_t orig_len = len;
92	const uchar *orig_s = s;
93	size_t flags;
94	size_t f, d, l, w, q, i, fn, fnx, fn_bits, bf16;
95
96	flags = 0;
97	f = d = l = w = q = i = fn = fnx = fn_bits = bf16 = 0;
98
99	/* The following decimal float suffixes, from TR 24732:2009, TS
100	18661-2:2015 and C23, are supported:
101
102	df, DF - _Decimal32.
103	dd, DD - _Decimal64.
104	dl, DL - _Decimal128.
105
106	The dN and DN suffixes for _DecimalN, and dNx and DNx for
107	_DecimalNx, defined in TS 18661-3:2015, are not supported.
108
109	Fixed-point suffixes, from TR 18037:2008, are supported. They
110	consist of three parts, in order:
111
112	(i) An optional u or U, for unsigned types.
113
114	(ii) An optional h or H, for short types, or l or L, for long
115	types, or ll or LL, for long long types. Use of ll or LL is a
116	GNU extension.
117
118	(iii) r or R, for _Fract types, or k or K, for _Accum types.
119
120	Otherwise the suffix is for a binary or standard floating-point
121	type. Such a suffix, or the absence of a suffix, may be preceded
122	or followed by i, I, j or J, to indicate an imaginary number with
123	the corresponding complex type. The following suffixes for
124	binary or standard floating-point types are supported:
125
126	f, F - float (ISO C and C++).
127	l, L - long double (ISO C and C++).
128	d, D - double, even with the FLOAT_CONST_DECIMAL64 pragma in
129	operation (from TR 24732:2009; the pragma and the suffix
130	are not included in TS 18661-2:2015).
131	w, W - machine-specific type such as __float80 (GNU extension).
132	q, Q - machine-specific type such as __float128 (GNU extension).
133	fN, FN - _FloatN (TS 18661-3:2015).
134	fNx, FNx - _FloatNx (TS 18661-3:2015).
135	bf16, BF16 - std::bfloat16_t (ISO C++23). */
136
137	/* Process decimal float suffixes, which are two letters starting
138	with d or D. Order and case are significant. */
139	if (len == 2 && (*s == 'd' || *s == 'D'))
140	{
141	bool uppercase = (*s == 'D');
142	switch (s[1])
143	{
144	case 'f': return (!uppercase ? (CPP_N_DFLOAT | CPP_N_SMALL): 0); break;
145	case 'F': return (uppercase ? (CPP_N_DFLOAT | CPP_N_SMALL) : 0); break;
146	case 'd': return (!uppercase ? (CPP_N_DFLOAT | CPP_N_MEDIUM): 0); break;
147	case 'D': return (uppercase ? (CPP_N_DFLOAT | CPP_N_MEDIUM) : 0); break;
148	case 'l': return (!uppercase ? (CPP_N_DFLOAT | CPP_N_LARGE) : 0); break;
149	case 'L': return (uppercase ? (CPP_N_DFLOAT | CPP_N_LARGE) : 0); break;
150	default:
151	/* Additional two-character suffixes beginning with D are not
152	for decimal float constants. */
153	break;
154	}
155	}
156
157	if (CPP_OPTION (pfile, ext_numeric_literals))
158	{
159	/* Recognize a fixed-point suffix. */
160	if (len != 0)
161	switch (s[len-1])
162	{
163	case 'k': case 'K': flags = CPP_N_ACCUM; break;
164	case 'r': case 'R': flags = CPP_N_FRACT; break;
165	default: break;
166	}
167
168	/* Continue processing a fixed-point suffix. The suffix is case
169	insensitive except for ll or LL. Order is significant. */
170	if (flags)
171	{
172	if (len == 1)
173	return flags;
174	len--;
175
176	if (*s == 'u' || *s == 'U')
177	{
178	flags |= CPP_N_UNSIGNED;
179	if (len == 1)
180	return flags;
181	len--;
182	s++;
183	}
184
185	switch (*s)
186	{
187	case 'h': case 'H':
188	if (len == 1)
189	return flags |= CPP_N_SMALL;
190	break;
191	case 'l':
192	if (len == 1)
193	return flags |= CPP_N_MEDIUM;
194	if (len == 2 && s[1] == 'l')
195	return flags |= CPP_N_LARGE;
196	break;
197	case 'L':
198	if (len == 1)
199	return flags |= CPP_N_MEDIUM;
200	if (len == 2 && s[1] == 'L')
201	return flags |= CPP_N_LARGE;
202	break;
203	default:
204	break;
205	}
206	/* Anything left at this point is invalid. */
207	return 0;
208	}
209	}
210
211	/* In any remaining valid suffix, the case and order don't matter. */
212	while (len--)
213	{
214	switch (s[0])
215	{
216	case 'f': case 'F':
217	f++;
218	if (len > 0
219	&& s[1] >= '1'
220	&& s[1] <= '9'
221	&& fn_bits == 0)
222	{
223	f--;
224	while (len > 0
225	&& s[1] >= '0'
226	&& s[1] <= '9'
227	&& fn_bits < CPP_FLOATN_MAX)
228	{
229	fn_bits = fn_bits * 10 + (s[1] - '0');
230	len--;
231	s++;
232	}
233	if (len > 0 && s[1] == 'x')
234	{
235	fnx++;
236	len--;
237	s++;
238	}
239	else
240	fn++;
241	}
242	break;
243	case 'b': case 'B':
244	if (len > 2
245	/* Except for bf16 / BF16 where case is significant. */
246	&& s[1] == (s[0] == 'b' ? 'f' : 'F')
247	&& s[2] == '1'
248	&& s[3] == '6')
249	{
250	bf16++;
251	len -= 3;
252	s += 3;
253	break;
254	}
255	return 0;
256	case 'd': case 'D': d++; break;
257	case 'l': case 'L': l++; break;
258	case 'w': case 'W': w++; break;
259	case 'q': case 'Q': q++; break;
260	case 'i': case 'I':
261	case 'j': case 'J': i++; break;
262	default:
263	return 0;
264	}
265	s++;
266	}
267
268	/* Reject any case of multiple suffixes specifying types, multiple
269	suffixes specifying an imaginary constant, _FloatN or _FloatNx
270	suffixes for invalid values of N, and _FloatN suffixes for values
271	of N larger than can be represented in the return value. The
272	caller is responsible for rejecting _FloatN suffixes where
273	_FloatN is not supported on the chosen target. */
274	if (f + d + l + w + q + fn + fnx + bf16 > 1 || i > 1)
275	return 0;
276	if (fn_bits > CPP_FLOATN_MAX)
277	return 0;
278	if (fnx && fn_bits != 32 && fn_bits != 64 && fn_bits != 128)
279	return 0;
280	if (fn && fn_bits != 16 && fn_bits % 32 != 0)
281	return 0;
282	if (fn && fn_bits == 96)
283	return 0;
284
285	if (i)
286	{
287	if (!CPP_OPTION (pfile, ext_numeric_literals))
288	return 0;
289
290	/* In C++14 and up these suffixes are in the standard library, so treat
291	them as user-defined literals. */
292	if (CPP_OPTION (pfile, cplusplus)
293	&& CPP_OPTION (pfile, lang) > CLK_CXX11
294	&& orig_s[0] == 'i'
295	&& (orig_len == 1
296	|| (orig_len == 2
297	&& (orig_s[1] == 'f' || orig_s[1] == 'l'))))
298	return 0;
299	}
300
301	if ((w || q) && !CPP_OPTION (pfile, ext_numeric_literals))
302	return 0;
303
304	return ((i ? CPP_N_IMAGINARY : 0)
305	| (f ? CPP_N_SMALL :
306	d ? CPP_N_MEDIUM :
307	l ? CPP_N_LARGE :
308	w ? CPP_N_MD_W :
309	q ? CPP_N_MD_Q :
310	fn ? CPP_N_FLOATN | (fn_bits << CPP_FLOATN_SHIFT) :
311	fnx ? CPP_N_FLOATNX | (fn_bits << CPP_FLOATN_SHIFT) :
312	bf16 ? CPP_N_BFLOAT16 :
313	CPP_N_DEFAULT));
314	}
315
316	/* Return the classification flags for a float suffix. */
317	unsigned int
318	cpp_interpret_float_suffix (cpp_reader *pfile, const char *s, size_t len)
319	{
320	return interpret_float_suffix (pfile, s: (const unsigned char *)s, len);
321	}
322
323	/* Subroutine of cpp_classify_number. S points to an integer suffix
324	of length LEN, possibly zero. Returns 0 for an invalid suffix, or a
325	flag vector describing the suffix. */
326	static unsigned int
327	interpret_int_suffix (cpp_reader *pfile, const uchar *s, size_t len)
328	{
329	size_t orig_len = len;
330	size_t u, l, i, z, wb;
331
332	u = l = i = z = wb = 0;
333
334	while (len--)
335	switch (s[len])
336	{
337	case 'z': case 'Z': z++; break;
338	case 'u': case 'U': u++; break;
339	case 'i': case 'I':
340	case 'j': case 'J': i++; break;
341	case 'l': case 'L': l++;
342	/* If there are two Ls, they must be adjacent and the same case. */
343	if (l == 2 && s[len] != s[len + 1])
344	return 0;
345	break;
346	case 'b':
347	if (len == 0 || s[len - 1] != 'w')
348	return 0;
349	wb++;
350	len--;
351	break;
352	case 'B':
353	if (len == 0 || s[len - 1] != 'W')
354	return 0;
355	wb++;
356	len--;
357	break;
358	default:
359	return 0;
360	}
361
362	if (l > 2 || u > 1 || i > 1 || z > 1 || wb > 1)
363	return 0;
364
365	if (z)
366	{
367	if (l > 0 || i > 0)
368	return 0;
369	if (!CPP_OPTION (pfile, cplusplus))
370	return 0;
371	}
372
373	if (wb)
374	{
375	if (CPP_OPTION (pfile, cplusplus))
376	return 0;
377	if (l > 0 || i > 0 || z > 0)
378	return 0;
379	}
380
381	if (i)
382	{
383	if (!CPP_OPTION (pfile, ext_numeric_literals))
384	return 0;
385
386	/* In C++14 and up these suffixes are in the standard library, so treat
387	them as user-defined literals. */
388	if (CPP_OPTION (pfile, cplusplus)
389	&& CPP_OPTION (pfile, lang) > CLK_CXX11
390	&& s[0] == 'i'
391	&& (orig_len == 1 || (orig_len == 2 && s[1] == 'l')))
392	return 0;
393	}
394
395	return ((i ? CPP_N_IMAGINARY : 0)
396	| (u ? CPP_N_UNSIGNED : 0)
397	| ((l == 0) ? CPP_N_SMALL
398	: (l == 1) ? CPP_N_MEDIUM : CPP_N_LARGE)
399	| (z ? CPP_N_SIZE_T : 0)
400	| (wb ? CPP_N_BITINT : 0));
401	}
402
403	/* Return the classification flags for an int suffix. */
404	unsigned int
405	cpp_interpret_int_suffix (cpp_reader *pfile, const char *s, size_t len)
406	{
407	return interpret_int_suffix (pfile, s: (const unsigned char *)s, len);
408	}
409
410	/* Return the string type corresponding to the the input user-defined string
411	literal type. If the input type is not a user-defined string literal
412	type return the input type. */
413	enum cpp_ttype
414	cpp_userdef_string_remove_type (enum cpp_ttype type)
415	{
416	if (type == CPP_STRING_USERDEF)
417	return CPP_STRING;
418	else if (type == CPP_WSTRING_USERDEF)
419	return CPP_WSTRING;
420	else if (type == CPP_STRING16_USERDEF)
421	return CPP_STRING16;
422	else if (type == CPP_STRING32_USERDEF)
423	return CPP_STRING32;
424	else if (type == CPP_UTF8STRING_USERDEF)
425	return CPP_UTF8STRING;
426	else
427	return type;
428	}
429
430	/* Return the user-defined string literal type corresponding to the input
431	string type. If the input type is not a string type return the input
432	type. */
433	enum cpp_ttype
434	cpp_userdef_string_add_type (enum cpp_ttype type)
435	{
436	if (type == CPP_STRING)
437	return CPP_STRING_USERDEF;
438	else if (type == CPP_WSTRING)
439	return CPP_WSTRING_USERDEF;
440	else if (type == CPP_STRING16)
441	return CPP_STRING16_USERDEF;
442	else if (type == CPP_STRING32)
443	return CPP_STRING32_USERDEF;
444	else if (type == CPP_UTF8STRING)
445	return CPP_UTF8STRING_USERDEF;
446	else
447	return type;
448	}
449
450	/* Return the char type corresponding to the the input user-defined char
451	literal type. If the input type is not a user-defined char literal
452	type return the input type. */
453	enum cpp_ttype
454	cpp_userdef_char_remove_type (enum cpp_ttype type)
455	{
456	if (type == CPP_CHAR_USERDEF)
457	return CPP_CHAR;
458	else if (type == CPP_WCHAR_USERDEF)
459	return CPP_WCHAR;
460	else if (type == CPP_CHAR16_USERDEF)
461	return CPP_CHAR16;
462	else if (type == CPP_CHAR32_USERDEF)
463	return CPP_CHAR32;
464	else if (type == CPP_UTF8CHAR_USERDEF)
465	return CPP_UTF8CHAR;
466	else
467	return type;
468	}
469
470	/* Return the user-defined char literal type corresponding to the input
471	char type. If the input type is not a char type return the input
472	type. */
473	enum cpp_ttype
474	cpp_userdef_char_add_type (enum cpp_ttype type)
475	{
476	if (type == CPP_CHAR)
477	return CPP_CHAR_USERDEF;
478	else if (type == CPP_WCHAR)
479	return CPP_WCHAR_USERDEF;
480	else if (type == CPP_CHAR16)
481	return CPP_CHAR16_USERDEF;
482	else if (type == CPP_CHAR32)
483	return CPP_CHAR32_USERDEF;
484	else if (type == CPP_UTF8CHAR)
485	return CPP_UTF8CHAR_USERDEF;
486	else
487	return type;
488	}
489
490	/* Return true if the token type is a user-defined string literal. */
491	bool
492	cpp_userdef_string_p (enum cpp_ttype type)
493	{
494	if (type == CPP_STRING_USERDEF
495	|| type == CPP_WSTRING_USERDEF
496	|| type == CPP_STRING16_USERDEF
497	|| type == CPP_STRING32_USERDEF
498	|| type == CPP_UTF8STRING_USERDEF)
499	return true;
500	else
501	return false;
502	}
503
504	/* Return true if the token type is a user-defined char literal. */
505	bool
506	cpp_userdef_char_p (enum cpp_ttype type)
507	{
508	if (type == CPP_CHAR_USERDEF
509	|| type == CPP_WCHAR_USERDEF
510	|| type == CPP_CHAR16_USERDEF
511	|| type == CPP_CHAR32_USERDEF
512	|| type == CPP_UTF8CHAR_USERDEF)
513	return true;
514	else
515	return false;
516	}
517
518	/* Extract the suffix from a user-defined literal string or char. */
519	const char *
520	cpp_get_userdef_suffix (const cpp_token *tok)
521	{
522	unsigned int len = tok->val.str.len;
523	const char *text = (const char *)tok->val.str.text;
524	char delim;
525	unsigned int i;
526	for (i = 0; i < len; ++i)
527	if (text[i] == '\'' || text[i] == '"')
528	break;
529	if (i == len)
530	return text + len;
531	delim = text[i];
532	for (i = len; i > 0; --i)
533	if (text[i - 1] == delim)
534	break;
535	return text + i;
536	}
537
538	/* Categorize numeric constants according to their field (integer,
539	floating point, or invalid), radix (decimal, octal, hexadecimal),
540	and type suffixes.
541
542	TOKEN is the token that represents the numeric constant to
543	classify.
544
545	In C++0X if UD_SUFFIX is non null it will be assigned
546	any unrecognized suffix for a user-defined literal.
547
548	VIRTUAL_LOCATION is the virtual location for TOKEN. */
549	unsigned int
550	cpp_classify_number (cpp_reader *pfile, const cpp_token *token,
551	const char **ud_suffix, location_t virtual_location)
552	{
553	const uchar *str = token->val.str.text;
554	const uchar *limit;
555	unsigned int max_digit, result, radix;
556	enum {NOT_FLOAT = 0, AFTER_POINT, AFTER_EXPON} float_flag;
557	bool seen_digit;
558	bool seen_digit_sep;
559
560	if (ud_suffix)
561	*ud_suffix = NULL;
562
563	/* If the lexer has done its job, length one can only be a single
564	digit. Fast-path this very common case. */
565	if (token->val.str.len == 1)
566	return CPP_N_INTEGER | CPP_N_SMALL | CPP_N_DECIMAL;
567
568	limit = str + token->val.str.len;
569	float_flag = NOT_FLOAT;
570	max_digit = 0;
571	radix = 10;
572	seen_digit = false;
573	seen_digit_sep = false;
574
575	/* First, interpret the radix. */
576	if (*str == '0')
577	{
578	radix = 8;
579	str++;
580
581	/* Require at least one hex digit to classify it as hex. */
582	if (*str == 'x' || *str == 'X')
583	{
584	if (str[1] == '.' || ISXDIGIT (str[1]))
585	{
586	radix = 16;
587	str++;
588	}
589	else if (DIGIT_SEP (str[1]))
590	SYNTAX_ERROR_AT (virtual_location,
591	"digit separator after base indicator");
592	}
593	else if (*str == 'b' || *str == 'B')
594	{
595	if (str[1] == '0' || str[1] == '1')
596	{
597	radix = 2;
598	str++;
599	}
600	else if (DIGIT_SEP (str[1]))
601	SYNTAX_ERROR_AT (virtual_location,
602	"digit separator after base indicator");
603	}
604	}
605
606	/* Now scan for a well-formed integer or float. */
607	for (;;)
608	{
609	unsigned int c = *str++;
610
611	if (ISDIGIT (c) || (ISXDIGIT (c) && radix == 16))
612	{
613	seen_digit_sep = false;
614	seen_digit = true;
615	c = hex_value (c);
616	if (c > max_digit)
617	max_digit = c;
618	}
619	else if (DIGIT_SEP (c))
620	seen_digit_sep = true;
621	else if (c == '.')
622	{
623	if (seen_digit_sep || DIGIT_SEP (*str))
624	SYNTAX_ERROR_AT (virtual_location,
625	"digit separator adjacent to decimal point");
626	seen_digit_sep = false;
627	if (float_flag == NOT_FLOAT)
628	float_flag = AFTER_POINT;
629	else
630	SYNTAX_ERROR_AT (virtual_location,
631	"too many decimal points in number");
632	}
633	else if ((radix <= 10 && (c == 'e' || c == 'E'))
634	|| (radix == 16 && (c == 'p' || c == 'P')))
635	{
636	if (seen_digit_sep || DIGIT_SEP (*str))
637	SYNTAX_ERROR_AT (virtual_location,
638	"digit separator adjacent to exponent");
639	float_flag = AFTER_EXPON;
640	break;
641	}
642	else
643	{
644	/* Start of suffix. */
645	str--;
646	break;
647	}
648	}
649
650	if (seen_digit_sep && float_flag != AFTER_EXPON)
651	SYNTAX_ERROR_AT (virtual_location,
652	"digit separator outside digit sequence");
653
654	/* The suffix may be for decimal fixed-point constants without exponent. */
655	if (radix != 16 && float_flag == NOT_FLOAT)
656	{
657	result = interpret_float_suffix (pfile, s: str, len: limit - str);
658	if ((result & CPP_N_FRACT) || (result & CPP_N_ACCUM))
659	{
660	result |= CPP_N_FLOATING;
661	/* We need to restore the radix to 10, if the radix is 8. */
662	if (radix == 8)
663	radix = 10;
664
665	if (CPP_PEDANTIC (pfile))
666	cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
667	msgid: "fixed-point constants are a GCC extension");
668	goto syntax_ok;
669	}
670	else
671	result = 0;
672	}
673
674	if (float_flag != NOT_FLOAT && radix == 8)
675	radix = 10;
676
677	if (max_digit >= radix)
678	{
679	if (radix == 2)
680	SYNTAX_ERROR2_AT (virtual_location,
681	"invalid digit \"%c\" in binary constant", '0' + max_digit);
682	else
683	SYNTAX_ERROR2_AT (virtual_location,
684	"invalid digit \"%c\" in octal constant", '0' + max_digit);
685	}
686
687	if (float_flag != NOT_FLOAT)
688	{
689	if (radix == 2)
690	{
691	cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
692	msgid: "invalid prefix \"0b\" for floating constant");
693	return CPP_N_INVALID;
694	}
695
696	if (radix == 16 && !seen_digit)
697	SYNTAX_ERROR_AT (virtual_location,
698	"no digits in hexadecimal floating constant");
699
700	if (radix == 16 && CPP_PEDANTIC (pfile)
701	&& !CPP_OPTION (pfile, extended_numbers))
702	{
703	if (CPP_OPTION (pfile, cplusplus))
704	cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
705	msgid: "use of C++17 hexadecimal floating constant");
706	else
707	cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
708	msgid: "use of C99 hexadecimal floating constant");
709	}
710
711	if (float_flag == AFTER_EXPON)
712	{
713	if (*str == '+' || *str == '-')
714	str++;
715
716	/* Exponent is decimal, even if string is a hex float. */
717	if (!ISDIGIT (*str))
718	{
719	if (DIGIT_SEP (*str))
720	SYNTAX_ERROR_AT (virtual_location,
721	"digit separator adjacent to exponent");
722	else
723	SYNTAX_ERROR_AT (virtual_location, "exponent has no digits");
724	}
725	do
726	{
727	seen_digit_sep = DIGIT_SEP (*str);
728	str++;
729	}
730	while (ISDIGIT (*str) || DIGIT_SEP (*str));
731	}
732	else if (radix == 16)
733	SYNTAX_ERROR_AT (virtual_location,
734	"hexadecimal floating constants require an exponent");
735
736	if (seen_digit_sep)
737	SYNTAX_ERROR_AT (virtual_location,
738	"digit separator outside digit sequence");
739
740	result = interpret_float_suffix (pfile, s: str, len: limit - str);
741	if (result == 0)
742	{
743	if (CPP_OPTION (pfile, user_literals))
744	{
745	if (ud_suffix)
746	*ud_suffix = (const char *) str;
747	result = CPP_N_LARGE | CPP_N_USERDEF;
748	}
749	else
750	{
751	cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
752	msgid: "invalid suffix \"%.*s\" on floating constant",
753	(int) (limit - str), str);
754	return CPP_N_INVALID;
755	}
756	}
757
758	/* Traditional C didn't accept any floating suffixes. */
759	if (limit != str
760	&& CPP_WTRADITIONAL (pfile)
761	&& ! cpp_sys_macro_p (pfile))
762	cpp_warning_with_line (pfile, CPP_W_TRADITIONAL, virtual_location, 0,
763	msgid: "traditional C rejects the \"%.*s\" suffix",
764	(int) (limit - str), str);
765
766	/* A suffix for double is a GCC extension via decimal float support.
767	If the suffix also specifies an imaginary value we'll catch that
768	later. */
769	if ((result == CPP_N_MEDIUM) && CPP_PEDANTIC (pfile))
770	cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
771	msgid: "suffix for double constant is a GCC extension");
772
773	/* Radix must be 10 for decimal floats. */
774	if ((result & CPP_N_DFLOAT) && radix != 10)
775	{
776	cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
777	msgid: "invalid suffix \"%.*s\" with hexadecimal floating constant",
778	(int) (limit - str), str);
779	return CPP_N_INVALID;
780	}
781
782	if ((result & (CPP_N_FRACT | CPP_N_ACCUM)) && CPP_PEDANTIC (pfile))
783	cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
784	msgid: "fixed-point constants are a GCC extension");
785
786	if (result & CPP_N_DFLOAT)
787	{
788	if (CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, dfp_constants))
789	cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
790	msgid: "decimal float constants are a C23 feature");
791	else if (CPP_OPTION (pfile, cpp_warn_c11_c23_compat) > 0)
792	cpp_warning_with_line (pfile, CPP_W_C11_C23_COMPAT,
793	virtual_location, 0,
794	msgid: "decimal float constants are a C23 feature");
795	}
796
797	result |= CPP_N_FLOATING;
798	}
799	else
800	{
801	result = interpret_int_suffix (pfile, s: str, len: limit - str);
802	if (result == 0)
803	{
804	if (CPP_OPTION (pfile, user_literals))
805	{
806	if (ud_suffix)
807	*ud_suffix = (const char *) str;
808	result = CPP_N_UNSIGNED | CPP_N_LARGE | CPP_N_USERDEF;
809	}
810	else
811	{
812	cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
813	msgid: "invalid suffix \"%.*s\" on integer constant",
814	(int) (limit - str), str);
815	return CPP_N_INVALID;
816	}
817	}
818
819	/* Traditional C only accepted the 'L' suffix.
820	Suppress warning about 'LL' with -Wno-long-long. */
821	if (CPP_WTRADITIONAL (pfile) && ! cpp_sys_macro_p (pfile))
822	{
823	int u_or_i = (result & (CPP_N_UNSIGNED|CPP_N_IMAGINARY));
824	int large = (result & CPP_N_WIDTH) == CPP_N_LARGE
825	&& CPP_OPTION (pfile, cpp_warn_long_long);
826
827	if (u_or_i || large)
828	cpp_warning_with_line (pfile, large ? CPP_W_LONG_LONG : CPP_W_TRADITIONAL,
829	virtual_location, 0,
830	msgid: "traditional C rejects the \"%.*s\" suffix",
831	(int) (limit - str), str);
832	}
833
834	if ((result & CPP_N_WIDTH) == CPP_N_LARGE
835	&& CPP_OPTION (pfile, cpp_warn_long_long))
836	{
837	const char *message = CPP_OPTION (pfile, cplusplus)
838	? N_("use of C++11 long long integer constant")
839	: N_("use of C99 long long integer constant");
840
841	if (CPP_OPTION (pfile, c99))
842	cpp_warning_with_line (pfile, CPP_W_LONG_LONG, virtual_location,
843	0, msgid: message);
844	else
845	cpp_pedwarning_with_line (pfile, CPP_W_LONG_LONG,
846	virtual_location, 0, msgid: message);
847	}
848
849	if ((result & CPP_N_SIZE_T) == CPP_N_SIZE_T
850	&& !CPP_OPTION (pfile, size_t_literals))
851	{
852	const char *message = (result & CPP_N_UNSIGNED) == CPP_N_UNSIGNED
853	? N_("use of C++23 %<size_t%> integer constant")
854	: N_("use of C++23 %<make_signed_t<size_t>%> integer constant");
855	cpp_warning_with_line (pfile, CPP_W_SIZE_T_LITERALS,
856	virtual_location, 0, msgid: message);
857	}
858
859	if ((result & CPP_N_BITINT) != 0
860	&& CPP_OPTION (pfile, cpp_warn_c11_c23_compat) != 0)
861	{
862	if (CPP_OPTION (pfile, cpp_warn_c11_c23_compat) > 0)
863	{
864	const char *message = N_("ISO C does not support literal "
865	"%<wb%> suffixes before C23");
866	if (CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, true_false))
867	cpp_pedwarning_with_line (pfile, CPP_W_C11_C23_COMPAT,
868	virtual_location, 0, msgid: message);
869	else
870	cpp_warning_with_line (pfile, CPP_W_C11_C23_COMPAT,
871	virtual_location, 0, msgid: message);
872	}
873	else if (CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, true_false))
874	{
875	const char *message = N_("ISO C does not support literal "
876	"%<wb%> suffixes before C23");
877	cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
878	msgid: message);
879	}
880	}
881
882	result |= CPP_N_INTEGER;
883	}
884
885	syntax_ok:
886	if ((result & CPP_N_IMAGINARY) && CPP_PEDANTIC (pfile))
887	cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
888	msgid: "imaginary constants are a GCC extension");
889	if (radix == 2)
890	{
891	if (!CPP_OPTION (pfile, binary_constants)
892	&& CPP_PEDANTIC (pfile))
893	cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
894	CPP_OPTION (pfile, cplusplus)
895	? N_("binary constants are a C++14 feature "
896	"or GCC extension")
897	: N_("binary constants are a C23 feature "
898	"or GCC extension"));
899	else if (CPP_OPTION (pfile, cpp_warn_c11_c23_compat) > 0)
900	cpp_warning_with_line (pfile, CPP_W_C11_C23_COMPAT,
901	virtual_location, 0,
902	msgid: "binary constants are a C23 feature");
903	}
904
905	if (radix == 10)
906	result |= CPP_N_DECIMAL;
907	else if (radix == 16)
908	result |= CPP_N_HEX;
909	else if (radix == 2)
910	result |= CPP_N_BINARY;
911	else
912	result |= CPP_N_OCTAL;
913
914	return result;
915
916	syntax_error:
917	return CPP_N_INVALID;
918	}
919
920	/* cpp_interpret_integer converts an integer constant into a cpp_num,
921	of precision options->precision.
922
923	We do not provide any interface for decimal->float conversion,
924	because the preprocessor doesn't need it and we don't want to
925	drag in GCC's floating point emulator. */
926	cpp_num
927	cpp_interpret_integer (cpp_reader *pfile, const cpp_token *token,
928	unsigned int type)
929	{
930	const uchar *p, *end;
931	cpp_num result;
932
933	result.low = 0;
934	result.high = 0;
935	result.unsignedp = !!(type & CPP_N_UNSIGNED);
936	result.overflow = false;
937
938	p = token->val.str.text;
939	end = p + token->val.str.len;
940
941	/* Common case of a single digit. */
942	if (token->val.str.len == 1)
943	result.low = p[0] - '0';
944	else
945	{
946	cpp_num_part max;
947	size_t precision = CPP_OPTION (pfile, precision);
948	unsigned int base = 10, c = 0;
949	bool overflow = false;
950
951	if ((type & CPP_N_RADIX) == CPP_N_OCTAL)
952	{
953	base = 8;
954	p++;
955	}
956	else if ((type & CPP_N_RADIX) == CPP_N_HEX)
957	{
958	base = 16;
959	p += 2;
960	}
961	else if ((type & CPP_N_RADIX) == CPP_N_BINARY)
962	{
963	base = 2;
964	p += 2;
965	}
966
967	/* We can add a digit to numbers strictly less than this without
968	needing the precision and slowness of double integers. */
969	max = ~(cpp_num_part) 0;
970	if (precision < PART_PRECISION)
971	max >>= PART_PRECISION - precision;
972	max = (max - base + 1) / base + 1;
973
974	for (; p < end; p++)
975	{
976	c = *p;
977
978	if (ISDIGIT (c) || (base == 16 && ISXDIGIT (c)))
979	c = hex_value (c);
980	else if (DIGIT_SEP (c))
981	continue;
982	else
983	break;
984
985	/* Strict inequality for when max is set to zero. */
986	if (result.low < max)
987	result.low = result.low * base + c;
988	else
989	{
990	result = append_digit (result, c, base, precision);
991	overflow |= result.overflow;
992	max = 0;
993	}
994	}
995
996	if (overflow && !(type & CPP_N_USERDEF))
997	cpp_error (pfile, CPP_DL_PEDWARN,
998	msgid: "integer constant is too large for its type");
999	/* If too big to be signed, consider it unsigned. Only warn for
1000	decimal numbers. Traditional numbers were always signed (but
1001	we still honor an explicit U suffix); but we only have
1002	traditional semantics in directives. */
1003	else if (!result.unsignedp
1004	&& !(CPP_OPTION (pfile, traditional)
1005	&& pfile->state.in_directive)
1006	&& !num_positive (result, precision))
1007	{
1008	/* This is for constants within the range of uintmax_t but
1009	not that of intmax_t. For such decimal constants, a
1010	diagnostic is required for C99 as the selected type must
1011	be signed and not having a type is a constraint violation
1012	(DR#298, TC3), so this must be a pedwarn. For C90,
1013	unsigned long is specified to be used for a constant that
1014	does not fit in signed long; if uintmax_t has the same
1015	range as unsigned long this means only a warning is
1016	appropriate here. C90 permits the preprocessor to use a
1017	wider range than unsigned long in the compiler, so if
1018	uintmax_t is wider than unsigned long no diagnostic is
1019	required for such constants in preprocessor #if
1020	expressions and the compiler will pedwarn for such
1021	constants outside the range of unsigned long that reach
1022	the compiler so a diagnostic is not required there
1023	either; thus, pedwarn for C99 but use a plain warning for
1024	C90. */
1025	if (base == 10)
1026	cpp_error (pfile, (CPP_OPTION (pfile, c99)
1027	? CPP_DL_PEDWARN
1028	: CPP_DL_WARNING),
1029	msgid: "integer constant is so large that it is unsigned");
1030	result.unsignedp = true;
1031	}
1032	}
1033
1034	return result;
1035	}
1036
1037	/* Append DIGIT to NUM, a number of PRECISION bits being read in base BASE. */
1038	static cpp_num
1039	append_digit (cpp_num num, int digit, int base, size_t precision)
1040	{
1041	cpp_num result;
1042	unsigned int shift;
1043	bool overflow;
1044	cpp_num_part add_high, add_low;
1045
1046	/* Multiply by 2, 8 or 16. Catching this overflow here means we don't
1047	need to worry about add_high overflowing. */
1048	switch (base)
1049	{
1050	case 2:
1051	shift = 1;
1052	break;
1053
1054	case 16:
1055	shift = 4;
1056	break;
1057
1058	default:
1059	shift = 3;
1060	}
1061	overflow = !!(num.high >> (PART_PRECISION - shift));
1062	result.high = num.high << shift;
1063	result.low = num.low << shift;
1064	result.high |= num.low >> (PART_PRECISION - shift);
1065	result.unsignedp = num.unsignedp;
1066
1067	if (base == 10)
1068	{
1069	add_low = num.low << 1;
1070	add_high = (num.high << 1) + (num.low >> (PART_PRECISION - 1));
1071	}
1072	else
1073	add_high = add_low = 0;
1074
1075	if (add_low + digit < add_low)
1076	add_high++;
1077	add_low += digit;
1078
1079	if (result.low + add_low < result.low)
1080	add_high++;
1081	if (result.high + add_high < result.high)
1082	overflow = true;
1083
1084	result.low += add_low;
1085	result.high += add_high;
1086	result.overflow = overflow;
1087
1088	/* The above code catches overflow of a cpp_num type. This catches
1089	overflow of the (possibly shorter) target precision. */
1090	num.low = result.low;
1091	num.high = result.high;
1092	result = num_trim (result, precision);
1093	if (!num_eq (result, num))
1094	result.overflow = true;
1095
1096	return result;
1097	}
1098
1099	/* Handle meeting "defined" in a preprocessor expression. */
1100	static cpp_num
1101	parse_defined (cpp_reader *pfile)
1102	{
1103	cpp_num result;
1104	int paren = 0;
1105	cpp_hashnode *node = 0;
1106	const cpp_token *token;
1107	cpp_context *initial_context = pfile->context;
1108
1109	/* Don't expand macros. */
1110	pfile->state.prevent_expansion++;
1111
1112	token = cpp_get_token (pfile);
1113	if (token->type == CPP_OPEN_PAREN)
1114	{
1115	paren = 1;
1116	token = cpp_get_token (pfile);
1117	}
1118
1119	if (token->type == CPP_NAME)
1120	{
1121	node = token->val.node.node;
1122	if (paren && cpp_get_token (pfile)->type != CPP_CLOSE_PAREN)
1123	{
1124	cpp_error (pfile, CPP_DL_ERROR, msgid: "missing ')' after \"defined\"");
1125	node = 0;
1126	}
1127	}
1128	else
1129	{
1130	cpp_error (pfile, CPP_DL_ERROR,
1131	msgid: "operator \"defined\" requires an identifier");
1132	if (token->flags & NAMED_OP)
1133	{
1134	cpp_token op;
1135
1136	op.flags = 0;
1137	op.type = token->type;
1138	cpp_error (pfile, CPP_DL_ERROR,
1139	msgid: "(\"%s\" is an alternative token for \"%s\" in C++)",
1140	cpp_token_as_text (pfile, token),
1141	cpp_token_as_text (pfile, &op));
1142	}
1143	}
1144
1145	bool is_defined = false;
1146	if (node)
1147	{
1148	if ((pfile->context != initial_context
1149	|| initial_context != &pfile->base_context)
1150	&& CPP_OPTION (pfile, warn_expansion_to_defined))
1151	cpp_pedwarning (pfile, CPP_W_EXPANSION_TO_DEFINED,
1152	msgid: "this use of \"defined\" may not be portable");
1153	is_defined = _cpp_defined_macro_p (node);
1154	if (!_cpp_maybe_notify_macro_use (pfile, node, loc: token->src_loc))
1155	/* It wasn't a macro after all. */
1156	is_defined = false;
1157	_cpp_mark_macro_used (node);
1158
1159	/* A possible controlling macro of the form #if !defined ().
1160	_cpp_parse_expr checks there was no other junk on the line. */
1161	pfile->mi_ind_cmacro = node;
1162	}
1163
1164	pfile->state.prevent_expansion--;
1165
1166	/* Do not treat conditional macros as being defined. This is due to the
1167	powerpc port using conditional macros for 'vector', 'bool', and 'pixel'
1168	to act as conditional keywords. This messes up tests like #ifndef
1169	bool. */
1170	result.unsignedp = false;
1171	result.high = 0;
1172	result.overflow = false;
1173	result.low = is_defined;
1174	return result;
1175	}
1176
1177	/* Convert a token into a CPP_NUMBER (an interpreted preprocessing
1178	number or character constant, or the result of the "defined" or "#"
1179	operators). */
1180	static cpp_num
1181	eval_token (cpp_reader *pfile, const cpp_token *token,
1182	location_t virtual_location)
1183	{
1184	cpp_num result;
1185	unsigned int temp;
1186	int unsignedp = 0;
1187
1188	result.unsignedp = false;
1189	result.overflow = false;
1190
1191	switch (token->type)
1192	{
1193	case CPP_NUMBER:
1194	temp = cpp_classify_number (pfile, token, NULL, virtual_location);
1195	if (temp & CPP_N_USERDEF)
1196	cpp_error (pfile, CPP_DL_ERROR,
1197	msgid: "user-defined literal in preprocessor expression");
1198	switch (temp & CPP_N_CATEGORY)
1199	{
1200	case CPP_N_FLOATING:
1201	cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
1202	msgid: "floating constant in preprocessor expression");
1203	break;
1204	case CPP_N_INTEGER:
1205	if (!(temp & CPP_N_IMAGINARY))
1206	return cpp_interpret_integer (pfile, token, type: temp);
1207	cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
1208	msgid: "imaginary number in preprocessor expression");
1209	break;
1210
1211	case CPP_N_INVALID:
1212	/* Error already issued. */
1213	break;
1214	}
1215	result.high = result.low = 0;
1216	break;
1217
1218	case CPP_WCHAR:
1219	case CPP_CHAR:
1220	case CPP_CHAR16:
1221	case CPP_CHAR32:
1222	case CPP_UTF8CHAR:
1223	{
1224	cppchar_t cc = cpp_interpret_charconst (pfile, token,
1225	&temp, &unsignedp);
1226
1227	result.high = 0;
1228	result.low = cc;
1229	/* Sign-extend the result if necessary. */
1230	if (!unsignedp && (cppchar_signed_t) cc < 0)
1231	{
1232	if (PART_PRECISION > BITS_PER_CPPCHAR_T)
1233	result.low |= ~(~(cpp_num_part) 0
1234	>> (PART_PRECISION - BITS_PER_CPPCHAR_T));
1235	result.high = ~(cpp_num_part) 0;
1236	result = num_trim (result, CPP_OPTION (pfile, precision));
1237	}
1238	}
1239	break;
1240
1241	case CPP_NAME:
1242	if (token->val.node.node == pfile->spec_nodes.n_defined)
1243	return parse_defined (pfile);
1244	else if (CPP_OPTION (pfile, true_false)
1245	&& (token->val.node.node == pfile->spec_nodes.n_true
1246	|| token->val.node.node == pfile->spec_nodes.n_false))
1247	{
1248	result.high = 0;
1249	result.low = (token->val.node.node == pfile->spec_nodes.n_true);
1250	}
1251	else
1252	{
1253	result.high = 0;
1254	result.low = 0;
1255	if (CPP_OPTION (pfile, warn_undef) && !pfile->state.skip_eval)
1256	cpp_warning_with_line (pfile, CPP_W_UNDEF, virtual_location, 0,
1257	msgid: "\"%s\" is not defined, evaluates to 0",
1258	NODE_NAME (token->val.node.node));
1259	}
1260	break;
1261
1262	case CPP_HASH:
1263	if (!pfile->state.skipping)
1264	{
1265	/* A pedantic warning takes precedence over a deprecated
1266	warning here. */
1267	if (CPP_PEDANTIC (pfile))
1268	cpp_error_with_line (pfile, CPP_DL_PEDWARN,
1269	virtual_location, 0,
1270	msgid: "assertions are a GCC extension");
1271	else if (CPP_OPTION (pfile, cpp_warn_deprecated))
1272	cpp_warning_with_line (pfile, CPP_W_DEPRECATED, virtual_location, 0,
1273	msgid: "assertions are a deprecated extension");
1274	}
1275	_cpp_test_assertion (pfile, &temp);
1276	result.high = 0;
1277	result.low = temp;
1278	break;
1279
1280	default:
1281	abort ();
1282	}
1283
1284	result.unsignedp = !!unsignedp;
1285	return result;
1286	}
1287
1288	/* Operator precedence and flags table.
1289
1290	After an operator is returned from the lexer, if it has priority less
1291	than the operator on the top of the stack, we reduce the stack by one
1292	operator and repeat the test. Since equal priorities do not reduce,
1293	this is naturally right-associative.
1294
1295	We handle left-associative operators by decrementing the priority of
1296	just-lexed operators by one, but retaining the priority of operators
1297	already on the stack.
1298
1299	The remaining cases are '(' and ')'. We handle '(' by skipping the
1300	reduction phase completely. ')' is given lower priority than
1301	everything else, including '(', effectively forcing a reduction of the
1302	parenthesized expression. If there is a matching '(', the routine
1303	reduce() exits immediately. If the normal exit route sees a ')', then
1304	there cannot have been a matching '(' and an error message is output.
1305
1306	The parser assumes all shifted operators require a left operand unless
1307	the flag NO_L_OPERAND is set. These semantics are automatic; any
1308	extra semantics need to be handled with operator-specific code. */
1309
1310	/* Flags. If CHECK_PROMOTION, we warn if the effective sign of an
1311	operand changes because of integer promotions. */
1312	#define NO_L_OPERAND (1 << 0)
1313	#define LEFT_ASSOC (1 << 1)
1314	#define CHECK_PROMOTION (1 << 2)
1315
1316	/* Operator to priority map. Must be in the same order as the first
1317	N entries of enum cpp_ttype. */
1318	static const struct cpp_operator
1319	{
1320	uchar prio;
1321	uchar flags;
1322	} optab[] =
1323	{
1324	/* EQ */ {.prio: 0, .flags: 0}, /* Shouldn't happen. */
1325	/* NOT */ {.prio: 16, NO_L_OPERAND},
1326	/* GREATER */ {.prio: 12, LEFT_ASSOC | CHECK_PROMOTION},
1327	/* LESS */ {.prio: 12, LEFT_ASSOC | CHECK_PROMOTION},
1328	/* PLUS */ {.prio: 14, LEFT_ASSOC | CHECK_PROMOTION},
1329	/* MINUS */ {.prio: 14, LEFT_ASSOC | CHECK_PROMOTION},
1330	/* MULT */ {.prio: 15, LEFT_ASSOC | CHECK_PROMOTION},
1331	/* DIV */ {.prio: 15, LEFT_ASSOC | CHECK_PROMOTION},
1332	/* MOD */ {.prio: 15, LEFT_ASSOC | CHECK_PROMOTION},
1333	/* AND */ {.prio: 9, LEFT_ASSOC | CHECK_PROMOTION},
1334	/* OR */ {.prio: 7, LEFT_ASSOC | CHECK_PROMOTION},
1335	/* XOR */ {.prio: 8, LEFT_ASSOC | CHECK_PROMOTION},
1336	/* RSHIFT */ {.prio: 13, LEFT_ASSOC},
1337	/* LSHIFT */ {.prio: 13, LEFT_ASSOC},
1338
1339	/* COMPL */ {.prio: 16, NO_L_OPERAND},
1340	/* AND_AND */ {.prio: 6, LEFT_ASSOC},
1341	/* OR_OR */ {.prio: 5, LEFT_ASSOC},
1342	/* Note that QUERY, COLON, and COMMA must have the same precedence.
1343	However, there are some special cases for these in reduce(). */
1344	/* QUERY */ {.prio: 4, .flags: 0},
1345	/* COLON */ {.prio: 4, LEFT_ASSOC | CHECK_PROMOTION},
1346	/* COMMA */ {.prio: 4, LEFT_ASSOC},
1347	/* OPEN_PAREN */ {.prio: 1, NO_L_OPERAND},
1348	/* CLOSE_PAREN */ {.prio: 0, .flags: 0},
1349	/* EOF */ {.prio: 0, .flags: 0},
1350	/* EQ_EQ */ {.prio: 11, LEFT_ASSOC},
1351	/* NOT_EQ */ {.prio: 11, LEFT_ASSOC},
1352	/* GREATER_EQ */ {.prio: 12, LEFT_ASSOC | CHECK_PROMOTION},
1353	/* LESS_EQ */ {.prio: 12, LEFT_ASSOC | CHECK_PROMOTION},
1354	/* UPLUS */ {.prio: 16, NO_L_OPERAND},
1355	/* UMINUS */ {.prio: 16, NO_L_OPERAND}
1356	};
1357
1358	/* Parse and evaluate a C expression, reading from PFILE.
1359	Returns the truth value of the expression.
1360
1361	The implementation is an operator precedence parser, i.e. a
1362	bottom-up parser, using a stack for not-yet-reduced tokens.
1363
1364	The stack base is op_stack, and the current stack pointer is 'top'.
1365	There is a stack element for each operator (only), and the most
1366	recently pushed operator is 'top->op'. An operand (value) is
1367	stored in the 'value' field of the stack element of the operator
1368	that precedes it. */
1369	bool
1370	_cpp_parse_expr (cpp_reader *pfile, bool is_if)
1371	{
1372	struct op *top = pfile->op_stack;
1373	unsigned int lex_count;
1374	bool saw_leading_not, want_value = true;
1375	location_t virtual_location = 0;
1376
1377	pfile->state.skip_eval = 0;
1378
1379	/* Set up detection of #if ! defined(). */
1380	pfile->mi_ind_cmacro = 0;
1381	saw_leading_not = false;
1382	lex_count = 0;
1383
1384	/* Lowest priority operator prevents further reductions. */
1385	top->op = CPP_EOF;
1386
1387	for (;;)
1388	{
1389	struct op op;
1390
1391	lex_count++;
1392	op.token = cpp_get_token_with_location (pfile, &virtual_location);
1393	op.op = op.token->type;
1394	op.loc = virtual_location;
1395
1396	switch (op.op)
1397	{
1398	/* These tokens convert into values. */
1399	case CPP_NUMBER:
1400	case CPP_CHAR:
1401	case CPP_WCHAR:
1402	case CPP_CHAR16:
1403	case CPP_CHAR32:
1404	case CPP_UTF8CHAR:
1405	case CPP_NAME:
1406	case CPP_HASH:
1407	if (!want_value)
1408	SYNTAX_ERROR2_AT (op.loc,
1409	"missing binary operator before token \"%s\"",
1410	cpp_token_as_text (pfile, op.token));
1411	want_value = false;
1412	top->value = eval_token (pfile, token: op.token, virtual_location: op.loc);
1413	continue;
1414
1415	case CPP_NOT:
1416	saw_leading_not = lex_count == 1;
1417	break;
1418	case CPP_PLUS:
1419	if (want_value)
1420	op.op = CPP_UPLUS;
1421	break;
1422	case CPP_MINUS:
1423	if (want_value)
1424	op.op = CPP_UMINUS;
1425	break;
1426
1427	case CPP_PADDING:
1428	lex_count--;
1429	continue;
1430
1431	default:
1432	if ((int) op.op <= (int) CPP_EQ || (int) op.op >= (int) CPP_PLUS_EQ)
1433	SYNTAX_ERROR2_AT (op.loc,
1434	"token \"%s\" is not valid in preprocessor expressions",
1435	cpp_token_as_text (pfile, op.token));
1436	break;
1437	}
1438
1439	/* Check we have a value or operator as appropriate. */
1440	if (optab[op.op].flags & NO_L_OPERAND)
1441	{
1442	if (!want_value)
1443	SYNTAX_ERROR2_AT (op.loc,
1444	"missing binary operator before token \"%s\"",
1445	cpp_token_as_text (pfile, op.token));
1446	}
1447	else if (want_value)
1448	{
1449	/* We want a number (or expression) and haven't got one.
1450	Try to emit a specific diagnostic. */
1451	if (op.op == CPP_CLOSE_PAREN && top->op == CPP_OPEN_PAREN)
1452	SYNTAX_ERROR_AT (op.loc,
1453	"missing expression between '(' and ')'");
1454
1455	if (op.op == CPP_EOF && top->op == CPP_EOF)
1456	SYNTAX_ERROR2_AT (op.loc,
1457	"%s with no expression", is_if ? "#if" : "#elif");
1458
1459	if (top->op != CPP_EOF && top->op != CPP_OPEN_PAREN)
1460	SYNTAX_ERROR2_AT (op.loc,
1461	"operator '%s' has no right operand",
1462	cpp_token_as_text (pfile, top->token));
1463	else if (op.op == CPP_CLOSE_PAREN || op.op == CPP_EOF)
1464	/* Complain about missing paren during reduction. */;
1465	else
1466	SYNTAX_ERROR2_AT (op.loc,
1467	"operator '%s' has no left operand",
1468	cpp_token_as_text (pfile, op.token));
1469	}
1470
1471	top = reduce (pfile, top, op.op);
1472	if (!top)
1473	goto syntax_error;
1474
1475	if (op.op == CPP_EOF)
1476	break;
1477
1478	switch (op.op)
1479	{
1480	case CPP_CLOSE_PAREN:
1481	continue;
1482	case CPP_OR_OR:
1483	if (!num_zerop (top->value))
1484	pfile->state.skip_eval++;
1485	break;
1486	case CPP_AND_AND:
1487	case CPP_QUERY:
1488	if (num_zerop (top->value))
1489	pfile->state.skip_eval++;
1490	break;
1491	case CPP_COLON:
1492	if (top->op != CPP_QUERY)
1493	SYNTAX_ERROR_AT (op.loc,
1494	" ':' without preceding '?'");
1495	if (!num_zerop (top[-1].value)) /* Was '?' condition true? */
1496	pfile->state.skip_eval++;
1497	else
1498	pfile->state.skip_eval--;
1499	default:
1500	break;
1501	}
1502
1503	want_value = true;
1504
1505	/* Check for and handle stack overflow. */
1506	if (++top == pfile->op_limit)
1507	top = _cpp_expand_op_stack (pfile);
1508
1509	top->op = op.op;
1510	top->token = op.token;
1511	top->loc = op.loc;
1512	}
1513
1514	/* The controlling macro expression is only valid if we called lex 3
1515	times: <!> <defined expression> and <EOF>. push_conditional ()
1516	checks that we are at top-of-file. */
1517	if (pfile->mi_ind_cmacro && !(saw_leading_not && lex_count == 3))
1518	pfile->mi_ind_cmacro = 0;
1519
1520	if (top != pfile->op_stack)
1521	{
1522	cpp_error_with_line (pfile, CPP_DL_ICE, top->loc, 0,
1523	msgid: "unbalanced stack in %s",
1524	is_if ? "#if" : "#elif");
1525	syntax_error:
1526	return false; /* Return false on syntax error. */
1527	}
1528
1529	return !num_zerop (top->value);
1530	}
1531
1532	/* Reduce the operator / value stack if possible, in preparation for
1533	pushing operator OP. Returns NULL on error, otherwise the top of
1534	the stack. */
1535	static struct op *
1536	reduce (cpp_reader *pfile, struct op *top, enum cpp_ttype op)
1537	{
1538	unsigned int prio;
1539
1540	if (top->op <= CPP_EQ || top->op > CPP_LAST_CPP_OP + 2)
1541	{
1542	bad_op:
1543	cpp_error (pfile, CPP_DL_ICE, msgid: "impossible operator '%u'", top->op);
1544	return 0;
1545	}
1546
1547	if (op == CPP_OPEN_PAREN)
1548	return top;
1549
1550	/* Decrement the priority of left-associative operators to force a
1551	reduction with operators of otherwise equal priority. */
1552	prio = optab[op].prio - ((optab[op].flags & LEFT_ASSOC) != 0);
1553	while (prio < optab[top->op].prio)
1554	{
1555	if (CPP_OPTION (pfile, warn_num_sign_change)
1556	&& optab[top->op].flags & CHECK_PROMOTION)
1557	check_promotion (pfile, top);
1558
1559	switch (top->op)
1560	{
1561	case CPP_UPLUS:
1562	case CPP_UMINUS:
1563	case CPP_NOT:
1564	case CPP_COMPL:
1565	top[-1].value = num_unary_op (pfile, top->value, top->op);
1566	top[-1].loc = top->loc;
1567	break;
1568
1569	case CPP_PLUS:
1570	case CPP_MINUS:
1571	case CPP_RSHIFT:
1572	case CPP_LSHIFT:
1573	case CPP_COMMA:
1574	top[-1].value = num_binary_op (pfile, top[-1].value,
1575	top->value, top->op);
1576	top[-1].loc = top->loc;
1577	break;
1578
1579	case CPP_GREATER:
1580	case CPP_LESS:
1581	case CPP_GREATER_EQ:
1582	case CPP_LESS_EQ:
1583	top[-1].value
1584	= num_inequality_op (pfile, top[-1].value, top->value, top->op);
1585	top[-1].loc = top->loc;
1586	break;
1587
1588	case CPP_EQ_EQ:
1589	case CPP_NOT_EQ:
1590	top[-1].value
1591	= num_equality_op (pfile, top[-1].value, top->value, top->op);
1592	top[-1].loc = top->loc;
1593	break;
1594
1595	case CPP_AND:
1596	case CPP_OR:
1597	case CPP_XOR:
1598	top[-1].value
1599	= num_bitwise_op (pfile, top[-1].value, top->value, top->op);
1600	top[-1].loc = top->loc;
1601	break;
1602
1603	case CPP_MULT:
1604	top[-1].value = num_mul (pfile, top[-1].value, top->value);
1605	top[-1].loc = top->loc;
1606	break;
1607
1608	case CPP_DIV:
1609	case CPP_MOD:
1610	top[-1].value = num_div_op (pfile, top[-1].value,
1611	top->value, top->op, top->loc);
1612	top[-1].loc = top->loc;
1613	break;
1614
1615	case CPP_OR_OR:
1616	top--;
1617	if (!num_zerop (top->value))
1618	pfile->state.skip_eval--;
1619	top->value.low = (!num_zerop (top->value)
1620	|| !num_zerop (top[1].value));
1621	top->value.high = 0;
1622	top->value.unsignedp = false;
1623	top->value.overflow = false;
1624	top->loc = top[1].loc;
1625	continue;
1626
1627	case CPP_AND_AND:
1628	top--;
1629	if (num_zerop (top->value))
1630	pfile->state.skip_eval--;
1631	top->value.low = (!num_zerop (top->value)
1632	&& !num_zerop (top[1].value));
1633	top->value.high = 0;
1634	top->value.unsignedp = false;
1635	top->value.overflow = false;
1636	top->loc = top[1].loc;
1637	continue;
1638
1639	case CPP_OPEN_PAREN:
1640	if (op != CPP_CLOSE_PAREN)
1641	{
1642	cpp_error_with_line (pfile, CPP_DL_ERROR,
1643	top->token->src_loc,
1644	0, msgid: "missing ')' in expression");
1645	return 0;
1646	}
1647	top--;
1648	top->value = top[1].value;
1649	top->loc = top[1].loc;
1650	return top;
1651
1652	case CPP_COLON:
1653	top -= 2;
1654	if (!num_zerop (top->value))
1655	{
1656	pfile->state.skip_eval--;
1657	top->value = top[1].value;
1658	top->loc = top[1].loc;
1659	}
1660	else
1661	{
1662	top->value = top[2].value;
1663	top->loc = top[2].loc;
1664	}
1665	top->value.unsignedp = (top[1].value.unsignedp
1666	|| top[2].value.unsignedp);
1667	continue;
1668
1669	case CPP_QUERY:
1670	/* COMMA and COLON should not reduce a QUERY operator. */
1671	if (op == CPP_COMMA || op == CPP_COLON)
1672	return top;
1673	cpp_error (pfile, CPP_DL_ERROR, msgid: "'?' without following ':'");
1674	return 0;
1675
1676	default:
1677	goto bad_op;
1678	}
1679
1680	top--;
1681	if (top->value.overflow && !pfile->state.skip_eval)
1682	cpp_error (pfile, CPP_DL_PEDWARN,
1683	msgid: "integer overflow in preprocessor expression");
1684	}
1685
1686	if (op == CPP_CLOSE_PAREN)
1687	{
1688	cpp_error (pfile, CPP_DL_ERROR, msgid: "missing '(' in expression");
1689	return 0;
1690	}
1691
1692	return top;
1693	}
1694
1695	/* Returns the position of the old top of stack after expansion. */
1696	struct op *
1697	_cpp_expand_op_stack (cpp_reader *pfile)
1698	{
1699	size_t old_size = (size_t) (pfile->op_limit - pfile->op_stack);
1700	size_t new_size = old_size * 2 + 20;
1701
1702	pfile->op_stack = XRESIZEVEC (struct op, pfile->op_stack, new_size);
1703	pfile->op_limit = pfile->op_stack + new_size;
1704
1705	return pfile->op_stack + old_size;
1706	}
1707
1708	/* Emits a warning if the effective sign of either operand of OP
1709	changes because of integer promotions. */
1710	static void
1711	check_promotion (cpp_reader *pfile, const struct op *op)
1712	{
1713	if (op->value.unsignedp == op[-1].value.unsignedp)
1714	return;
1715
1716	if (op->value.unsignedp)
1717	{
1718	if (!num_positive (op[-1].value, CPP_OPTION (pfile, precision)))
1719	cpp_error_with_line (pfile, CPP_DL_WARNING, op[-1].loc, 0,
1720	msgid: "the left operand of \"%s\" changes sign when promoted",
1721	cpp_token_as_text (pfile, op->token));
1722	}
1723	else if (!num_positive (op->value, CPP_OPTION (pfile, precision)))
1724	cpp_error_with_line (pfile, CPP_DL_WARNING, op->loc, 0,
1725	msgid: "the right operand of \"%s\" changes sign when promoted",
1726	cpp_token_as_text (pfile, op->token));
1727	}
1728
1729	/* Clears the unused high order bits of the number pointed to by PNUM. */
1730	static cpp_num
1731	num_trim (cpp_num num, size_t precision)
1732	{
1733	if (precision > PART_PRECISION)
1734	{
1735	precision -= PART_PRECISION;
1736	if (precision < PART_PRECISION)
1737	num.high &= ((cpp_num_part) 1 << precision) - 1;
1738	}
1739	else
1740	{
1741	if (precision < PART_PRECISION)
1742	num.low &= ((cpp_num_part) 1 << precision) - 1;
1743	num.high = 0;
1744	}
1745
1746	return num;
1747	}
1748
1749	/* True iff A (presumed signed) >= 0. */
1750	static bool
1751	num_positive (cpp_num num, size_t precision)
1752	{
1753	if (precision > PART_PRECISION)
1754	{
1755	precision -= PART_PRECISION;
1756	return (num.high & (cpp_num_part) 1 << (precision - 1)) == 0;
1757	}
1758
1759	return (num.low & (cpp_num_part) 1 << (precision - 1)) == 0;
1760	}
1761
1762	/* Sign extend a number, with PRECISION significant bits and all
1763	others assumed clear, to fill out a cpp_num structure. */
1764	cpp_num
1765	cpp_num_sign_extend (cpp_num num, size_t precision)
1766	{
1767	if (!num.unsignedp)
1768	{
1769	if (precision > PART_PRECISION)
1770	{
1771	precision -= PART_PRECISION;
1772	if (precision < PART_PRECISION
1773	&& (num.high & (cpp_num_part) 1 << (precision - 1)))
1774	num.high |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1775	}
1776	else if (num.low & (cpp_num_part) 1 << (precision - 1))
1777	{
1778	if (precision < PART_PRECISION)
1779	num.low |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1780	num.high = ~(cpp_num_part) 0;
1781	}
1782	}
1783
1784	return num;
1785	}
1786
1787	/* Returns the negative of NUM. */
1788	static cpp_num
1789	num_negate (cpp_num num, size_t precision)
1790	{
1791	cpp_num copy;
1792
1793	copy = num;
1794	num.high = ~num.high;
1795	num.low = ~num.low;
1796	if (++num.low == 0)
1797	num.high++;
1798	num = num_trim (num, precision);
1799	num.overflow = (!num.unsignedp && num_eq (num, copy) && !num_zerop (num));
1800
1801	return num;
1802	}
1803
1804	/* Returns true if A >= B. */
1805	static bool
1806	num_greater_eq (cpp_num pa, cpp_num pb, size_t precision)
1807	{
1808	bool unsignedp;
1809
1810	unsignedp = pa.unsignedp || pb.unsignedp;
1811
1812	if (!unsignedp)
1813	{
1814	/* Both numbers have signed type. If they are of different
1815	sign, the answer is the sign of A. */
1816	unsignedp = num_positive (num: pa, precision);
1817
1818	if (unsignedp != num_positive (num: pb, precision))
1819	return unsignedp;
1820
1821	/* Otherwise we can do an unsigned comparison. */
1822	}
1823
1824	return (pa.high > pb.high) || (pa.high == pb.high && pa.low >= pb.low);
1825	}
1826
1827	/* Returns LHS OP RHS, where OP is a bit-wise operation. */
1828	static cpp_num
1829	num_bitwise_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1830	cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1831	{
1832	lhs.overflow = false;
1833	lhs.unsignedp = lhs.unsignedp || rhs.unsignedp;
1834
1835	/* As excess precision is zeroed, there is no need to num_trim () as
1836	these operations cannot introduce a set bit there. */
1837	if (op == CPP_AND)
1838	{
1839	lhs.low &= rhs.low;
1840	lhs.high &= rhs.high;
1841	}
1842	else if (op == CPP_OR)
1843	{
1844	lhs.low |= rhs.low;
1845	lhs.high |= rhs.high;
1846	}
1847	else
1848	{
1849	lhs.low ^= rhs.low;
1850	lhs.high ^= rhs.high;
1851	}
1852
1853	return lhs;
1854	}
1855
1856	/* Returns LHS OP RHS, where OP is an inequality. */
1857	static cpp_num
1858	num_inequality_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs,
1859	enum cpp_ttype op)
1860	{
1861	bool gte = num_greater_eq (pa: lhs, pb: rhs, CPP_OPTION (pfile, precision));
1862
1863	if (op == CPP_GREATER_EQ)
1864	lhs.low = gte;
1865	else if (op == CPP_LESS)
1866	lhs.low = !gte;
1867	else if (op == CPP_GREATER)
1868	lhs.low = gte && !num_eq (lhs, rhs);
1869	else /* CPP_LESS_EQ. */
1870	lhs.low = !gte || num_eq (lhs, rhs);
1871
1872	lhs.high = 0;
1873	lhs.overflow = false;
1874	lhs.unsignedp = false;
1875	return lhs;
1876	}
1877
1878	/* Returns LHS OP RHS, where OP is == or !=. */
1879	static cpp_num
1880	num_equality_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1881	cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1882	{
1883	/* Work around a 3.0.4 bug; see PR 6950. */
1884	bool eq = num_eq (lhs, rhs);
1885	if (op == CPP_NOT_EQ)
1886	eq = !eq;
1887	lhs.low = eq;
1888	lhs.high = 0;
1889	lhs.overflow = false;
1890	lhs.unsignedp = false;
1891	return lhs;
1892	}
1893
1894	/* Shift NUM, of width PRECISION, right by N bits. */
1895	static cpp_num
1896	num_rshift (cpp_num num, size_t precision, size_t n)
1897	{
1898	cpp_num_part sign_mask;
1899	bool x = num_positive (num, precision);
1900
1901	if (num.unsignedp || x)
1902	sign_mask = 0;
1903	else
1904	sign_mask = ~(cpp_num_part) 0;
1905
1906	if (n >= precision)
1907	num.high = num.low = sign_mask;
1908	else
1909	{
1910	/* Sign-extend. */
1911	if (precision < PART_PRECISION)
1912	num.high = sign_mask, num.low |= sign_mask << precision;
1913	else if (precision < 2 * PART_PRECISION)
1914	num.high |= sign_mask << (precision - PART_PRECISION);
1915
1916	if (n >= PART_PRECISION)
1917	{
1918	n -= PART_PRECISION;
1919	num.low = num.high;
1920	num.high = sign_mask;
1921	}
1922
1923	if (n)
1924	{
1925	num.low = (num.low >> n) | (num.high << (PART_PRECISION - n));
1926	num.high = (num.high >> n) | (sign_mask << (PART_PRECISION - n));
1927	}
1928	}
1929
1930	num = num_trim (num, precision);
1931	num.overflow = false;
1932	return num;
1933	}
1934
1935	/* Shift NUM, of width PRECISION, left by N bits. */
1936	static cpp_num
1937	num_lshift (cpp_num num, size_t precision, size_t n)
1938	{
1939	if (n >= precision)
1940	{
1941	num.overflow = !num.unsignedp && !num_zerop (num);
1942	num.high = num.low = 0;
1943	}
1944	else
1945	{
1946	cpp_num orig, maybe_orig;
1947	size_t m = n;
1948
1949	orig = num;
1950	if (m >= PART_PRECISION)
1951	{
1952	m -= PART_PRECISION;
1953	num.high = num.low;
1954	num.low = 0;
1955	}
1956	if (m)
1957	{
1958	num.high = (num.high << m) | (num.low >> (PART_PRECISION - m));
1959	num.low <<= m;
1960	}
1961	num = num_trim (num, precision);
1962
1963	if (num.unsignedp)
1964	num.overflow = false;
1965	else
1966	{
1967	maybe_orig = num_rshift (num, precision, n);
1968	num.overflow = !num_eq (orig, maybe_orig);
1969	}
1970	}
1971
1972	return num;
1973	}
1974
1975	/* The four unary operators: +, -, ! and ~. */
1976	static cpp_num
1977	num_unary_op (cpp_reader *pfile, cpp_num num, enum cpp_ttype op)
1978	{
1979	switch (op)
1980	{
1981	case CPP_UPLUS:
1982	if (CPP_WTRADITIONAL (pfile) && !pfile->state.skip_eval)
1983	cpp_warning (pfile, CPP_W_TRADITIONAL,
1984	msgid: "traditional C rejects the unary plus operator");
1985	num.overflow = false;
1986	break;
1987
1988	case CPP_UMINUS:
1989	num = num_negate (num, CPP_OPTION (pfile, precision));
1990	break;
1991
1992	case CPP_COMPL:
1993	num.high = ~num.high;
1994	num.low = ~num.low;
1995	num = num_trim (num, CPP_OPTION (pfile, precision));
1996	num.overflow = false;
1997	break;
1998
1999	default: /* case CPP_NOT: */
2000	num.low = num_zerop (num);
2001	num.high = 0;
2002	num.overflow = false;
2003	num.unsignedp = false;
2004	break;
2005	}
2006
2007	return num;
2008	}
2009
2010	/* The various binary operators. */
2011	static cpp_num
2012	num_binary_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
2013	{
2014	cpp_num result;
2015	size_t precision = CPP_OPTION (pfile, precision);
2016	size_t n;
2017
2018	switch (op)
2019	{
2020	/* Shifts. */
2021	case CPP_LSHIFT:
2022	case CPP_RSHIFT:
2023	if (!rhs.unsignedp && !num_positive (num: rhs, precision))
2024	{
2025	/* A negative shift is a positive shift the other way. */
2026	if (op == CPP_LSHIFT)
2027	op = CPP_RSHIFT;
2028	else
2029	op = CPP_LSHIFT;
2030	rhs = num_negate (num: rhs, precision);
2031	}
2032	if (rhs.high)
2033	n = ~0; /* Maximal. */
2034	else
2035	n = rhs.low;
2036	if (op == CPP_LSHIFT)
2037	lhs = num_lshift (num: lhs, precision, n);
2038	else
2039	lhs = num_rshift (num: lhs, precision, n);
2040	break;
2041
2042	/* Arithmetic. */
2043	case CPP_MINUS:
2044	result.low = lhs.low - rhs.low;
2045	result.high = lhs.high - rhs.high;
2046	if (result.low > lhs.low)
2047	result.high--;
2048	result.unsignedp = lhs.unsignedp || rhs.unsignedp;
2049	result.overflow = false;
2050
2051	result = num_trim (num: result, precision);
2052	if (!result.unsignedp)
2053	{
2054	bool lhsp = num_positive (num: lhs, precision);
2055	result.overflow = (lhsp != num_positive (num: rhs, precision)
2056	&& lhsp != num_positive (num: result, precision));
2057	}
2058	return result;
2059
2060	case CPP_PLUS:
2061	result.low = lhs.low + rhs.low;
2062	result.high = lhs.high + rhs.high;
2063	if (result.low < lhs.low)
2064	result.high++;
2065	result.unsignedp = lhs.unsignedp || rhs.unsignedp;
2066	result.overflow = false;
2067
2068	result = num_trim (num: result, precision);
2069	if (!result.unsignedp)
2070	{
2071	bool lhsp = num_positive (num: lhs, precision);
2072	result.overflow = (lhsp == num_positive (num: rhs, precision)
2073	&& lhsp != num_positive (num: result, precision));
2074	}
2075	return result;
2076
2077	/* Comma. */
2078	default: /* case CPP_COMMA: */
2079	if (CPP_PEDANTIC (pfile) && (!CPP_OPTION (pfile, c99)
2080	|| !pfile->state.skip_eval))
2081	cpp_pedwarning (pfile, CPP_W_PEDANTIC,
2082	msgid: "comma operator in operand of #if");
2083	lhs = rhs;
2084	break;
2085	}
2086
2087	return lhs;
2088	}
2089
2090	/* Multiplies two unsigned cpp_num_parts to give a cpp_num. This
2091	cannot overflow. */
2092	static cpp_num
2093	num_part_mul (cpp_num_part lhs, cpp_num_part rhs)
2094	{
2095	cpp_num result;
2096	cpp_num_part middle[2], temp;
2097
2098	result.low = LOW_PART (lhs) * LOW_PART (rhs);
2099	result.high = HIGH_PART (lhs) * HIGH_PART (rhs);
2100
2101	middle[0] = LOW_PART (lhs) * HIGH_PART (rhs);
2102	middle[1] = HIGH_PART (lhs) * LOW_PART (rhs);
2103
2104	temp = result.low;
2105	result.low += LOW_PART (middle[0]) << (PART_PRECISION / 2);
2106	if (result.low < temp)
2107	result.high++;
2108
2109	temp = result.low;
2110	result.low += LOW_PART (middle[1]) << (PART_PRECISION / 2);
2111	if (result.low < temp)
2112	result.high++;
2113
2114	result.high += HIGH_PART (middle[0]);
2115	result.high += HIGH_PART (middle[1]);
2116	result.unsignedp = true;
2117	result.overflow = false;
2118
2119	return result;
2120	}
2121
2122	/* Multiply two preprocessing numbers. */
2123	static cpp_num
2124	num_mul (cpp_reader *pfile, cpp_num lhs, cpp_num rhs)
2125	{
2126	cpp_num result, temp;
2127	bool unsignedp = lhs.unsignedp || rhs.unsignedp;
2128	bool overflow, negate = false;
2129	size_t precision = CPP_OPTION (pfile, precision);
2130
2131	/* Prepare for unsigned multiplication. */
2132	if (!unsignedp)
2133	{
2134	if (!num_positive (num: lhs, precision))
2135	negate = !negate, lhs = num_negate (num: lhs, precision);
2136	if (!num_positive (num: rhs, precision))
2137	negate = !negate, rhs = num_negate (num: rhs, precision);
2138	}
2139
2140	overflow = lhs.high && rhs.high;
2141	result = num_part_mul (lhs: lhs.low, rhs: rhs.low);
2142
2143	temp = num_part_mul (lhs: lhs.high, rhs: rhs.low);
2144	result.high += temp.low;
2145	if (temp.high)
2146	overflow = true;
2147
2148	temp = num_part_mul (lhs: lhs.low, rhs: rhs.high);
2149	result.high += temp.low;
2150	if (temp.high)
2151	overflow = true;
2152
2153	temp.low = result.low, temp.high = result.high;
2154	result = num_trim (num: result, precision);
2155	if (!num_eq (result, temp))
2156	overflow = true;
2157
2158	if (negate)
2159	result = num_negate (num: result, precision);
2160
2161	if (unsignedp)
2162	result.overflow = false;
2163	else
2164	result.overflow = overflow || (num_positive (num: result, precision) ^ !negate
2165	&& !num_zerop (result));
2166	result.unsignedp = unsignedp;
2167
2168	return result;
2169	}
2170
2171	/* Divide two preprocessing numbers, LHS and RHS, returning the answer
2172	or the remainder depending upon OP. LOCATION is the source location
2173	of this operator (for diagnostics). */
2174
2175	static cpp_num
2176	num_div_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op,
2177	location_t location)
2178	{
2179	cpp_num result, sub;
2180	cpp_num_part mask;
2181	bool unsignedp = lhs.unsignedp || rhs.unsignedp;
2182	bool negate = false, lhs_neg = false;
2183	size_t i, precision = CPP_OPTION (pfile, precision);
2184
2185	/* Prepare for unsigned division. */
2186	if (!unsignedp)
2187	{
2188	if (!num_positive (num: lhs, precision))
2189	negate = !negate, lhs_neg = true, lhs = num_negate (num: lhs, precision);
2190	if (!num_positive (num: rhs, precision))
2191	negate = !negate, rhs = num_negate (num: rhs, precision);
2192	}
2193
2194	/* Find the high bit. */
2195	if (rhs.high)
2196	{
2197	i = precision - 1;
2198	mask = (cpp_num_part) 1 << (i - PART_PRECISION);
2199	for (; ; i--, mask >>= 1)
2200	if (rhs.high & mask)
2201	break;
2202	}
2203	else if (rhs.low)
2204	{
2205	if (precision > PART_PRECISION)
2206	i = precision - PART_PRECISION - 1;
2207	else
2208	i = precision - 1;
2209	mask = (cpp_num_part) 1 << i;
2210	for (; ; i--, mask >>= 1)
2211	if (rhs.low & mask)
2212	break;
2213	}
2214	else
2215	{
2216	if (!pfile->state.skip_eval)
2217	cpp_error_with_line (pfile, CPP_DL_ERROR, location, 0,
2218	msgid: "division by zero in #if");
2219	lhs.unsignedp = unsignedp;
2220	return lhs;
2221	}
2222
2223	/* First nonzero bit of RHS is bit I. Do naive division by
2224	shifting the RHS fully left, and subtracting from LHS if LHS is
2225	at least as big, and then repeating but with one less shift.
2226	This is not very efficient, but is easy to understand. */
2227
2228	rhs.unsignedp = true;
2229	lhs.unsignedp = true;
2230	i = precision - i - 1;
2231	sub = num_lshift (num: rhs, precision, n: i);
2232
2233	result.high = result.low = 0;
2234	for (;;)
2235	{
2236	if (num_greater_eq (pa: lhs, pb: sub, precision))
2237	{
2238	lhs = num_binary_op (pfile, lhs, rhs: sub, op: CPP_MINUS);
2239	if (i >= PART_PRECISION)
2240	result.high |= (cpp_num_part) 1 << (i - PART_PRECISION);
2241	else
2242	result.low |= (cpp_num_part) 1 << i;
2243	}
2244	if (i-- == 0)
2245	break;
2246	sub.low = (sub.low >> 1) | (sub.high << (PART_PRECISION - 1));
2247	sub.high >>= 1;
2248	}
2249
2250	/* We divide so that the remainder has the sign of the LHS. */
2251	if (op == CPP_DIV)
2252	{
2253	result.unsignedp = unsignedp;
2254	result.overflow = false;
2255	if (!unsignedp)
2256	{
2257	if (negate)
2258	result = num_negate (num: result, precision);
2259	result.overflow = (num_positive (num: result, precision) ^ !negate
2260	&& !num_zerop (result));
2261	}
2262
2263	return result;
2264	}
2265
2266	/* CPP_MOD. */
2267	lhs.unsignedp = unsignedp;
2268	lhs.overflow = false;
2269	if (lhs_neg)
2270	lhs = num_negate (num: lhs, precision);
2271
2272	return lhs;
2273	}
2274
2275