Daily bump.
[official-gcc.git] / libcpp / expr.c
blob9df75332c05510846a2e39087ed0f95ee0e04072
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.
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.
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.
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. */
21 #include "config.h"
22 #include "system.h"
23 #include "cpplib.h"
24 #include "internal.h"
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))
31 struct op
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;
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);
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);
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 *);
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))
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)
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)
85 size_t f, l, w, q, i, d;
86 size_t r, k, u, h;
88 f = l = w = q = i = d = 0;
89 r = k = u = h = 0;
91 while (len--)
92 switch (s[len])
94 case 'r': case 'R': r++; break;
95 case 'k': case 'K': k++; break;
96 case 'u': case 'U': u++; break;
97 case 'h': case 'H': h++; break;
98 case 'f': case 'F':
99 if (d > 0)
100 return 0;
101 f++;
102 break;
103 case 'l': case 'L':
104 if (d > 0)
105 return 0;
106 l++;
107 /* If there are two Ls, they must be adjacent and the same case. */
108 if (l == 2 && s[len] != s[len + 1])
109 return 0;
110 break;
111 case 'w': case 'W':
112 if (d > 0)
113 return 0;
114 w++;
115 break;
116 case 'q': case 'Q':
117 if (d > 0)
118 return 0;
119 q++;
120 break;
121 case 'i': case 'I':
122 case 'j': case 'J': i++; break;
123 case 'd': case 'D': d++; break;
124 default:
125 return 0;
128 if (r + k > 1 || h > 1 || l > 2 || u > 1)
129 return 0;
131 if (r == 1)
133 if (f || i || d || w || q)
134 return 0;
136 return (CPP_N_FRACT
137 | (u ? CPP_N_UNSIGNED : 0)
138 | (h ? CPP_N_SMALL :
139 l == 2 ? CPP_N_LARGE :
140 l == 1 ? CPP_N_MEDIUM : 0));
143 if (k == 1)
145 if (f || i || d || w || q)
146 return 0;
148 return (CPP_N_ACCUM
149 | (u ? CPP_N_UNSIGNED : 0)
150 | (h ? CPP_N_SMALL :
151 l == 2 ? CPP_N_LARGE :
152 l == 1 ? CPP_N_MEDIUM : 0));
155 if (f + l + w + q > 1 || i > 1 || h + u > 0)
156 return 0;
158 /* Allow dd, df, dl suffixes for decimal float constants. */
159 if (d && ((d + f + l != 2) || i))
160 return 0;
162 return ((i ? CPP_N_IMAGINARY : 0)
163 | (f ? CPP_N_SMALL :
164 l ? CPP_N_LARGE :
165 w ? CPP_N_MD_W :
166 q ? CPP_N_MD_Q : CPP_N_MEDIUM)
167 | (d ? CPP_N_DFLOAT : 0));
170 /* Subroutine of cpp_classify_number. S points to an integer suffix
171 of length LEN, possibly zero. Returns 0 for an invalid suffix, or a
172 flag vector describing the suffix. */
173 static unsigned int
174 interpret_int_suffix (const uchar *s, size_t len)
176 size_t u, l, i;
178 u = l = i = 0;
180 while (len--)
181 switch (s[len])
183 case 'u': case 'U': u++; break;
184 case 'i': case 'I':
185 case 'j': case 'J': i++; break;
186 case 'l': case 'L': l++;
187 /* If there are two Ls, they must be adjacent and the same case. */
188 if (l == 2 && s[len] != s[len + 1])
189 return 0;
190 break;
191 default:
192 return 0;
195 if (l > 2 || u > 1 || i > 1)
196 return 0;
198 return ((i ? CPP_N_IMAGINARY : 0)
199 | (u ? CPP_N_UNSIGNED : 0)
200 | ((l == 0) ? CPP_N_SMALL
201 : (l == 1) ? CPP_N_MEDIUM : CPP_N_LARGE));
204 /* Categorize numeric constants according to their field (integer,
205 floating point, or invalid), radix (decimal, octal, hexadecimal),
206 and type suffixes. */
207 unsigned int
208 cpp_classify_number (cpp_reader *pfile, const cpp_token *token)
210 const uchar *str = token->val.str.text;
211 const uchar *limit;
212 unsigned int max_digit, result, radix;
213 enum {NOT_FLOAT = 0, AFTER_POINT, AFTER_EXPON} float_flag;
215 /* If the lexer has done its job, length one can only be a single
216 digit. Fast-path this very common case. */
217 if (token->val.str.len == 1)
218 return CPP_N_INTEGER | CPP_N_SMALL | CPP_N_DECIMAL;
220 limit = str + token->val.str.len;
221 float_flag = NOT_FLOAT;
222 max_digit = 0;
223 radix = 10;
225 /* First, interpret the radix. */
226 if (*str == '0')
228 radix = 8;
229 str++;
231 /* Require at least one hex digit to classify it as hex. */
232 if ((*str == 'x' || *str == 'X')
233 && (str[1] == '.' || ISXDIGIT (str[1])))
235 radix = 16;
236 str++;
238 else if ((*str == 'b' || *str == 'B') && (str[1] == '0' || str[1] == '1'))
240 radix = 2;
241 str++;
245 /* Now scan for a well-formed integer or float. */
246 for (;;)
248 unsigned int c = *str++;
250 if (ISDIGIT (c) || (ISXDIGIT (c) && radix == 16))
252 c = hex_value (c);
253 if (c > max_digit)
254 max_digit = c;
256 else if (c == '.')
258 if (float_flag == NOT_FLOAT)
259 float_flag = AFTER_POINT;
260 else
261 SYNTAX_ERROR ("too many decimal points in number");
263 else if ((radix <= 10 && (c == 'e' || c == 'E'))
264 || (radix == 16 && (c == 'p' || c == 'P')))
266 float_flag = AFTER_EXPON;
267 break;
269 else
271 /* Start of suffix. */
272 str--;
273 break;
277 /* The suffix may be for decimal fixed-point constants without exponent. */
278 if (radix != 16 && float_flag == NOT_FLOAT)
280 result = interpret_float_suffix (str, limit - str);
281 if ((result & CPP_N_FRACT) || (result & CPP_N_ACCUM))
283 result |= CPP_N_FLOATING;
284 /* We need to restore the radix to 10, if the radix is 8. */
285 if (radix == 8)
286 radix = 10;
288 if (CPP_PEDANTIC (pfile))
289 cpp_error (pfile, CPP_DL_PEDWARN,
290 "fixed-point constants are a GCC extension");
291 goto syntax_ok;
293 else
294 result = 0;
297 if (float_flag != NOT_FLOAT && radix == 8)
298 radix = 10;
300 if (max_digit >= radix)
302 if (radix == 2)
303 SYNTAX_ERROR2 ("invalid digit \"%c\" in binary constant", '0' + max_digit);
304 else
305 SYNTAX_ERROR2 ("invalid digit \"%c\" in octal constant", '0' + max_digit);
308 if (float_flag != NOT_FLOAT)
310 if (radix == 2)
312 cpp_error (pfile, CPP_DL_ERROR,
313 "invalid prefix \"0b\" for floating constant");
314 return CPP_N_INVALID;
317 if (radix == 16 && CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, c99))
318 cpp_error (pfile, CPP_DL_PEDWARN,
319 "use of C99 hexadecimal floating constant");
321 if (float_flag == AFTER_EXPON)
323 if (*str == '+' || *str == '-')
324 str++;
326 /* Exponent is decimal, even if string is a hex float. */
327 if (!ISDIGIT (*str))
328 SYNTAX_ERROR ("exponent has no digits");
331 str++;
332 while (ISDIGIT (*str));
334 else if (radix == 16)
335 SYNTAX_ERROR ("hexadecimal floating constants require an exponent");
337 result = interpret_float_suffix (str, limit - str);
338 if (result == 0)
340 cpp_error (pfile, CPP_DL_ERROR,
341 "invalid suffix \"%.*s\" on floating constant",
342 (int) (limit - str), str);
343 return CPP_N_INVALID;
346 /* Traditional C didn't accept any floating suffixes. */
347 if (limit != str
348 && CPP_WTRADITIONAL (pfile)
349 && ! cpp_sys_macro_p (pfile))
350 cpp_error (pfile, CPP_DL_WARNING,
351 "traditional C rejects the \"%.*s\" suffix",
352 (int) (limit - str), str);
354 /* Radix must be 10 for decimal floats. */
355 if ((result & CPP_N_DFLOAT) && radix != 10)
357 cpp_error (pfile, CPP_DL_ERROR,
358 "invalid suffix \"%.*s\" with hexadecimal floating constant",
359 (int) (limit - str), str);
360 return CPP_N_INVALID;
363 if ((result & (CPP_N_FRACT | CPP_N_ACCUM)) && CPP_PEDANTIC (pfile))
364 cpp_error (pfile, CPP_DL_PEDWARN,
365 "fixed-point constants are a GCC extension");
367 if ((result & CPP_N_DFLOAT) && CPP_PEDANTIC (pfile))
368 cpp_error (pfile, CPP_DL_PEDWARN,
369 "decimal float constants are a GCC extension");
371 result |= CPP_N_FLOATING;
373 else
375 result = interpret_int_suffix (str, limit - str);
376 if (result == 0)
378 cpp_error (pfile, CPP_DL_ERROR,
379 "invalid suffix \"%.*s\" on integer constant",
380 (int) (limit - str), str);
381 return CPP_N_INVALID;
384 /* Traditional C only accepted the 'L' suffix.
385 Suppress warning about 'LL' with -Wno-long-long. */
386 if (CPP_WTRADITIONAL (pfile) && ! cpp_sys_macro_p (pfile))
388 int u_or_i = (result & (CPP_N_UNSIGNED|CPP_N_IMAGINARY));
389 int large = (result & CPP_N_WIDTH) == CPP_N_LARGE;
391 if (u_or_i || (large && CPP_OPTION (pfile, warn_long_long)))
392 cpp_error (pfile, CPP_DL_WARNING,
393 "traditional C rejects the \"%.*s\" suffix",
394 (int) (limit - str), str);
397 if ((result & CPP_N_WIDTH) == CPP_N_LARGE
398 && ! CPP_OPTION (pfile, c99)
399 && CPP_OPTION (pfile, warn_long_long))
400 cpp_error (pfile, CPP_DL_PEDWARN,
401 "use of C99 long long integer constant");
403 result |= CPP_N_INTEGER;
406 syntax_ok:
407 if ((result & CPP_N_IMAGINARY) && CPP_PEDANTIC (pfile))
408 cpp_error (pfile, CPP_DL_PEDWARN,
409 "imaginary constants are a GCC extension");
410 if (radix == 2 && CPP_PEDANTIC (pfile))
411 cpp_error (pfile, CPP_DL_PEDWARN,
412 "binary constants are a GCC extension");
414 if (radix == 10)
415 result |= CPP_N_DECIMAL;
416 else if (radix == 16)
417 result |= CPP_N_HEX;
418 else if (radix == 2)
419 result |= CPP_N_BINARY;
420 else
421 result |= CPP_N_OCTAL;
423 return result;
425 syntax_error:
426 return CPP_N_INVALID;
429 /* cpp_interpret_integer converts an integer constant into a cpp_num,
430 of precision options->precision.
432 We do not provide any interface for decimal->float conversion,
433 because the preprocessor doesn't need it and we don't want to
434 drag in GCC's floating point emulator. */
435 cpp_num
436 cpp_interpret_integer (cpp_reader *pfile, const cpp_token *token,
437 unsigned int type)
439 const uchar *p, *end;
440 cpp_num result;
442 result.low = 0;
443 result.high = 0;
444 result.unsignedp = !!(type & CPP_N_UNSIGNED);
445 result.overflow = false;
447 p = token->val.str.text;
448 end = p + token->val.str.len;
450 /* Common case of a single digit. */
451 if (token->val.str.len == 1)
452 result.low = p[0] - '0';
453 else
455 cpp_num_part max;
456 size_t precision = CPP_OPTION (pfile, precision);
457 unsigned int base = 10, c = 0;
458 bool overflow = false;
460 if ((type & CPP_N_RADIX) == CPP_N_OCTAL)
462 base = 8;
463 p++;
465 else if ((type & CPP_N_RADIX) == CPP_N_HEX)
467 base = 16;
468 p += 2;
470 else if ((type & CPP_N_RADIX) == CPP_N_BINARY)
472 base = 2;
473 p += 2;
476 /* We can add a digit to numbers strictly less than this without
477 needing the precision and slowness of double integers. */
478 max = ~(cpp_num_part) 0;
479 if (precision < PART_PRECISION)
480 max >>= PART_PRECISION - precision;
481 max = (max - base + 1) / base + 1;
483 for (; p < end; p++)
485 c = *p;
487 if (ISDIGIT (c) || (base == 16 && ISXDIGIT (c)))
488 c = hex_value (c);
489 else
490 break;
492 /* Strict inequality for when max is set to zero. */
493 if (result.low < max)
494 result.low = result.low * base + c;
495 else
497 result = append_digit (result, c, base, precision);
498 overflow |= result.overflow;
499 max = 0;
503 if (overflow)
504 cpp_error (pfile, CPP_DL_PEDWARN,
505 "integer constant is too large for its type");
506 /* If too big to be signed, consider it unsigned. Only warn for
507 decimal numbers. Traditional numbers were always signed (but
508 we still honor an explicit U suffix); but we only have
509 traditional semantics in directives. */
510 else if (!result.unsignedp
511 && !(CPP_OPTION (pfile, traditional)
512 && pfile->state.in_directive)
513 && !num_positive (result, precision))
515 if (base == 10)
516 cpp_error (pfile, CPP_DL_WARNING,
517 "integer constant is so large that it is unsigned");
518 result.unsignedp = true;
522 return result;
525 /* Append DIGIT to NUM, a number of PRECISION bits being read in base BASE. */
526 static cpp_num
527 append_digit (cpp_num num, int digit, int base, size_t precision)
529 cpp_num result;
530 unsigned int shift;
531 bool overflow;
532 cpp_num_part add_high, add_low;
534 /* Multiply by 2, 8 or 16. Catching this overflow here means we don't
535 need to worry about add_high overflowing. */
536 switch (base)
538 case 2:
539 shift = 1;
540 break;
542 case 16:
543 shift = 4;
544 break;
546 default:
547 shift = 3;
549 overflow = !!(num.high >> (PART_PRECISION - shift));
550 result.high = num.high << shift;
551 result.low = num.low << shift;
552 result.high |= num.low >> (PART_PRECISION - shift);
553 result.unsignedp = num.unsignedp;
555 if (base == 10)
557 add_low = num.low << 1;
558 add_high = (num.high << 1) + (num.low >> (PART_PRECISION - 1));
560 else
561 add_high = add_low = 0;
563 if (add_low + digit < add_low)
564 add_high++;
565 add_low += digit;
567 if (result.low + add_low < result.low)
568 add_high++;
569 if (result.high + add_high < result.high)
570 overflow = true;
572 result.low += add_low;
573 result.high += add_high;
574 result.overflow = overflow;
576 /* The above code catches overflow of a cpp_num type. This catches
577 overflow of the (possibly shorter) target precision. */
578 num.low = result.low;
579 num.high = result.high;
580 result = num_trim (result, precision);
581 if (!num_eq (result, num))
582 result.overflow = true;
584 return result;
587 /* Handle meeting "defined" in a preprocessor expression. */
588 static cpp_num
589 parse_defined (cpp_reader *pfile)
591 cpp_num result;
592 int paren = 0;
593 cpp_hashnode *node = 0;
594 const cpp_token *token;
595 cpp_context *initial_context = pfile->context;
597 /* Don't expand macros. */
598 pfile->state.prevent_expansion++;
600 token = cpp_get_token (pfile);
601 if (token->type == CPP_OPEN_PAREN)
603 paren = 1;
604 token = cpp_get_token (pfile);
607 if (token->type == CPP_NAME)
609 node = token->val.node;
610 if (paren && cpp_get_token (pfile)->type != CPP_CLOSE_PAREN)
612 cpp_error (pfile, CPP_DL_ERROR, "missing ')' after \"defined\"");
613 node = 0;
616 else
618 cpp_error (pfile, CPP_DL_ERROR,
619 "operator \"defined\" requires an identifier");
620 if (token->flags & NAMED_OP)
622 cpp_token op;
624 op.flags = 0;
625 op.type = token->type;
626 cpp_error (pfile, CPP_DL_ERROR,
627 "(\"%s\" is an alternative token for \"%s\" in C++)",
628 cpp_token_as_text (pfile, token),
629 cpp_token_as_text (pfile, &op));
633 if (node)
635 if (pfile->context != initial_context && CPP_PEDANTIC (pfile))
636 cpp_error (pfile, CPP_DL_WARNING,
637 "this use of \"defined\" may not be portable");
639 _cpp_mark_macro_used (node);
641 /* A possible controlling macro of the form #if !defined ().
642 _cpp_parse_expr checks there was no other junk on the line. */
643 pfile->mi_ind_cmacro = node;
646 pfile->state.prevent_expansion--;
648 result.unsignedp = false;
649 result.high = 0;
650 result.overflow = false;
651 result.low = node && node->type == NT_MACRO;
652 return result;
655 /* Convert a token into a CPP_NUMBER (an interpreted preprocessing
656 number or character constant, or the result of the "defined" or "#"
657 operators). */
658 static cpp_num
659 eval_token (cpp_reader *pfile, const cpp_token *token)
661 cpp_num result;
662 unsigned int temp;
663 int unsignedp = 0;
665 result.unsignedp = false;
666 result.overflow = false;
668 switch (token->type)
670 case CPP_NUMBER:
671 temp = cpp_classify_number (pfile, token);
672 switch (temp & CPP_N_CATEGORY)
674 case CPP_N_FLOATING:
675 cpp_error (pfile, CPP_DL_ERROR,
676 "floating constant in preprocessor expression");
677 break;
678 case CPP_N_INTEGER:
679 if (!(temp & CPP_N_IMAGINARY))
680 return cpp_interpret_integer (pfile, token, temp);
681 cpp_error (pfile, CPP_DL_ERROR,
682 "imaginary number in preprocessor expression");
683 break;
685 case CPP_N_INVALID:
686 /* Error already issued. */
687 break;
689 result.high = result.low = 0;
690 break;
692 case CPP_WCHAR:
693 case CPP_CHAR:
695 cppchar_t cc = cpp_interpret_charconst (pfile, token,
696 &temp, &unsignedp);
698 result.high = 0;
699 result.low = cc;
700 /* Sign-extend the result if necessary. */
701 if (!unsignedp && (cppchar_signed_t) cc < 0)
703 if (PART_PRECISION > BITS_PER_CPPCHAR_T)
704 result.low |= ~(~(cpp_num_part) 0
705 >> (PART_PRECISION - BITS_PER_CPPCHAR_T));
706 result.high = ~(cpp_num_part) 0;
707 result = num_trim (result, CPP_OPTION (pfile, precision));
710 break;
712 case CPP_NAME:
713 if (token->val.node == pfile->spec_nodes.n_defined)
714 return parse_defined (pfile);
715 else if (CPP_OPTION (pfile, cplusplus)
716 && (token->val.node == pfile->spec_nodes.n_true
717 || token->val.node == pfile->spec_nodes.n_false))
719 result.high = 0;
720 result.low = (token->val.node == pfile->spec_nodes.n_true);
722 else
724 result.high = 0;
725 result.low = 0;
726 if (CPP_OPTION (pfile, warn_undef) && !pfile->state.skip_eval)
727 cpp_error (pfile, CPP_DL_WARNING, "\"%s\" is not defined",
728 NODE_NAME (token->val.node));
730 break;
732 default: /* CPP_HASH */
733 _cpp_test_assertion (pfile, &temp);
734 result.high = 0;
735 result.low = temp;
738 result.unsignedp = !!unsignedp;
739 return result;
742 /* Operator precedence and flags table.
744 After an operator is returned from the lexer, if it has priority less
745 than the operator on the top of the stack, we reduce the stack by one
746 operator and repeat the test. Since equal priorities do not reduce,
747 this is naturally right-associative.
749 We handle left-associative operators by decrementing the priority of
750 just-lexed operators by one, but retaining the priority of operators
751 already on the stack.
753 The remaining cases are '(' and ')'. We handle '(' by skipping the
754 reduction phase completely. ')' is given lower priority than
755 everything else, including '(', effectively forcing a reduction of the
756 parenthesized expression. If there is a matching '(', the routine
757 reduce() exits immediately. If the normal exit route sees a ')', then
758 there cannot have been a matching '(' and an error message is output.
760 The parser assumes all shifted operators require a left operand unless
761 the flag NO_L_OPERAND is set. These semantics are automatic; any
762 extra semantics need to be handled with operator-specific code. */
764 /* Flags. If CHECK_PROMOTION, we warn if the effective sign of an
765 operand changes because of integer promotions. */
766 #define NO_L_OPERAND (1 << 0)
767 #define LEFT_ASSOC (1 << 1)
768 #define CHECK_PROMOTION (1 << 2)
770 /* Operator to priority map. Must be in the same order as the first
771 N entries of enum cpp_ttype. */
772 static const struct cpp_operator
774 uchar prio;
775 uchar flags;
776 } optab[] =
778 /* EQ */ {0, 0}, /* Shouldn't happen. */
779 /* NOT */ {16, NO_L_OPERAND},
780 /* GREATER */ {12, LEFT_ASSOC | CHECK_PROMOTION},
781 /* LESS */ {12, LEFT_ASSOC | CHECK_PROMOTION},
782 /* PLUS */ {14, LEFT_ASSOC | CHECK_PROMOTION},
783 /* MINUS */ {14, LEFT_ASSOC | CHECK_PROMOTION},
784 /* MULT */ {15, LEFT_ASSOC | CHECK_PROMOTION},
785 /* DIV */ {15, LEFT_ASSOC | CHECK_PROMOTION},
786 /* MOD */ {15, LEFT_ASSOC | CHECK_PROMOTION},
787 /* AND */ {9, LEFT_ASSOC | CHECK_PROMOTION},
788 /* OR */ {7, LEFT_ASSOC | CHECK_PROMOTION},
789 /* XOR */ {8, LEFT_ASSOC | CHECK_PROMOTION},
790 /* RSHIFT */ {13, LEFT_ASSOC},
791 /* LSHIFT */ {13, LEFT_ASSOC},
793 /* COMPL */ {16, NO_L_OPERAND},
794 /* AND_AND */ {6, LEFT_ASSOC},
795 /* OR_OR */ {5, LEFT_ASSOC},
796 /* QUERY */ {3, 0},
797 /* COLON */ {4, LEFT_ASSOC | CHECK_PROMOTION},
798 /* COMMA */ {2, LEFT_ASSOC},
799 /* OPEN_PAREN */ {1, NO_L_OPERAND},
800 /* CLOSE_PAREN */ {0, 0},
801 /* EOF */ {0, 0},
802 /* EQ_EQ */ {11, LEFT_ASSOC},
803 /* NOT_EQ */ {11, LEFT_ASSOC},
804 /* GREATER_EQ */ {12, LEFT_ASSOC | CHECK_PROMOTION},
805 /* LESS_EQ */ {12, LEFT_ASSOC | CHECK_PROMOTION},
806 /* UPLUS */ {16, NO_L_OPERAND},
807 /* UMINUS */ {16, NO_L_OPERAND}
810 /* Parse and evaluate a C expression, reading from PFILE.
811 Returns the truth value of the expression.
813 The implementation is an operator precedence parser, i.e. a
814 bottom-up parser, using a stack for not-yet-reduced tokens.
816 The stack base is op_stack, and the current stack pointer is 'top'.
817 There is a stack element for each operator (only), and the most
818 recently pushed operator is 'top->op'. An operand (value) is
819 stored in the 'value' field of the stack element of the operator
820 that precedes it. */
821 bool
822 _cpp_parse_expr (cpp_reader *pfile)
824 struct op *top = pfile->op_stack;
825 unsigned int lex_count;
826 bool saw_leading_not, want_value = true;
828 pfile->state.skip_eval = 0;
830 /* Set up detection of #if ! defined(). */
831 pfile->mi_ind_cmacro = 0;
832 saw_leading_not = false;
833 lex_count = 0;
835 /* Lowest priority operator prevents further reductions. */
836 top->op = CPP_EOF;
838 for (;;)
840 struct op op;
842 lex_count++;
843 op.token = cpp_get_token (pfile);
844 op.op = op.token->type;
846 switch (op.op)
848 /* These tokens convert into values. */
849 case CPP_NUMBER:
850 case CPP_CHAR:
851 case CPP_WCHAR:
852 case CPP_NAME:
853 case CPP_HASH:
854 if (!want_value)
855 SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
856 cpp_token_as_text (pfile, op.token));
857 want_value = false;
858 top->value = eval_token (pfile, op.token);
859 continue;
861 case CPP_NOT:
862 saw_leading_not = lex_count == 1;
863 break;
864 case CPP_PLUS:
865 if (want_value)
866 op.op = CPP_UPLUS;
867 break;
868 case CPP_MINUS:
869 if (want_value)
870 op.op = CPP_UMINUS;
871 break;
873 default:
874 if ((int) op.op <= (int) CPP_EQ || (int) op.op >= (int) CPP_PLUS_EQ)
875 SYNTAX_ERROR2 ("token \"%s\" is not valid in preprocessor expressions",
876 cpp_token_as_text (pfile, op.token));
877 break;
880 /* Check we have a value or operator as appropriate. */
881 if (optab[op.op].flags & NO_L_OPERAND)
883 if (!want_value)
884 SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
885 cpp_token_as_text (pfile, op.token));
887 else if (want_value)
889 /* We want a number (or expression) and haven't got one.
890 Try to emit a specific diagnostic. */
891 if (op.op == CPP_CLOSE_PAREN && top->op == CPP_OPEN_PAREN)
892 SYNTAX_ERROR ("missing expression between '(' and ')'");
894 if (op.op == CPP_EOF && top->op == CPP_EOF)
895 SYNTAX_ERROR ("#if with no expression");
897 if (top->op != CPP_EOF && top->op != CPP_OPEN_PAREN)
898 SYNTAX_ERROR2 ("operator '%s' has no right operand",
899 cpp_token_as_text (pfile, top->token));
900 else if (op.op == CPP_CLOSE_PAREN || op.op == CPP_EOF)
901 /* Complain about missing paren during reduction. */;
902 else
903 SYNTAX_ERROR2 ("operator '%s' has no left operand",
904 cpp_token_as_text (pfile, op.token));
907 top = reduce (pfile, top, op.op);
908 if (!top)
909 goto syntax_error;
911 if (op.op == CPP_EOF)
912 break;
914 switch (op.op)
916 case CPP_CLOSE_PAREN:
917 continue;
918 case CPP_OR_OR:
919 if (!num_zerop (top->value))
920 pfile->state.skip_eval++;
921 break;
922 case CPP_AND_AND:
923 case CPP_QUERY:
924 if (num_zerop (top->value))
925 pfile->state.skip_eval++;
926 break;
927 case CPP_COLON:
928 if (top->op != CPP_QUERY)
929 SYNTAX_ERROR (" ':' without preceding '?'");
930 if (!num_zerop (top[-1].value)) /* Was '?' condition true? */
931 pfile->state.skip_eval++;
932 else
933 pfile->state.skip_eval--;
934 default:
935 break;
938 want_value = true;
940 /* Check for and handle stack overflow. */
941 if (++top == pfile->op_limit)
942 top = _cpp_expand_op_stack (pfile);
944 top->op = op.op;
945 top->token = op.token;
948 /* The controlling macro expression is only valid if we called lex 3
949 times: <!> <defined expression> and <EOF>. push_conditional ()
950 checks that we are at top-of-file. */
951 if (pfile->mi_ind_cmacro && !(saw_leading_not && lex_count == 3))
952 pfile->mi_ind_cmacro = 0;
954 if (top != pfile->op_stack)
956 cpp_error (pfile, CPP_DL_ICE, "unbalanced stack in #if");
957 syntax_error:
958 return false; /* Return false on syntax error. */
961 return !num_zerop (top->value);
964 /* Reduce the operator / value stack if possible, in preparation for
965 pushing operator OP. Returns NULL on error, otherwise the top of
966 the stack. */
967 static struct op *
968 reduce (cpp_reader *pfile, struct op *top, enum cpp_ttype op)
970 unsigned int prio;
972 if (top->op <= CPP_EQ || top->op > CPP_LAST_CPP_OP + 2)
974 bad_op:
975 cpp_error (pfile, CPP_DL_ICE, "impossible operator '%u'", top->op);
976 return 0;
979 if (op == CPP_OPEN_PAREN)
980 return top;
982 /* Decrement the priority of left-associative operators to force a
983 reduction with operators of otherwise equal priority. */
984 prio = optab[op].prio - ((optab[op].flags & LEFT_ASSOC) != 0);
985 while (prio < optab[top->op].prio)
987 if (CPP_OPTION (pfile, warn_num_sign_change)
988 && optab[top->op].flags & CHECK_PROMOTION)
989 check_promotion (pfile, top);
991 switch (top->op)
993 case CPP_UPLUS:
994 case CPP_UMINUS:
995 case CPP_NOT:
996 case CPP_COMPL:
997 top[-1].value = num_unary_op (pfile, top->value, top->op);
998 break;
1000 case CPP_PLUS:
1001 case CPP_MINUS:
1002 case CPP_RSHIFT:
1003 case CPP_LSHIFT:
1004 case CPP_COMMA:
1005 top[-1].value = num_binary_op (pfile, top[-1].value,
1006 top->value, top->op);
1007 break;
1009 case CPP_GREATER:
1010 case CPP_LESS:
1011 case CPP_GREATER_EQ:
1012 case CPP_LESS_EQ:
1013 top[-1].value
1014 = num_inequality_op (pfile, top[-1].value, top->value, top->op);
1015 break;
1017 case CPP_EQ_EQ:
1018 case CPP_NOT_EQ:
1019 top[-1].value
1020 = num_equality_op (pfile, top[-1].value, top->value, top->op);
1021 break;
1023 case CPP_AND:
1024 case CPP_OR:
1025 case CPP_XOR:
1026 top[-1].value
1027 = num_bitwise_op (pfile, top[-1].value, top->value, top->op);
1028 break;
1030 case CPP_MULT:
1031 top[-1].value = num_mul (pfile, top[-1].value, top->value);
1032 break;
1034 case CPP_DIV:
1035 case CPP_MOD:
1036 top[-1].value = num_div_op (pfile, top[-1].value,
1037 top->value, top->op);
1038 break;
1040 case CPP_OR_OR:
1041 top--;
1042 if (!num_zerop (top->value))
1043 pfile->state.skip_eval--;
1044 top->value.low = (!num_zerop (top->value)
1045 || !num_zerop (top[1].value));
1046 top->value.high = 0;
1047 top->value.unsignedp = false;
1048 top->value.overflow = false;
1049 continue;
1051 case CPP_AND_AND:
1052 top--;
1053 if (num_zerop (top->value))
1054 pfile->state.skip_eval--;
1055 top->value.low = (!num_zerop (top->value)
1056 && !num_zerop (top[1].value));
1057 top->value.high = 0;
1058 top->value.unsignedp = false;
1059 top->value.overflow = false;
1060 continue;
1062 case CPP_OPEN_PAREN:
1063 if (op != CPP_CLOSE_PAREN)
1065 cpp_error (pfile, CPP_DL_ERROR, "missing ')' in expression");
1066 return 0;
1068 top--;
1069 top->value = top[1].value;
1070 return top;
1072 case CPP_COLON:
1073 top -= 2;
1074 if (!num_zerop (top->value))
1076 pfile->state.skip_eval--;
1077 top->value = top[1].value;
1079 else
1080 top->value = top[2].value;
1081 top->value.unsignedp = (top[1].value.unsignedp
1082 || top[2].value.unsignedp);
1083 continue;
1085 case CPP_QUERY:
1086 cpp_error (pfile, CPP_DL_ERROR, "'?' without following ':'");
1087 return 0;
1089 default:
1090 goto bad_op;
1093 top--;
1094 if (top->value.overflow && !pfile->state.skip_eval)
1095 cpp_error (pfile, CPP_DL_PEDWARN,
1096 "integer overflow in preprocessor expression");
1099 if (op == CPP_CLOSE_PAREN)
1101 cpp_error (pfile, CPP_DL_ERROR, "missing '(' in expression");
1102 return 0;
1105 return top;
1108 /* Returns the position of the old top of stack after expansion. */
1109 struct op *
1110 _cpp_expand_op_stack (cpp_reader *pfile)
1112 size_t old_size = (size_t) (pfile->op_limit - pfile->op_stack);
1113 size_t new_size = old_size * 2 + 20;
1115 pfile->op_stack = XRESIZEVEC (struct op, pfile->op_stack, new_size);
1116 pfile->op_limit = pfile->op_stack + new_size;
1118 return pfile->op_stack + old_size;
1121 /* Emits a warning if the effective sign of either operand of OP
1122 changes because of integer promotions. */
1123 static void
1124 check_promotion (cpp_reader *pfile, const struct op *op)
1126 if (op->value.unsignedp == op[-1].value.unsignedp)
1127 return;
1129 if (op->value.unsignedp)
1131 if (!num_positive (op[-1].value, CPP_OPTION (pfile, precision)))
1132 cpp_error (pfile, CPP_DL_WARNING,
1133 "the left operand of \"%s\" changes sign when promoted",
1134 cpp_token_as_text (pfile, op->token));
1136 else if (!num_positive (op->value, CPP_OPTION (pfile, precision)))
1137 cpp_error (pfile, CPP_DL_WARNING,
1138 "the right operand of \"%s\" changes sign when promoted",
1139 cpp_token_as_text (pfile, op->token));
1142 /* Clears the unused high order bits of the number pointed to by PNUM. */
1143 static cpp_num
1144 num_trim (cpp_num num, size_t precision)
1146 if (precision > PART_PRECISION)
1148 precision -= PART_PRECISION;
1149 if (precision < PART_PRECISION)
1150 num.high &= ((cpp_num_part) 1 << precision) - 1;
1152 else
1154 if (precision < PART_PRECISION)
1155 num.low &= ((cpp_num_part) 1 << precision) - 1;
1156 num.high = 0;
1159 return num;
1162 /* True iff A (presumed signed) >= 0. */
1163 static bool
1164 num_positive (cpp_num num, size_t precision)
1166 if (precision > PART_PRECISION)
1168 precision -= PART_PRECISION;
1169 return (num.high & (cpp_num_part) 1 << (precision - 1)) == 0;
1172 return (num.low & (cpp_num_part) 1 << (precision - 1)) == 0;
1175 /* Sign extend a number, with PRECISION significant bits and all
1176 others assumed clear, to fill out a cpp_num structure. */
1177 cpp_num
1178 cpp_num_sign_extend (cpp_num num, size_t precision)
1180 if (!num.unsignedp)
1182 if (precision > PART_PRECISION)
1184 precision -= PART_PRECISION;
1185 if (precision < PART_PRECISION
1186 && (num.high & (cpp_num_part) 1 << (precision - 1)))
1187 num.high |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1189 else if (num.low & (cpp_num_part) 1 << (precision - 1))
1191 if (precision < PART_PRECISION)
1192 num.low |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1193 num.high = ~(cpp_num_part) 0;
1197 return num;
1200 /* Returns the negative of NUM. */
1201 static cpp_num
1202 num_negate (cpp_num num, size_t precision)
1204 cpp_num copy;
1206 copy = num;
1207 num.high = ~num.high;
1208 num.low = ~num.low;
1209 if (++num.low == 0)
1210 num.high++;
1211 num = num_trim (num, precision);
1212 num.overflow = (!num.unsignedp && num_eq (num, copy) && !num_zerop (num));
1214 return num;
1217 /* Returns true if A >= B. */
1218 static bool
1219 num_greater_eq (cpp_num pa, cpp_num pb, size_t precision)
1221 bool unsignedp;
1223 unsignedp = pa.unsignedp || pb.unsignedp;
1225 if (!unsignedp)
1227 /* Both numbers have signed type. If they are of different
1228 sign, the answer is the sign of A. */
1229 unsignedp = num_positive (pa, precision);
1231 if (unsignedp != num_positive (pb, precision))
1232 return unsignedp;
1234 /* Otherwise we can do an unsigned comparison. */
1237 return (pa.high > pb.high) || (pa.high == pb.high && pa.low >= pb.low);
1240 /* Returns LHS OP RHS, where OP is a bit-wise operation. */
1241 static cpp_num
1242 num_bitwise_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1243 cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1245 lhs.overflow = false;
1246 lhs.unsignedp = lhs.unsignedp || rhs.unsignedp;
1248 /* As excess precision is zeroed, there is no need to num_trim () as
1249 these operations cannot introduce a set bit there. */
1250 if (op == CPP_AND)
1252 lhs.low &= rhs.low;
1253 lhs.high &= rhs.high;
1255 else if (op == CPP_OR)
1257 lhs.low |= rhs.low;
1258 lhs.high |= rhs.high;
1260 else
1262 lhs.low ^= rhs.low;
1263 lhs.high ^= rhs.high;
1266 return lhs;
1269 /* Returns LHS OP RHS, where OP is an inequality. */
1270 static cpp_num
1271 num_inequality_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs,
1272 enum cpp_ttype op)
1274 bool gte = num_greater_eq (lhs, rhs, CPP_OPTION (pfile, precision));
1276 if (op == CPP_GREATER_EQ)
1277 lhs.low = gte;
1278 else if (op == CPP_LESS)
1279 lhs.low = !gte;
1280 else if (op == CPP_GREATER)
1281 lhs.low = gte && !num_eq (lhs, rhs);
1282 else /* CPP_LESS_EQ. */
1283 lhs.low = !gte || num_eq (lhs, rhs);
1285 lhs.high = 0;
1286 lhs.overflow = false;
1287 lhs.unsignedp = false;
1288 return lhs;
1291 /* Returns LHS OP RHS, where OP is == or !=. */
1292 static cpp_num
1293 num_equality_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1294 cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1296 /* Work around a 3.0.4 bug; see PR 6950. */
1297 bool eq = num_eq (lhs, rhs);
1298 if (op == CPP_NOT_EQ)
1299 eq = !eq;
1300 lhs.low = eq;
1301 lhs.high = 0;
1302 lhs.overflow = false;
1303 lhs.unsignedp = false;
1304 return lhs;
1307 /* Shift NUM, of width PRECISION, right by N bits. */
1308 static cpp_num
1309 num_rshift (cpp_num num, size_t precision, size_t n)
1311 cpp_num_part sign_mask;
1312 bool x = num_positive (num, precision);
1314 if (num.unsignedp || x)
1315 sign_mask = 0;
1316 else
1317 sign_mask = ~(cpp_num_part) 0;
1319 if (n >= precision)
1320 num.high = num.low = sign_mask;
1321 else
1323 /* Sign-extend. */
1324 if (precision < PART_PRECISION)
1325 num.high = sign_mask, num.low |= sign_mask << precision;
1326 else if (precision < 2 * PART_PRECISION)
1327 num.high |= sign_mask << (precision - PART_PRECISION);
1329 if (n >= PART_PRECISION)
1331 n -= PART_PRECISION;
1332 num.low = num.high;
1333 num.high = sign_mask;
1336 if (n)
1338 num.low = (num.low >> n) | (num.high << (PART_PRECISION - n));
1339 num.high = (num.high >> n) | (sign_mask << (PART_PRECISION - n));
1343 num = num_trim (num, precision);
1344 num.overflow = false;
1345 return num;
1348 /* Shift NUM, of width PRECISION, left by N bits. */
1349 static cpp_num
1350 num_lshift (cpp_num num, size_t precision, size_t n)
1352 if (n >= precision)
1354 num.overflow = !num.unsignedp && !num_zerop (num);
1355 num.high = num.low = 0;
1357 else
1359 cpp_num orig, maybe_orig;
1360 size_t m = n;
1362 orig = num;
1363 if (m >= PART_PRECISION)
1365 m -= PART_PRECISION;
1366 num.high = num.low;
1367 num.low = 0;
1369 if (m)
1371 num.high = (num.high << m) | (num.low >> (PART_PRECISION - m));
1372 num.low <<= m;
1374 num = num_trim (num, precision);
1376 if (num.unsignedp)
1377 num.overflow = false;
1378 else
1380 maybe_orig = num_rshift (num, precision, n);
1381 num.overflow = !num_eq (orig, maybe_orig);
1385 return num;
1388 /* The four unary operators: +, -, ! and ~. */
1389 static cpp_num
1390 num_unary_op (cpp_reader *pfile, cpp_num num, enum cpp_ttype op)
1392 switch (op)
1394 case CPP_UPLUS:
1395 if (CPP_WTRADITIONAL (pfile) && !pfile->state.skip_eval)
1396 cpp_error (pfile, CPP_DL_WARNING,
1397 "traditional C rejects the unary plus operator");
1398 num.overflow = false;
1399 break;
1401 case CPP_UMINUS:
1402 num = num_negate (num, CPP_OPTION (pfile, precision));
1403 break;
1405 case CPP_COMPL:
1406 num.high = ~num.high;
1407 num.low = ~num.low;
1408 num = num_trim (num, CPP_OPTION (pfile, precision));
1409 num.overflow = false;
1410 break;
1412 default: /* case CPP_NOT: */
1413 num.low = num_zerop (num);
1414 num.high = 0;
1415 num.overflow = false;
1416 num.unsignedp = false;
1417 break;
1420 return num;
1423 /* The various binary operators. */
1424 static cpp_num
1425 num_binary_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1427 cpp_num result;
1428 size_t precision = CPP_OPTION (pfile, precision);
1429 size_t n;
1431 switch (op)
1433 /* Shifts. */
1434 case CPP_LSHIFT:
1435 case CPP_RSHIFT:
1436 if (!rhs.unsignedp && !num_positive (rhs, precision))
1438 /* A negative shift is a positive shift the other way. */
1439 if (op == CPP_LSHIFT)
1440 op = CPP_RSHIFT;
1441 else
1442 op = CPP_LSHIFT;
1443 rhs = num_negate (rhs, precision);
1445 if (rhs.high)
1446 n = ~0; /* Maximal. */
1447 else
1448 n = rhs.low;
1449 if (op == CPP_LSHIFT)
1450 lhs = num_lshift (lhs, precision, n);
1451 else
1452 lhs = num_rshift (lhs, precision, n);
1453 break;
1455 /* Arithmetic. */
1456 case CPP_MINUS:
1457 rhs = num_negate (rhs, precision);
1458 case CPP_PLUS:
1459 result.low = lhs.low + rhs.low;
1460 result.high = lhs.high + rhs.high;
1461 if (result.low < lhs.low)
1462 result.high++;
1463 result.unsignedp = lhs.unsignedp || rhs.unsignedp;
1464 result.overflow = false;
1466 result = num_trim (result, precision);
1467 if (!result.unsignedp)
1469 bool lhsp = num_positive (lhs, precision);
1470 result.overflow = (lhsp == num_positive (rhs, precision)
1471 && lhsp != num_positive (result, precision));
1473 return result;
1475 /* Comma. */
1476 default: /* case CPP_COMMA: */
1477 if (CPP_PEDANTIC (pfile) && (!CPP_OPTION (pfile, c99)
1478 || !pfile->state.skip_eval))
1479 cpp_error (pfile, CPP_DL_PEDWARN,
1480 "comma operator in operand of #if");
1481 lhs = rhs;
1482 break;
1485 return lhs;
1488 /* Multiplies two unsigned cpp_num_parts to give a cpp_num. This
1489 cannot overflow. */
1490 static cpp_num
1491 num_part_mul (cpp_num_part lhs, cpp_num_part rhs)
1493 cpp_num result;
1494 cpp_num_part middle[2], temp;
1496 result.low = LOW_PART (lhs) * LOW_PART (rhs);
1497 result.high = HIGH_PART (lhs) * HIGH_PART (rhs);
1499 middle[0] = LOW_PART (lhs) * HIGH_PART (rhs);
1500 middle[1] = HIGH_PART (lhs) * LOW_PART (rhs);
1502 temp = result.low;
1503 result.low += LOW_PART (middle[0]) << (PART_PRECISION / 2);
1504 if (result.low < temp)
1505 result.high++;
1507 temp = result.low;
1508 result.low += LOW_PART (middle[1]) << (PART_PRECISION / 2);
1509 if (result.low < temp)
1510 result.high++;
1512 result.high += HIGH_PART (middle[0]);
1513 result.high += HIGH_PART (middle[1]);
1514 result.unsignedp = true;
1515 result.overflow = false;
1517 return result;
1520 /* Multiply two preprocessing numbers. */
1521 static cpp_num
1522 num_mul (cpp_reader *pfile, cpp_num lhs, cpp_num rhs)
1524 cpp_num result, temp;
1525 bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1526 bool overflow, negate = false;
1527 size_t precision = CPP_OPTION (pfile, precision);
1529 /* Prepare for unsigned multiplication. */
1530 if (!unsignedp)
1532 if (!num_positive (lhs, precision))
1533 negate = !negate, lhs = num_negate (lhs, precision);
1534 if (!num_positive (rhs, precision))
1535 negate = !negate, rhs = num_negate (rhs, precision);
1538 overflow = lhs.high && rhs.high;
1539 result = num_part_mul (lhs.low, rhs.low);
1541 temp = num_part_mul (lhs.high, rhs.low);
1542 result.high += temp.low;
1543 if (temp.high)
1544 overflow = true;
1546 temp = num_part_mul (lhs.low, rhs.high);
1547 result.high += temp.low;
1548 if (temp.high)
1549 overflow = true;
1551 temp.low = result.low, temp.high = result.high;
1552 result = num_trim (result, precision);
1553 if (!num_eq (result, temp))
1554 overflow = true;
1556 if (negate)
1557 result = num_negate (result, precision);
1559 if (unsignedp)
1560 result.overflow = false;
1561 else
1562 result.overflow = overflow || (num_positive (result, precision) ^ !negate
1563 && !num_zerop (result));
1564 result.unsignedp = unsignedp;
1566 return result;
1569 /* Divide two preprocessing numbers, returning the answer or the
1570 remainder depending upon OP. */
1571 static cpp_num
1572 num_div_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1574 cpp_num result, sub;
1575 cpp_num_part mask;
1576 bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1577 bool negate = false, lhs_neg = false;
1578 size_t i, precision = CPP_OPTION (pfile, precision);
1580 /* Prepare for unsigned division. */
1581 if (!unsignedp)
1583 if (!num_positive (lhs, precision))
1584 negate = !negate, lhs_neg = true, lhs = num_negate (lhs, precision);
1585 if (!num_positive (rhs, precision))
1586 negate = !negate, rhs = num_negate (rhs, precision);
1589 /* Find the high bit. */
1590 if (rhs.high)
1592 i = precision - 1;
1593 mask = (cpp_num_part) 1 << (i - PART_PRECISION);
1594 for (; ; i--, mask >>= 1)
1595 if (rhs.high & mask)
1596 break;
1598 else if (rhs.low)
1600 if (precision > PART_PRECISION)
1601 i = precision - PART_PRECISION - 1;
1602 else
1603 i = precision - 1;
1604 mask = (cpp_num_part) 1 << i;
1605 for (; ; i--, mask >>= 1)
1606 if (rhs.low & mask)
1607 break;
1609 else
1611 if (!pfile->state.skip_eval)
1612 cpp_error (pfile, CPP_DL_ERROR, "division by zero in #if");
1613 return lhs;
1616 /* First nonzero bit of RHS is bit I. Do naive division by
1617 shifting the RHS fully left, and subtracting from LHS if LHS is
1618 at least as big, and then repeating but with one less shift.
1619 This is not very efficient, but is easy to understand. */
1621 rhs.unsignedp = true;
1622 lhs.unsignedp = true;
1623 i = precision - i - 1;
1624 sub = num_lshift (rhs, precision, i);
1626 result.high = result.low = 0;
1627 for (;;)
1629 if (num_greater_eq (lhs, sub, precision))
1631 lhs = num_binary_op (pfile, lhs, sub, CPP_MINUS);
1632 if (i >= PART_PRECISION)
1633 result.high |= (cpp_num_part) 1 << (i - PART_PRECISION);
1634 else
1635 result.low |= (cpp_num_part) 1 << i;
1637 if (i-- == 0)
1638 break;
1639 sub.low = (sub.low >> 1) | (sub.high << (PART_PRECISION - 1));
1640 sub.high >>= 1;
1643 /* We divide so that the remainder has the sign of the LHS. */
1644 if (op == CPP_DIV)
1646 result.unsignedp = unsignedp;
1647 result.overflow = false;
1648 if (!unsignedp)
1650 if (negate)
1651 result = num_negate (result, precision);
1652 result.overflow = (num_positive (result, precision) ^ !negate
1653 && !num_zerop (result));
1656 return result;
1659 /* CPP_MOD. */
1660 lhs.unsignedp = unsignedp;
1661 lhs.overflow = false;
1662 if (lhs_neg)
1663 lhs = num_negate (lhs, precision);
1665 return lhs;