OSDN Git Service

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