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