OSDN Git Service

gcc:
[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 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       {
709         cppchar_t cc = cpp_interpret_charconst (pfile, token,
710                                                 &temp, &unsignedp);
711
712         result.high = 0;
713         result.low = cc;
714         /* Sign-extend the result if necessary.  */
715         if (!unsignedp && (cppchar_signed_t) cc < 0)
716           {
717             if (PART_PRECISION > BITS_PER_CPPCHAR_T)
718               result.low |= ~(~(cpp_num_part) 0
719                               >> (PART_PRECISION - BITS_PER_CPPCHAR_T));
720             result.high = ~(cpp_num_part) 0;
721             result = num_trim (result, CPP_OPTION (pfile, precision));
722           }
723       }
724       break;
725
726     case CPP_NAME:
727       if (token->val.node == pfile->spec_nodes.n_defined)
728         return parse_defined (pfile);
729       else if (CPP_OPTION (pfile, cplusplus)
730                && (token->val.node == pfile->spec_nodes.n_true
731                    || token->val.node == pfile->spec_nodes.n_false))
732         {
733           result.high = 0;
734           result.low = (token->val.node == pfile->spec_nodes.n_true);
735         }
736       else
737         {
738           result.high = 0;
739           result.low = 0;
740           if (CPP_OPTION (pfile, warn_undef) && !pfile->state.skip_eval)
741             cpp_error (pfile, CPP_DL_WARNING, "\"%s\" is not defined",
742                        NODE_NAME (token->val.node));
743         }
744       break;
745
746     default: /* CPP_HASH */
747       _cpp_test_assertion (pfile, &temp);
748       result.high = 0;
749       result.low = temp;
750     }
751
752   result.unsignedp = !!unsignedp;
753   return result;
754 }
755 \f
756 /* Operator precedence and flags table.
757
758 After an operator is returned from the lexer, if it has priority less
759 than the operator on the top of the stack, we reduce the stack by one
760 operator and repeat the test.  Since equal priorities do not reduce,
761 this is naturally right-associative.
762
763 We handle left-associative operators by decrementing the priority of
764 just-lexed operators by one, but retaining the priority of operators
765 already on the stack.
766
767 The remaining cases are '(' and ')'.  We handle '(' by skipping the
768 reduction phase completely.  ')' is given lower priority than
769 everything else, including '(', effectively forcing a reduction of the
770 parenthesized expression.  If there is a matching '(', the routine
771 reduce() exits immediately.  If the normal exit route sees a ')', then
772 there cannot have been a matching '(' and an error message is output.
773
774 The parser assumes all shifted operators require a left operand unless
775 the flag NO_L_OPERAND is set.  These semantics are automatic; any
776 extra semantics need to be handled with operator-specific code.  */
777
778 /* Flags.  If CHECK_PROMOTION, we warn if the effective sign of an
779    operand changes because of integer promotions.  */
780 #define NO_L_OPERAND    (1 << 0)
781 #define LEFT_ASSOC      (1 << 1)
782 #define CHECK_PROMOTION (1 << 2)
783
784 /* Operator to priority map.  Must be in the same order as the first
785    N entries of enum cpp_ttype.  */
786 static const struct cpp_operator
787 {
788   uchar prio;
789   uchar flags;
790 } optab[] =
791 {
792   /* EQ */              {0, 0}, /* Shouldn't happen.  */
793   /* NOT */             {16, NO_L_OPERAND},
794   /* GREATER */         {12, LEFT_ASSOC | CHECK_PROMOTION},
795   /* LESS */            {12, LEFT_ASSOC | CHECK_PROMOTION},
796   /* PLUS */            {14, LEFT_ASSOC | CHECK_PROMOTION},
797   /* MINUS */           {14, LEFT_ASSOC | CHECK_PROMOTION},
798   /* MULT */            {15, LEFT_ASSOC | CHECK_PROMOTION},
799   /* DIV */             {15, LEFT_ASSOC | CHECK_PROMOTION},
800   /* MOD */             {15, LEFT_ASSOC | CHECK_PROMOTION},
801   /* AND */             {9, LEFT_ASSOC | CHECK_PROMOTION},
802   /* OR */              {7, LEFT_ASSOC | CHECK_PROMOTION},
803   /* XOR */             {8, LEFT_ASSOC | CHECK_PROMOTION},
804   /* RSHIFT */          {13, LEFT_ASSOC},
805   /* LSHIFT */          {13, LEFT_ASSOC},
806
807   /* COMPL */           {16, NO_L_OPERAND},
808   /* AND_AND */         {6, LEFT_ASSOC},
809   /* OR_OR */           {5, LEFT_ASSOC},
810   /* QUERY */           {3, 0},
811   /* COLON */           {4, LEFT_ASSOC | CHECK_PROMOTION},
812   /* COMMA */           {2, LEFT_ASSOC},
813   /* OPEN_PAREN */      {1, NO_L_OPERAND},
814   /* CLOSE_PAREN */     {0, 0},
815   /* EOF */             {0, 0},
816   /* EQ_EQ */           {11, LEFT_ASSOC},
817   /* NOT_EQ */          {11, LEFT_ASSOC},
818   /* GREATER_EQ */      {12, LEFT_ASSOC | CHECK_PROMOTION},
819   /* LESS_EQ */         {12, LEFT_ASSOC | CHECK_PROMOTION},
820   /* UPLUS */           {16, NO_L_OPERAND},
821   /* UMINUS */          {16, NO_L_OPERAND}
822 };
823
824 /* Parse and evaluate a C expression, reading from PFILE.
825    Returns the truth value of the expression.
826
827    The implementation is an operator precedence parser, i.e. a
828    bottom-up parser, using a stack for not-yet-reduced tokens.
829
830    The stack base is op_stack, and the current stack pointer is 'top'.
831    There is a stack element for each operator (only), and the most
832    recently pushed operator is 'top->op'.  An operand (value) is
833    stored in the 'value' field of the stack element of the operator
834    that precedes it.  */
835 bool
836 _cpp_parse_expr (cpp_reader *pfile)
837 {
838   struct op *top = pfile->op_stack;
839   unsigned int lex_count;
840   bool saw_leading_not, want_value = true;
841
842   pfile->state.skip_eval = 0;
843
844   /* Set up detection of #if ! defined().  */
845   pfile->mi_ind_cmacro = 0;
846   saw_leading_not = false;
847   lex_count = 0;
848
849   /* Lowest priority operator prevents further reductions.  */
850   top->op = CPP_EOF;
851
852   for (;;)
853     {
854       struct op op;
855
856       lex_count++;
857       op.token = cpp_get_token (pfile);
858       op.op = op.token->type;
859
860       switch (op.op)
861         {
862           /* These tokens convert into values.  */
863         case CPP_NUMBER:
864         case CPP_CHAR:
865         case CPP_WCHAR:
866         case CPP_NAME:
867         case CPP_HASH:
868           if (!want_value)
869             SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
870                            cpp_token_as_text (pfile, op.token));
871           want_value = false;
872           top->value = eval_token (pfile, op.token);
873           continue;
874
875         case CPP_NOT:
876           saw_leading_not = lex_count == 1;
877           break;
878         case CPP_PLUS:
879           if (want_value)
880             op.op = CPP_UPLUS;
881           break;
882         case CPP_MINUS:
883           if (want_value)
884             op.op = CPP_UMINUS;
885           break;
886
887         default:
888           if ((int) op.op <= (int) CPP_EQ || (int) op.op >= (int) CPP_PLUS_EQ)
889             SYNTAX_ERROR2 ("token \"%s\" is not valid in preprocessor expressions",
890                            cpp_token_as_text (pfile, op.token));
891           break;
892         }
893
894       /* Check we have a value or operator as appropriate.  */
895       if (optab[op.op].flags & NO_L_OPERAND)
896         {
897           if (!want_value)
898             SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
899                            cpp_token_as_text (pfile, op.token));
900         }
901       else if (want_value)
902         {
903           /* We want a number (or expression) and haven't got one.
904              Try to emit a specific diagnostic.  */
905           if (op.op == CPP_CLOSE_PAREN && top->op == CPP_OPEN_PAREN)
906             SYNTAX_ERROR ("missing expression between '(' and ')'");
907
908           if (op.op == CPP_EOF && top->op == CPP_EOF)
909             SYNTAX_ERROR ("#if with no expression");
910
911           if (top->op != CPP_EOF && top->op != CPP_OPEN_PAREN)
912             SYNTAX_ERROR2 ("operator '%s' has no right operand",
913                            cpp_token_as_text (pfile, top->token));
914           else if (op.op == CPP_CLOSE_PAREN || op.op == CPP_EOF)
915             /* Complain about missing paren during reduction.  */;
916           else
917             SYNTAX_ERROR2 ("operator '%s' has no left operand",
918                            cpp_token_as_text (pfile, op.token));
919         }
920
921       top = reduce (pfile, top, op.op);
922       if (!top)
923         goto syntax_error;
924
925       if (op.op == CPP_EOF)
926         break;
927
928       switch (op.op)
929         {
930         case CPP_CLOSE_PAREN:
931           continue;
932         case CPP_OR_OR:
933           if (!num_zerop (top->value))
934             pfile->state.skip_eval++;
935           break;
936         case CPP_AND_AND:
937         case CPP_QUERY:
938           if (num_zerop (top->value))
939             pfile->state.skip_eval++;
940           break;
941         case CPP_COLON:
942           if (top->op != CPP_QUERY)
943             SYNTAX_ERROR (" ':' without preceding '?'");
944           if (!num_zerop (top[-1].value)) /* Was '?' condition true?  */
945             pfile->state.skip_eval++;
946           else
947             pfile->state.skip_eval--;
948         default:
949           break;
950         }
951
952       want_value = true;
953
954       /* Check for and handle stack overflow.  */
955       if (++top == pfile->op_limit)
956         top = _cpp_expand_op_stack (pfile);
957
958       top->op = op.op;
959       top->token = op.token;
960     }
961
962   /* The controlling macro expression is only valid if we called lex 3
963      times: <!> <defined expression> and <EOF>.  push_conditional ()
964      checks that we are at top-of-file.  */
965   if (pfile->mi_ind_cmacro && !(saw_leading_not && lex_count == 3))
966     pfile->mi_ind_cmacro = 0;
967
968   if (top != pfile->op_stack)
969     {
970       cpp_error (pfile, CPP_DL_ICE, "unbalanced stack in #if");
971     syntax_error:
972       return false;  /* Return false on syntax error.  */
973     }
974
975   return !num_zerop (top->value);
976 }
977
978 /* Reduce the operator / value stack if possible, in preparation for
979    pushing operator OP.  Returns NULL on error, otherwise the top of
980    the stack.  */
981 static struct op *
982 reduce (cpp_reader *pfile, struct op *top, enum cpp_ttype op)
983 {
984   unsigned int prio;
985
986   if (top->op <= CPP_EQ || top->op > CPP_LAST_CPP_OP + 2)
987     {
988     bad_op:
989       cpp_error (pfile, CPP_DL_ICE, "impossible operator '%u'", top->op);
990       return 0;
991     }
992
993   if (op == CPP_OPEN_PAREN)
994     return top;
995
996   /* Decrement the priority of left-associative operators to force a
997      reduction with operators of otherwise equal priority.  */
998   prio = optab[op].prio - ((optab[op].flags & LEFT_ASSOC) != 0);
999   while (prio < optab[top->op].prio)
1000     {
1001       if (CPP_OPTION (pfile, warn_num_sign_change)
1002           && optab[top->op].flags & CHECK_PROMOTION)
1003         check_promotion (pfile, top);
1004
1005       switch (top->op)
1006         {
1007         case CPP_UPLUS:
1008         case CPP_UMINUS:
1009         case CPP_NOT:
1010         case CPP_COMPL:
1011           top[-1].value = num_unary_op (pfile, top->value, top->op);
1012           break;
1013
1014         case CPP_PLUS:
1015         case CPP_MINUS:
1016         case CPP_RSHIFT:
1017         case CPP_LSHIFT:
1018         case CPP_COMMA:
1019           top[-1].value = num_binary_op (pfile, top[-1].value,
1020                                          top->value, top->op);
1021           break;
1022
1023         case CPP_GREATER:
1024         case CPP_LESS:
1025         case CPP_GREATER_EQ:
1026         case CPP_LESS_EQ:
1027           top[-1].value
1028             = num_inequality_op (pfile, top[-1].value, top->value, top->op);
1029           break;
1030
1031         case CPP_EQ_EQ:
1032         case CPP_NOT_EQ:
1033           top[-1].value
1034             = num_equality_op (pfile, top[-1].value, top->value, top->op);
1035           break;
1036
1037         case CPP_AND:
1038         case CPP_OR:
1039         case CPP_XOR:
1040           top[-1].value
1041             = num_bitwise_op (pfile, top[-1].value, top->value, top->op);
1042           break;
1043
1044         case CPP_MULT:
1045           top[-1].value = num_mul (pfile, top[-1].value, top->value);
1046           break;
1047
1048         case CPP_DIV:
1049         case CPP_MOD:
1050           top[-1].value = num_div_op (pfile, top[-1].value,
1051                                       top->value, top->op);
1052           break;
1053
1054         case CPP_OR_OR:
1055           top--;
1056           if (!num_zerop (top->value))
1057             pfile->state.skip_eval--;
1058           top->value.low = (!num_zerop (top->value)
1059                             || !num_zerop (top[1].value));
1060           top->value.high = 0;
1061           top->value.unsignedp = false;
1062           top->value.overflow = false;
1063           continue;
1064
1065         case CPP_AND_AND:
1066           top--;
1067           if (num_zerop (top->value))
1068             pfile->state.skip_eval--;
1069           top->value.low = (!num_zerop (top->value)
1070                             && !num_zerop (top[1].value));
1071           top->value.high = 0;
1072           top->value.unsignedp = false;
1073           top->value.overflow = false;
1074           continue;
1075
1076         case CPP_OPEN_PAREN:
1077           if (op != CPP_CLOSE_PAREN)
1078             {
1079               cpp_error (pfile, CPP_DL_ERROR, "missing ')' in expression");
1080               return 0;
1081             }
1082           top--;
1083           top->value = top[1].value;
1084           return top;
1085
1086         case CPP_COLON:
1087           top -= 2;
1088           if (!num_zerop (top->value))
1089             {
1090               pfile->state.skip_eval--;
1091               top->value = top[1].value;
1092             }
1093           else
1094             top->value = top[2].value;
1095           top->value.unsignedp = (top[1].value.unsignedp
1096                                   || top[2].value.unsignedp);
1097           continue;
1098
1099         case CPP_QUERY:
1100           cpp_error (pfile, CPP_DL_ERROR, "'?' without following ':'");
1101           return 0;
1102
1103         default:
1104           goto bad_op;
1105         }
1106
1107       top--;
1108       if (top->value.overflow && !pfile->state.skip_eval)
1109         cpp_error (pfile, CPP_DL_PEDWARN,
1110                    "integer overflow in preprocessor expression");
1111     }
1112
1113   if (op == CPP_CLOSE_PAREN)
1114     {
1115       cpp_error (pfile, CPP_DL_ERROR, "missing '(' in expression");
1116       return 0;
1117     }
1118
1119   return top;
1120 }
1121
1122 /* Returns the position of the old top of stack after expansion.  */
1123 struct op *
1124 _cpp_expand_op_stack (cpp_reader *pfile)
1125 {
1126   size_t old_size = (size_t) (pfile->op_limit - pfile->op_stack);
1127   size_t new_size = old_size * 2 + 20;
1128
1129   pfile->op_stack = XRESIZEVEC (struct op, pfile->op_stack, new_size);
1130   pfile->op_limit = pfile->op_stack + new_size;
1131
1132   return pfile->op_stack + old_size;
1133 }
1134
1135 /* Emits a warning if the effective sign of either operand of OP
1136    changes because of integer promotions.  */
1137 static void
1138 check_promotion (cpp_reader *pfile, const struct op *op)
1139 {
1140   if (op->value.unsignedp == op[-1].value.unsignedp)
1141     return;
1142
1143   if (op->value.unsignedp)
1144     {
1145       if (!num_positive (op[-1].value, CPP_OPTION (pfile, precision)))
1146         cpp_error (pfile, CPP_DL_WARNING,
1147                    "the left operand of \"%s\" changes sign when promoted",
1148                    cpp_token_as_text (pfile, op->token));
1149     }
1150   else if (!num_positive (op->value, CPP_OPTION (pfile, precision)))
1151     cpp_error (pfile, CPP_DL_WARNING,
1152                "the right operand of \"%s\" changes sign when promoted",
1153                cpp_token_as_text (pfile, op->token));
1154 }
1155
1156 /* Clears the unused high order bits of the number pointed to by PNUM.  */
1157 static cpp_num
1158 num_trim (cpp_num num, size_t precision)
1159 {
1160   if (precision > PART_PRECISION)
1161     {
1162       precision -= PART_PRECISION;
1163       if (precision < PART_PRECISION)
1164         num.high &= ((cpp_num_part) 1 << precision) - 1;
1165     }
1166   else
1167     {
1168       if (precision < PART_PRECISION)
1169         num.low &= ((cpp_num_part) 1 << precision) - 1;
1170       num.high = 0;
1171     }
1172
1173   return num;
1174 }
1175
1176 /* True iff A (presumed signed) >= 0.  */
1177 static bool
1178 num_positive (cpp_num num, size_t precision)
1179 {
1180   if (precision > PART_PRECISION)
1181     {
1182       precision -= PART_PRECISION;
1183       return (num.high & (cpp_num_part) 1 << (precision - 1)) == 0;
1184     }
1185
1186   return (num.low & (cpp_num_part) 1 << (precision - 1)) == 0;
1187 }
1188
1189 /* Sign extend a number, with PRECISION significant bits and all
1190    others assumed clear, to fill out a cpp_num structure.  */
1191 cpp_num
1192 cpp_num_sign_extend (cpp_num num, size_t precision)
1193 {
1194   if (!num.unsignedp)
1195     {
1196       if (precision > PART_PRECISION)
1197         {
1198           precision -= PART_PRECISION;
1199           if (precision < PART_PRECISION
1200               && (num.high & (cpp_num_part) 1 << (precision - 1)))
1201             num.high |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1202         }
1203       else if (num.low & (cpp_num_part) 1 << (precision - 1))
1204         {
1205           if (precision < PART_PRECISION)
1206             num.low |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1207           num.high = ~(cpp_num_part) 0;
1208         }
1209     }
1210
1211   return num;
1212 }
1213
1214 /* Returns the negative of NUM.  */
1215 static cpp_num
1216 num_negate (cpp_num num, size_t precision)
1217 {
1218   cpp_num copy;
1219
1220   copy = num;
1221   num.high = ~num.high;
1222   num.low = ~num.low;
1223   if (++num.low == 0)
1224     num.high++;
1225   num = num_trim (num, precision);
1226   num.overflow = (!num.unsignedp && num_eq (num, copy) && !num_zerop (num));
1227
1228   return num;
1229 }
1230
1231 /* Returns true if A >= B.  */
1232 static bool
1233 num_greater_eq (cpp_num pa, cpp_num pb, size_t precision)
1234 {
1235   bool unsignedp;
1236
1237   unsignedp = pa.unsignedp || pb.unsignedp;
1238
1239   if (!unsignedp)
1240     {
1241       /* Both numbers have signed type.  If they are of different
1242        sign, the answer is the sign of A.  */
1243       unsignedp = num_positive (pa, precision);
1244
1245       if (unsignedp != num_positive (pb, precision))
1246         return unsignedp;
1247
1248       /* Otherwise we can do an unsigned comparison.  */
1249     }
1250
1251   return (pa.high > pb.high) || (pa.high == pb.high && pa.low >= pb.low);
1252 }
1253
1254 /* Returns LHS OP RHS, where OP is a bit-wise operation.  */
1255 static cpp_num
1256 num_bitwise_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1257                 cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1258 {
1259   lhs.overflow = false;
1260   lhs.unsignedp = lhs.unsignedp || rhs.unsignedp;
1261
1262   /* As excess precision is zeroed, there is no need to num_trim () as
1263      these operations cannot introduce a set bit there.  */
1264   if (op == CPP_AND)
1265     {
1266       lhs.low &= rhs.low;
1267       lhs.high &= rhs.high;
1268     }
1269   else if (op == CPP_OR)
1270     {
1271       lhs.low |= rhs.low;
1272       lhs.high |= rhs.high;
1273     }
1274   else
1275     {
1276       lhs.low ^= rhs.low;
1277       lhs.high ^= rhs.high;
1278     }
1279
1280   return lhs;
1281 }
1282
1283 /* Returns LHS OP RHS, where OP is an inequality.  */
1284 static cpp_num
1285 num_inequality_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs,
1286                    enum cpp_ttype op)
1287 {
1288   bool gte = num_greater_eq (lhs, rhs, CPP_OPTION (pfile, precision));
1289
1290   if (op == CPP_GREATER_EQ)
1291     lhs.low = gte;
1292   else if (op == CPP_LESS)
1293     lhs.low = !gte;
1294   else if (op == CPP_GREATER)
1295     lhs.low = gte && !num_eq (lhs, rhs);
1296   else /* CPP_LESS_EQ.  */
1297     lhs.low = !gte || num_eq (lhs, rhs);
1298
1299   lhs.high = 0;
1300   lhs.overflow = false;
1301   lhs.unsignedp = false;
1302   return lhs;
1303 }
1304
1305 /* Returns LHS OP RHS, where OP is == or !=.  */
1306 static cpp_num
1307 num_equality_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1308                  cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1309 {
1310   /* Work around a 3.0.4 bug; see PR 6950.  */
1311   bool eq = num_eq (lhs, rhs);
1312   if (op == CPP_NOT_EQ)
1313     eq = !eq;
1314   lhs.low = eq;
1315   lhs.high = 0;
1316   lhs.overflow = false;
1317   lhs.unsignedp = false;
1318   return lhs;
1319 }
1320
1321 /* Shift NUM, of width PRECISION, right by N bits.  */
1322 static cpp_num
1323 num_rshift (cpp_num num, size_t precision, size_t n)
1324 {
1325   cpp_num_part sign_mask;
1326   bool x = num_positive (num, precision);
1327
1328   if (num.unsignedp || x)
1329     sign_mask = 0;
1330   else
1331     sign_mask = ~(cpp_num_part) 0;
1332
1333   if (n >= precision)
1334     num.high = num.low = sign_mask;
1335   else
1336     {
1337       /* Sign-extend.  */
1338       if (precision < PART_PRECISION)
1339         num.high = sign_mask, num.low |= sign_mask << precision;
1340       else if (precision < 2 * PART_PRECISION)
1341         num.high |= sign_mask << (precision - PART_PRECISION);
1342
1343       if (n >= PART_PRECISION)
1344         {
1345           n -= PART_PRECISION;
1346           num.low = num.high;
1347           num.high = sign_mask;
1348         }
1349
1350       if (n)
1351         {
1352           num.low = (num.low >> n) | (num.high << (PART_PRECISION - n));
1353           num.high = (num.high >> n) | (sign_mask << (PART_PRECISION - n));
1354         }
1355     }
1356
1357   num = num_trim (num, precision);
1358   num.overflow = false;
1359   return num;
1360 }
1361
1362 /* Shift NUM, of width PRECISION, left by N bits.  */
1363 static cpp_num
1364 num_lshift (cpp_num num, size_t precision, size_t n)
1365 {
1366   if (n >= precision)
1367     {
1368       num.overflow = !num.unsignedp && !num_zerop (num);
1369       num.high = num.low = 0;
1370     }
1371   else
1372     {
1373       cpp_num orig, maybe_orig;
1374       size_t m = n;
1375
1376       orig = num;
1377       if (m >= PART_PRECISION)
1378         {
1379           m -= PART_PRECISION;
1380           num.high = num.low;
1381           num.low = 0;
1382         }
1383       if (m)
1384         {
1385           num.high = (num.high << m) | (num.low >> (PART_PRECISION - m));
1386           num.low <<= m;
1387         }
1388       num = num_trim (num, precision);
1389
1390       if (num.unsignedp)
1391         num.overflow = false;
1392       else
1393         {
1394           maybe_orig = num_rshift (num, precision, n);
1395           num.overflow = !num_eq (orig, maybe_orig);
1396         }
1397     }
1398
1399   return num;
1400 }
1401
1402 /* The four unary operators: +, -, ! and ~.  */
1403 static cpp_num
1404 num_unary_op (cpp_reader *pfile, cpp_num num, enum cpp_ttype op)
1405 {
1406   switch (op)
1407     {
1408     case CPP_UPLUS:
1409       if (CPP_WTRADITIONAL (pfile) && !pfile->state.skip_eval)
1410         cpp_error (pfile, CPP_DL_WARNING,
1411                    "traditional C rejects the unary plus operator");
1412       num.overflow = false;
1413       break;
1414
1415     case CPP_UMINUS:
1416       num = num_negate (num, CPP_OPTION (pfile, precision));
1417       break;
1418
1419     case CPP_COMPL:
1420       num.high = ~num.high;
1421       num.low = ~num.low;
1422       num = num_trim (num, CPP_OPTION (pfile, precision));
1423       num.overflow = false;
1424       break;
1425
1426     default: /* case CPP_NOT: */
1427       num.low = num_zerop (num);
1428       num.high = 0;
1429       num.overflow = false;
1430       num.unsignedp = false;
1431       break;
1432     }
1433
1434   return num;
1435 }
1436
1437 /* The various binary operators.  */
1438 static cpp_num
1439 num_binary_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1440 {
1441   cpp_num result;
1442   size_t precision = CPP_OPTION (pfile, precision);
1443   size_t n;
1444
1445   switch (op)
1446     {
1447       /* Shifts.  */
1448     case CPP_LSHIFT:
1449     case CPP_RSHIFT:
1450       if (!rhs.unsignedp && !num_positive (rhs, precision))
1451         {
1452           /* A negative shift is a positive shift the other way.  */
1453           if (op == CPP_LSHIFT)
1454             op = CPP_RSHIFT;
1455           else
1456             op = CPP_LSHIFT;
1457           rhs = num_negate (rhs, precision);
1458         }
1459       if (rhs.high)
1460         n = ~0;                 /* Maximal.  */
1461       else
1462         n = rhs.low;
1463       if (op == CPP_LSHIFT)
1464         lhs = num_lshift (lhs, precision, n);
1465       else
1466         lhs = num_rshift (lhs, precision, n);
1467       break;
1468
1469       /* Arithmetic.  */
1470     case CPP_MINUS:
1471       rhs = num_negate (rhs, precision);
1472     case CPP_PLUS:
1473       result.low = lhs.low + rhs.low;
1474       result.high = lhs.high + rhs.high;
1475       if (result.low < lhs.low)
1476         result.high++;
1477       result.unsignedp = lhs.unsignedp || rhs.unsignedp;
1478       result.overflow = false;
1479
1480       result = num_trim (result, precision);
1481       if (!result.unsignedp)
1482         {
1483           bool lhsp = num_positive (lhs, precision);
1484           result.overflow = (lhsp == num_positive (rhs, precision)
1485                              && lhsp != num_positive (result, precision));
1486         }
1487       return result;
1488
1489       /* Comma.  */
1490     default: /* case CPP_COMMA: */
1491       if (CPP_PEDANTIC (pfile) && (!CPP_OPTION (pfile, c99)
1492                                    || !pfile->state.skip_eval))
1493         cpp_error (pfile, CPP_DL_PEDWARN,
1494                    "comma operator in operand of #if");
1495       lhs = rhs;
1496       break;
1497     }
1498
1499   return lhs;
1500 }
1501
1502 /* Multiplies two unsigned cpp_num_parts to give a cpp_num.  This
1503    cannot overflow.  */
1504 static cpp_num
1505 num_part_mul (cpp_num_part lhs, cpp_num_part rhs)
1506 {
1507   cpp_num result;
1508   cpp_num_part middle[2], temp;
1509
1510   result.low = LOW_PART (lhs) * LOW_PART (rhs);
1511   result.high = HIGH_PART (lhs) * HIGH_PART (rhs);
1512
1513   middle[0] = LOW_PART (lhs) * HIGH_PART (rhs);
1514   middle[1] = HIGH_PART (lhs) * LOW_PART (rhs);
1515
1516   temp = result.low;
1517   result.low += LOW_PART (middle[0]) << (PART_PRECISION / 2);
1518   if (result.low < temp)
1519     result.high++;
1520
1521   temp = result.low;
1522   result.low += LOW_PART (middle[1]) << (PART_PRECISION / 2);
1523   if (result.low < temp)
1524     result.high++;
1525
1526   result.high += HIGH_PART (middle[0]);
1527   result.high += HIGH_PART (middle[1]);
1528   result.unsignedp = true;
1529   result.overflow = false;
1530
1531   return result;
1532 }
1533
1534 /* Multiply two preprocessing numbers.  */
1535 static cpp_num
1536 num_mul (cpp_reader *pfile, cpp_num lhs, cpp_num rhs)
1537 {
1538   cpp_num result, temp;
1539   bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1540   bool overflow, negate = false;
1541   size_t precision = CPP_OPTION (pfile, precision);
1542
1543   /* Prepare for unsigned multiplication.  */
1544   if (!unsignedp)
1545     {
1546       if (!num_positive (lhs, precision))
1547         negate = !negate, lhs = num_negate (lhs, precision);
1548       if (!num_positive (rhs, precision))
1549         negate = !negate, rhs = num_negate (rhs, precision);
1550     }
1551
1552   overflow = lhs.high && rhs.high;
1553   result = num_part_mul (lhs.low, rhs.low);
1554
1555   temp = num_part_mul (lhs.high, rhs.low);
1556   result.high += temp.low;
1557   if (temp.high)
1558     overflow = true;
1559
1560   temp = num_part_mul (lhs.low, rhs.high);
1561   result.high += temp.low;
1562   if (temp.high)
1563     overflow = true;
1564
1565   temp.low = result.low, temp.high = result.high;
1566   result = num_trim (result, precision);
1567   if (!num_eq (result, temp))
1568     overflow = true;
1569
1570   if (negate)
1571     result = num_negate (result, precision);
1572
1573   if (unsignedp)
1574     result.overflow = false;
1575   else
1576     result.overflow = overflow || (num_positive (result, precision) ^ !negate
1577                                    && !num_zerop (result));
1578   result.unsignedp = unsignedp;
1579
1580   return result;
1581 }
1582
1583 /* Divide two preprocessing numbers, returning the answer or the
1584    remainder depending upon OP.  */
1585 static cpp_num
1586 num_div_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1587 {
1588   cpp_num result, sub;
1589   cpp_num_part mask;
1590   bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1591   bool negate = false, lhs_neg = false;
1592   size_t i, precision = CPP_OPTION (pfile, precision);
1593
1594   /* Prepare for unsigned division.  */
1595   if (!unsignedp)
1596     {
1597       if (!num_positive (lhs, precision))
1598         negate = !negate, lhs_neg = true, lhs = num_negate (lhs, precision);
1599       if (!num_positive (rhs, precision))
1600         negate = !negate, rhs = num_negate (rhs, precision);
1601     }
1602
1603   /* Find the high bit.  */
1604   if (rhs.high)
1605     {
1606       i = precision - 1;
1607       mask = (cpp_num_part) 1 << (i - PART_PRECISION);
1608       for (; ; i--, mask >>= 1)
1609         if (rhs.high & mask)
1610           break;
1611     }
1612   else if (rhs.low)
1613     {
1614       if (precision > PART_PRECISION)
1615         i = precision - PART_PRECISION - 1;
1616       else
1617         i = precision - 1;
1618       mask = (cpp_num_part) 1 << i;
1619       for (; ; i--, mask >>= 1)
1620         if (rhs.low & mask)
1621           break;
1622     }
1623   else
1624     {
1625       if (!pfile->state.skip_eval)
1626         cpp_error (pfile, CPP_DL_ERROR, "division by zero in #if");
1627       return lhs;
1628     }
1629
1630   /* First nonzero bit of RHS is bit I.  Do naive division by
1631      shifting the RHS fully left, and subtracting from LHS if LHS is
1632      at least as big, and then repeating but with one less shift.
1633      This is not very efficient, but is easy to understand.  */
1634
1635   rhs.unsignedp = true;
1636   lhs.unsignedp = true;
1637   i = precision - i - 1;
1638   sub = num_lshift (rhs, precision, i);
1639
1640   result.high = result.low = 0;
1641   for (;;)
1642     {
1643       if (num_greater_eq (lhs, sub, precision))
1644         {
1645           lhs = num_binary_op (pfile, lhs, sub, CPP_MINUS);
1646           if (i >= PART_PRECISION)
1647             result.high |= (cpp_num_part) 1 << (i - PART_PRECISION);
1648           else
1649             result.low |= (cpp_num_part) 1 << i;
1650         }
1651       if (i-- == 0)
1652         break;
1653       sub.low = (sub.low >> 1) | (sub.high << (PART_PRECISION - 1));
1654       sub.high >>= 1;
1655     }
1656
1657   /* We divide so that the remainder has the sign of the LHS.  */
1658   if (op == CPP_DIV)
1659     {
1660       result.unsignedp = unsignedp;
1661       result.overflow = false;
1662       if (!unsignedp)
1663         {
1664           if (negate)
1665             result = num_negate (result, precision);
1666           result.overflow = (num_positive (result, precision) ^ !negate
1667                              && !num_zerop (result));
1668         }
1669
1670       return result;
1671     }
1672
1673   /* CPP_MOD.  */
1674   lhs.unsignedp = unsignedp;
1675   lhs.overflow = false;
1676   if (lhs_neg)
1677     lhs = num_negate (lhs, precision);
1678
1679   return lhs;
1680 }