OSDN Git Service

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