OSDN Git Service

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