OSDN Git Service

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