2005-04-26 Paul Brook <paul@codesourcery.com>
[official-gcc.git] / libcpp / expr.c
blob47689189b2b632379e24bf31c7aacb1a79f8b004
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, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, 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 (CPP_LAST_CPP_OP + 1)
69 #define CPP_UMINUS (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 = 0, l = 0, i = 0;
87 while (len--)
88 switch (s[len])
90 case 'f': case 'F': f++; break;
91 case 'l': case 'L': l++; break;
92 case 'i': case 'I':
93 case 'j': case 'J': i++; break;
94 default:
95 return 0;
98 if (f + l > 1 || i > 1)
99 return 0;
101 return ((i ? CPP_N_IMAGINARY : 0)
102 | (f ? CPP_N_SMALL :
103 l ? CPP_N_LARGE : CPP_N_MEDIUM));
106 /* Subroutine of cpp_classify_number. S points to an integer suffix
107 of length LEN, possibly zero. Returns 0 for an invalid suffix, or a
108 flag vector describing the suffix. */
109 static unsigned int
110 interpret_int_suffix (const uchar *s, size_t len)
112 size_t u, l, i;
114 u = l = i = 0;
116 while (len--)
117 switch (s[len])
119 case 'u': case 'U': u++; break;
120 case 'i': case 'I':
121 case 'j': case 'J': i++; break;
122 case 'l': case 'L': l++;
123 /* If there are two Ls, they must be adjacent and the same case. */
124 if (l == 2 && s[len] != s[len + 1])
125 return 0;
126 break;
127 default:
128 return 0;
131 if (l > 2 || u > 1 || i > 1)
132 return 0;
134 return ((i ? CPP_N_IMAGINARY : 0)
135 | (u ? CPP_N_UNSIGNED : 0)
136 | ((l == 0) ? CPP_N_SMALL
137 : (l == 1) ? CPP_N_MEDIUM : CPP_N_LARGE));
140 /* Categorize numeric constants according to their field (integer,
141 floating point, or invalid), radix (decimal, octal, hexadecimal),
142 and type suffixes. */
143 unsigned int
144 cpp_classify_number (cpp_reader *pfile, const cpp_token *token)
146 const uchar *str = token->val.str.text;
147 const uchar *limit;
148 unsigned int max_digit, result, radix;
149 enum {NOT_FLOAT = 0, AFTER_POINT, AFTER_EXPON} float_flag;
151 /* If the lexer has done its job, length one can only be a single
152 digit. Fast-path this very common case. */
153 if (token->val.str.len == 1)
154 return CPP_N_INTEGER | CPP_N_SMALL | CPP_N_DECIMAL;
156 limit = str + token->val.str.len;
157 float_flag = NOT_FLOAT;
158 max_digit = 0;
159 radix = 10;
161 /* First, interpret the radix. */
162 if (*str == '0')
164 radix = 8;
165 str++;
167 /* Require at least one hex digit to classify it as hex. */
168 if ((*str == 'x' || *str == 'X')
169 && (str[1] == '.' || ISXDIGIT (str[1])))
171 radix = 16;
172 str++;
176 /* Now scan for a well-formed integer or float. */
177 for (;;)
179 unsigned int c = *str++;
181 if (ISDIGIT (c) || (ISXDIGIT (c) && radix == 16))
183 c = hex_value (c);
184 if (c > max_digit)
185 max_digit = c;
187 else if (c == '.')
189 if (float_flag == NOT_FLOAT)
190 float_flag = AFTER_POINT;
191 else
192 SYNTAX_ERROR ("too many decimal points in number");
194 else if ((radix <= 10 && (c == 'e' || c == 'E'))
195 || (radix == 16 && (c == 'p' || c == 'P')))
197 float_flag = AFTER_EXPON;
198 break;
200 else
202 /* Start of suffix. */
203 str--;
204 break;
208 if (float_flag != NOT_FLOAT && radix == 8)
209 radix = 10;
211 if (max_digit >= radix)
212 SYNTAX_ERROR2 ("invalid digit \"%c\" in octal constant", '0' + max_digit);
214 if (float_flag != NOT_FLOAT)
216 if (radix == 16 && CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, c99))
217 cpp_error (pfile, CPP_DL_PEDWARN,
218 "use of C99 hexadecimal floating constant");
220 if (float_flag == AFTER_EXPON)
222 if (*str == '+' || *str == '-')
223 str++;
225 /* Exponent is decimal, even if string is a hex float. */
226 if (!ISDIGIT (*str))
227 SYNTAX_ERROR ("exponent has no digits");
230 str++;
231 while (ISDIGIT (*str));
233 else if (radix == 16)
234 SYNTAX_ERROR ("hexadecimal floating constants require an exponent");
236 result = interpret_float_suffix (str, limit - str);
237 if (result == 0)
239 cpp_error (pfile, CPP_DL_ERROR,
240 "invalid suffix \"%.*s\" on floating constant",
241 (int) (limit - str), str);
242 return CPP_N_INVALID;
245 /* Traditional C didn't accept any floating suffixes. */
246 if (limit != str
247 && CPP_WTRADITIONAL (pfile)
248 && ! cpp_sys_macro_p (pfile))
249 cpp_error (pfile, CPP_DL_WARNING,
250 "traditional C rejects the \"%.*s\" suffix",
251 (int) (limit - str), str);
253 result |= CPP_N_FLOATING;
255 else
257 result = interpret_int_suffix (str, limit - str);
258 if (result == 0)
260 cpp_error (pfile, CPP_DL_ERROR,
261 "invalid suffix \"%.*s\" on integer constant",
262 (int) (limit - str), str);
263 return CPP_N_INVALID;
266 /* Traditional C only accepted the 'L' suffix.
267 Suppress warning about 'LL' with -Wno-long-long. */
268 if (CPP_WTRADITIONAL (pfile) && ! cpp_sys_macro_p (pfile))
270 int u_or_i = (result & (CPP_N_UNSIGNED|CPP_N_IMAGINARY));
271 int large = (result & CPP_N_WIDTH) == CPP_N_LARGE;
273 if (u_or_i || (large && CPP_OPTION (pfile, warn_long_long)))
274 cpp_error (pfile, CPP_DL_WARNING,
275 "traditional C rejects the \"%.*s\" suffix",
276 (int) (limit - str), str);
279 if ((result & CPP_N_WIDTH) == CPP_N_LARGE
280 && ! CPP_OPTION (pfile, c99)
281 && CPP_OPTION (pfile, warn_long_long))
282 cpp_error (pfile, CPP_DL_PEDWARN,
283 "use of C99 long long integer constant");
285 result |= CPP_N_INTEGER;
288 if ((result & CPP_N_IMAGINARY) && CPP_PEDANTIC (pfile))
289 cpp_error (pfile, CPP_DL_PEDWARN,
290 "imaginary constants are a GCC extension");
292 if (radix == 10)
293 result |= CPP_N_DECIMAL;
294 else if (radix == 16)
295 result |= CPP_N_HEX;
296 else
297 result |= CPP_N_OCTAL;
299 return result;
301 syntax_error:
302 return CPP_N_INVALID;
305 /* cpp_interpret_integer converts an integer constant into a cpp_num,
306 of precision options->precision.
308 We do not provide any interface for decimal->float conversion,
309 because the preprocessor doesn't need it and we don't want to
310 drag in GCC's floating point emulator. */
311 cpp_num
312 cpp_interpret_integer (cpp_reader *pfile, const cpp_token *token,
313 unsigned int type)
315 const uchar *p, *end;
316 cpp_num result;
318 result.low = 0;
319 result.high = 0;
320 result.unsignedp = !!(type & CPP_N_UNSIGNED);
321 result.overflow = false;
323 p = token->val.str.text;
324 end = p + token->val.str.len;
326 /* Common case of a single digit. */
327 if (token->val.str.len == 1)
328 result.low = p[0] - '0';
329 else
331 cpp_num_part max;
332 size_t precision = CPP_OPTION (pfile, precision);
333 unsigned int base = 10, c = 0;
334 bool overflow = false;
336 if ((type & CPP_N_RADIX) == CPP_N_OCTAL)
338 base = 8;
339 p++;
341 else if ((type & CPP_N_RADIX) == CPP_N_HEX)
343 base = 16;
344 p += 2;
347 /* We can add a digit to numbers strictly less than this without
348 needing the precision and slowness of double integers. */
349 max = ~(cpp_num_part) 0;
350 if (precision < PART_PRECISION)
351 max >>= PART_PRECISION - precision;
352 max = (max - base + 1) / base + 1;
354 for (; p < end; p++)
356 c = *p;
358 if (ISDIGIT (c) || (base == 16 && ISXDIGIT (c)))
359 c = hex_value (c);
360 else
361 break;
363 /* Strict inequality for when max is set to zero. */
364 if (result.low < max)
365 result.low = result.low * base + c;
366 else
368 result = append_digit (result, c, base, precision);
369 overflow |= result.overflow;
370 max = 0;
374 if (overflow)
375 cpp_error (pfile, CPP_DL_PEDWARN,
376 "integer constant is too large for its type");
377 /* If too big to be signed, consider it unsigned. Only warn for
378 decimal numbers. Traditional numbers were always signed (but
379 we still honor an explicit U suffix); but we only have
380 traditional semantics in directives. */
381 else if (!result.unsignedp
382 && !(CPP_OPTION (pfile, traditional)
383 && pfile->state.in_directive)
384 && !num_positive (result, precision))
386 if (base == 10)
387 cpp_error (pfile, CPP_DL_WARNING,
388 "integer constant is so large that it is unsigned");
389 result.unsignedp = true;
393 return result;
396 /* Append DIGIT to NUM, a number of PRECISION bits being read in base BASE. */
397 static cpp_num
398 append_digit (cpp_num num, int digit, int base, size_t precision)
400 cpp_num result;
401 unsigned int shift = 3 + (base == 16);
402 bool overflow;
403 cpp_num_part add_high, add_low;
405 /* Multiply by 8 or 16. Catching this overflow here means we don't
406 need to worry about add_high overflowing. */
407 overflow = !!(num.high >> (PART_PRECISION - shift));
408 result.high = num.high << shift;
409 result.low = num.low << shift;
410 result.high |= num.low >> (PART_PRECISION - shift);
411 result.unsignedp = num.unsignedp;
413 if (base == 10)
415 add_low = num.low << 1;
416 add_high = (num.high << 1) + (num.low >> (PART_PRECISION - 1));
418 else
419 add_high = add_low = 0;
421 if (add_low + digit < add_low)
422 add_high++;
423 add_low += digit;
425 if (result.low + add_low < result.low)
426 add_high++;
427 if (result.high + add_high < result.high)
428 overflow = true;
430 result.low += add_low;
431 result.high += add_high;
432 result.overflow = overflow;
434 /* The above code catches overflow of a cpp_num type. This catches
435 overflow of the (possibly shorter) target precision. */
436 num.low = result.low;
437 num.high = result.high;
438 result = num_trim (result, precision);
439 if (!num_eq (result, num))
440 result.overflow = true;
442 return result;
445 /* Handle meeting "defined" in a preprocessor expression. */
446 static cpp_num
447 parse_defined (cpp_reader *pfile)
449 cpp_num result;
450 int paren = 0;
451 cpp_hashnode *node = 0;
452 const cpp_token *token;
453 cpp_context *initial_context = pfile->context;
455 /* Don't expand macros. */
456 pfile->state.prevent_expansion++;
458 token = cpp_get_token (pfile);
459 if (token->type == CPP_OPEN_PAREN)
461 paren = 1;
462 token = cpp_get_token (pfile);
465 if (token->type == CPP_NAME)
467 node = token->val.node;
468 if (paren && cpp_get_token (pfile)->type != CPP_CLOSE_PAREN)
470 cpp_error (pfile, CPP_DL_ERROR, "missing ')' after \"defined\"");
471 node = 0;
474 else
476 cpp_error (pfile, CPP_DL_ERROR,
477 "operator \"defined\" requires an identifier");
478 if (token->flags & NAMED_OP)
480 cpp_token op;
482 op.flags = 0;
483 op.type = token->type;
484 cpp_error (pfile, CPP_DL_ERROR,
485 "(\"%s\" is an alternative token for \"%s\" in C++)",
486 cpp_token_as_text (pfile, token),
487 cpp_token_as_text (pfile, &op));
491 if (node)
493 if (pfile->context != initial_context && CPP_PEDANTIC (pfile))
494 cpp_error (pfile, CPP_DL_WARNING,
495 "this use of \"defined\" may not be portable");
497 _cpp_mark_macro_used (node);
499 /* A possible controlling macro of the form #if !defined ().
500 _cpp_parse_expr checks there was no other junk on the line. */
501 pfile->mi_ind_cmacro = node;
504 pfile->state.prevent_expansion--;
506 result.unsignedp = false;
507 result.high = 0;
508 result.overflow = false;
509 result.low = node && node->type == NT_MACRO;
510 return result;
513 /* Convert a token into a CPP_NUMBER (an interpreted preprocessing
514 number or character constant, or the result of the "defined" or "#"
515 operators). */
516 static cpp_num
517 eval_token (cpp_reader *pfile, const cpp_token *token)
519 cpp_num result;
520 unsigned int temp;
521 int unsignedp = 0;
523 result.unsignedp = false;
524 result.overflow = false;
526 switch (token->type)
528 case CPP_NUMBER:
529 temp = cpp_classify_number (pfile, token);
530 switch (temp & CPP_N_CATEGORY)
532 case CPP_N_FLOATING:
533 cpp_error (pfile, CPP_DL_ERROR,
534 "floating constant in preprocessor expression");
535 break;
536 case CPP_N_INTEGER:
537 if (!(temp & CPP_N_IMAGINARY))
538 return cpp_interpret_integer (pfile, token, temp);
539 cpp_error (pfile, CPP_DL_ERROR,
540 "imaginary number in preprocessor expression");
541 break;
543 case CPP_N_INVALID:
544 /* Error already issued. */
545 break;
547 result.high = result.low = 0;
548 break;
550 case CPP_WCHAR:
551 case CPP_CHAR:
553 cppchar_t cc = cpp_interpret_charconst (pfile, token,
554 &temp, &unsignedp);
556 result.high = 0;
557 result.low = cc;
558 /* Sign-extend the result if necessary. */
559 if (!unsignedp && (cppchar_signed_t) cc < 0)
561 if (PART_PRECISION > BITS_PER_CPPCHAR_T)
562 result.low |= ~(~(cpp_num_part) 0
563 >> (PART_PRECISION - BITS_PER_CPPCHAR_T));
564 result.high = ~(cpp_num_part) 0;
565 result = num_trim (result, CPP_OPTION (pfile, precision));
568 break;
570 case CPP_NAME:
571 if (token->val.node == pfile->spec_nodes.n_defined)
572 return parse_defined (pfile);
573 else if (CPP_OPTION (pfile, cplusplus)
574 && (token->val.node == pfile->spec_nodes.n_true
575 || token->val.node == pfile->spec_nodes.n_false))
577 result.high = 0;
578 result.low = (token->val.node == pfile->spec_nodes.n_true);
580 else
582 result.high = 0;
583 result.low = 0;
584 if (CPP_OPTION (pfile, warn_undef) && !pfile->state.skip_eval)
585 cpp_error (pfile, CPP_DL_WARNING, "\"%s\" is not defined",
586 NODE_NAME (token->val.node));
588 break;
590 default: /* CPP_HASH */
591 _cpp_test_assertion (pfile, &temp);
592 result.high = 0;
593 result.low = temp;
596 result.unsignedp = !!unsignedp;
597 return result;
600 /* Operator precedence and flags table.
602 After an operator is returned from the lexer, if it has priority less
603 than the operator on the top of the stack, we reduce the stack by one
604 operator and repeat the test. Since equal priorities do not reduce,
605 this is naturally right-associative.
607 We handle left-associative operators by decrementing the priority of
608 just-lexed operators by one, but retaining the priority of operators
609 already on the stack.
611 The remaining cases are '(' and ')'. We handle '(' by skipping the
612 reduction phase completely. ')' is given lower priority than
613 everything else, including '(', effectively forcing a reduction of the
614 parenthesized expression. If there is a matching '(', the routine
615 reduce() exits immediately. If the normal exit route sees a ')', then
616 there cannot have been a matching '(' and an error message is output.
618 The parser assumes all shifted operators require a left operand unless
619 the flag NO_L_OPERAND is set. These semantics are automatic; any
620 extra semantics need to be handled with operator-specific code. */
622 /* Flags. If CHECK_PROMOTION, we warn if the effective sign of an
623 operand changes because of integer promotions. */
624 #define NO_L_OPERAND (1 << 0)
625 #define LEFT_ASSOC (1 << 1)
626 #define CHECK_PROMOTION (1 << 2)
628 /* Operator to priority map. Must be in the same order as the first
629 N entries of enum cpp_ttype. */
630 static const struct operator
632 uchar prio;
633 uchar flags;
634 } optab[] =
636 /* EQ */ {0, 0}, /* Shouldn't happen. */
637 /* NOT */ {16, NO_L_OPERAND},
638 /* GREATER */ {12, LEFT_ASSOC | CHECK_PROMOTION},
639 /* LESS */ {12, LEFT_ASSOC | CHECK_PROMOTION},
640 /* PLUS */ {14, LEFT_ASSOC | CHECK_PROMOTION},
641 /* MINUS */ {14, LEFT_ASSOC | CHECK_PROMOTION},
642 /* MULT */ {15, LEFT_ASSOC | CHECK_PROMOTION},
643 /* DIV */ {15, LEFT_ASSOC | CHECK_PROMOTION},
644 /* MOD */ {15, LEFT_ASSOC | CHECK_PROMOTION},
645 /* AND */ {9, LEFT_ASSOC | CHECK_PROMOTION},
646 /* OR */ {7, LEFT_ASSOC | CHECK_PROMOTION},
647 /* XOR */ {8, LEFT_ASSOC | CHECK_PROMOTION},
648 /* RSHIFT */ {13, LEFT_ASSOC},
649 /* LSHIFT */ {13, LEFT_ASSOC},
651 /* MIN */ {10, LEFT_ASSOC | CHECK_PROMOTION},
652 /* MAX */ {10, LEFT_ASSOC | CHECK_PROMOTION},
654 /* COMPL */ {16, NO_L_OPERAND},
655 /* AND_AND */ {6, LEFT_ASSOC},
656 /* OR_OR */ {5, LEFT_ASSOC},
657 /* QUERY */ {3, 0},
658 /* COLON */ {4, LEFT_ASSOC | CHECK_PROMOTION},
659 /* COMMA */ {2, LEFT_ASSOC},
660 /* OPEN_PAREN */ {1, NO_L_OPERAND},
661 /* CLOSE_PAREN */ {0, 0},
662 /* EOF */ {0, 0},
663 /* EQ_EQ */ {11, LEFT_ASSOC},
664 /* NOT_EQ */ {11, LEFT_ASSOC},
665 /* GREATER_EQ */ {12, LEFT_ASSOC | CHECK_PROMOTION},
666 /* LESS_EQ */ {12, LEFT_ASSOC | CHECK_PROMOTION},
667 /* UPLUS */ {16, NO_L_OPERAND},
668 /* UMINUS */ {16, NO_L_OPERAND}
671 /* Parse and evaluate a C expression, reading from PFILE.
672 Returns the truth value of the expression.
674 The implementation is an operator precedence parser, i.e. a
675 bottom-up parser, using a stack for not-yet-reduced tokens.
677 The stack base is op_stack, and the current stack pointer is 'top'.
678 There is a stack element for each operator (only), and the most
679 recently pushed operator is 'top->op'. An operand (value) is
680 stored in the 'value' field of the stack element of the operator
681 that precedes it. */
682 bool
683 _cpp_parse_expr (cpp_reader *pfile)
685 struct op *top = pfile->op_stack;
686 unsigned int lex_count;
687 bool saw_leading_not, want_value = true;
689 pfile->state.skip_eval = 0;
691 /* Set up detection of #if ! defined(). */
692 pfile->mi_ind_cmacro = 0;
693 saw_leading_not = false;
694 lex_count = 0;
696 /* Lowest priority operator prevents further reductions. */
697 top->op = CPP_EOF;
699 for (;;)
701 struct op op;
703 lex_count++;
704 op.token = cpp_get_token (pfile);
705 op.op = op.token->type;
707 switch (op.op)
709 /* These tokens convert into values. */
710 case CPP_NUMBER:
711 case CPP_CHAR:
712 case CPP_WCHAR:
713 case CPP_NAME:
714 case CPP_HASH:
715 if (!want_value)
716 SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
717 cpp_token_as_text (pfile, op.token));
718 want_value = false;
719 top->value = eval_token (pfile, op.token);
720 continue;
722 case CPP_NOT:
723 saw_leading_not = lex_count == 1;
724 break;
725 case CPP_PLUS:
726 if (want_value)
727 op.op = CPP_UPLUS;
728 break;
729 case CPP_MINUS:
730 if (want_value)
731 op.op = CPP_UMINUS;
732 break;
734 default:
735 if ((int) op.op <= (int) CPP_EQ || (int) op.op >= (int) CPP_PLUS_EQ)
736 SYNTAX_ERROR2 ("token \"%s\" is not valid in preprocessor expressions",
737 cpp_token_as_text (pfile, op.token));
738 break;
741 /* Check we have a value or operator as appropriate. */
742 if (optab[op.op].flags & NO_L_OPERAND)
744 if (!want_value)
745 SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
746 cpp_token_as_text (pfile, op.token));
748 else if (want_value)
750 /* We want a number (or expression) and haven't got one.
751 Try to emit a specific diagnostic. */
752 if (op.op == CPP_CLOSE_PAREN && top->op == CPP_OPEN_PAREN)
753 SYNTAX_ERROR ("missing expression between '(' and ')'");
755 if (op.op == CPP_EOF && top->op == CPP_EOF)
756 SYNTAX_ERROR ("#if with no expression");
758 if (top->op != CPP_EOF && top->op != CPP_OPEN_PAREN)
759 SYNTAX_ERROR2 ("operator '%s' has no right operand",
760 cpp_token_as_text (pfile, top->token));
761 else if (op.op == CPP_CLOSE_PAREN || op.op == CPP_EOF)
762 /* Complain about missing paren during reduction. */;
763 else
764 SYNTAX_ERROR2 ("operator '%s' has no left operand",
765 cpp_token_as_text (pfile, op.token));
768 top = reduce (pfile, top, op.op);
769 if (!top)
770 goto syntax_error;
772 if (op.op == CPP_EOF)
773 break;
775 switch (op.op)
777 case CPP_CLOSE_PAREN:
778 continue;
779 case CPP_OR_OR:
780 if (!num_zerop (top->value))
781 pfile->state.skip_eval++;
782 break;
783 case CPP_AND_AND:
784 case CPP_QUERY:
785 if (num_zerop (top->value))
786 pfile->state.skip_eval++;
787 break;
788 case CPP_COLON:
789 if (top->op != CPP_QUERY)
790 SYNTAX_ERROR (" ':' without preceding '?'");
791 if (!num_zerop (top[-1].value)) /* Was '?' condition true? */
792 pfile->state.skip_eval++;
793 else
794 pfile->state.skip_eval--;
795 default:
796 break;
799 want_value = true;
801 /* Check for and handle stack overflow. */
802 if (++top == pfile->op_limit)
803 top = _cpp_expand_op_stack (pfile);
805 top->op = op.op;
806 top->token = op.token;
809 /* The controlling macro expression is only valid if we called lex 3
810 times: <!> <defined expression> and <EOF>. push_conditional ()
811 checks that we are at top-of-file. */
812 if (pfile->mi_ind_cmacro && !(saw_leading_not && lex_count == 3))
813 pfile->mi_ind_cmacro = 0;
815 if (top != pfile->op_stack)
817 cpp_error (pfile, CPP_DL_ICE, "unbalanced stack in #if");
818 syntax_error:
819 return false; /* Return false on syntax error. */
822 return !num_zerop (top->value);
825 /* Reduce the operator / value stack if possible, in preparation for
826 pushing operator OP. Returns NULL on error, otherwise the top of
827 the stack. */
828 static struct op *
829 reduce (cpp_reader *pfile, struct op *top, enum cpp_ttype op)
831 unsigned int prio;
833 if (top->op <= CPP_EQ || top->op > CPP_LAST_CPP_OP + 2)
835 bad_op:
836 cpp_error (pfile, CPP_DL_ICE, "impossible operator '%u'", top->op);
837 return 0;
840 if (op == CPP_OPEN_PAREN)
841 return top;
843 /* Decrement the priority of left-associative operators to force a
844 reduction with operators of otherwise equal priority. */
845 prio = optab[op].prio - ((optab[op].flags & LEFT_ASSOC) != 0);
846 while (prio < optab[top->op].prio)
848 if (CPP_OPTION (pfile, warn_num_sign_change)
849 && optab[top->op].flags & CHECK_PROMOTION)
850 check_promotion (pfile, top);
852 switch (top->op)
854 case CPP_UPLUS:
855 case CPP_UMINUS:
856 case CPP_NOT:
857 case CPP_COMPL:
858 top[-1].value = num_unary_op (pfile, top->value, top->op);
859 break;
861 case CPP_PLUS:
862 case CPP_MINUS:
863 case CPP_RSHIFT:
864 case CPP_LSHIFT:
865 case CPP_MIN:
866 case CPP_MAX:
867 case CPP_COMMA:
868 top[-1].value = num_binary_op (pfile, top[-1].value,
869 top->value, top->op);
870 break;
872 case CPP_GREATER:
873 case CPP_LESS:
874 case CPP_GREATER_EQ:
875 case CPP_LESS_EQ:
876 top[-1].value
877 = num_inequality_op (pfile, top[-1].value, top->value, top->op);
878 break;
880 case CPP_EQ_EQ:
881 case CPP_NOT_EQ:
882 top[-1].value
883 = num_equality_op (pfile, top[-1].value, top->value, top->op);
884 break;
886 case CPP_AND:
887 case CPP_OR:
888 case CPP_XOR:
889 top[-1].value
890 = num_bitwise_op (pfile, top[-1].value, top->value, top->op);
891 break;
893 case CPP_MULT:
894 top[-1].value = num_mul (pfile, top[-1].value, top->value);
895 break;
897 case CPP_DIV:
898 case CPP_MOD:
899 top[-1].value = num_div_op (pfile, top[-1].value,
900 top->value, top->op);
901 break;
903 case CPP_OR_OR:
904 top--;
905 if (!num_zerop (top->value))
906 pfile->state.skip_eval--;
907 top->value.low = (!num_zerop (top->value)
908 || !num_zerop (top[1].value));
909 top->value.high = 0;
910 top->value.unsignedp = false;
911 top->value.overflow = false;
912 continue;
914 case CPP_AND_AND:
915 top--;
916 if (num_zerop (top->value))
917 pfile->state.skip_eval--;
918 top->value.low = (!num_zerop (top->value)
919 && !num_zerop (top[1].value));
920 top->value.high = 0;
921 top->value.unsignedp = false;
922 top->value.overflow = false;
923 continue;
925 case CPP_OPEN_PAREN:
926 if (op != CPP_CLOSE_PAREN)
928 cpp_error (pfile, CPP_DL_ERROR, "missing ')' in expression");
929 return 0;
931 top--;
932 top->value = top[1].value;
933 return top;
935 case CPP_COLON:
936 top -= 2;
937 if (!num_zerop (top->value))
939 pfile->state.skip_eval--;
940 top->value = top[1].value;
942 else
943 top->value = top[2].value;
944 top->value.unsignedp = (top[1].value.unsignedp
945 || top[2].value.unsignedp);
946 continue;
948 case CPP_QUERY:
949 cpp_error (pfile, CPP_DL_ERROR, "'?' without following ':'");
950 return 0;
952 default:
953 goto bad_op;
956 top--;
957 if (top->value.overflow && !pfile->state.skip_eval)
958 cpp_error (pfile, CPP_DL_PEDWARN,
959 "integer overflow in preprocessor expression");
962 if (op == CPP_CLOSE_PAREN)
964 cpp_error (pfile, CPP_DL_ERROR, "missing '(' in expression");
965 return 0;
968 return top;
971 /* Returns the position of the old top of stack after expansion. */
972 struct op *
973 _cpp_expand_op_stack (cpp_reader *pfile)
975 size_t old_size = (size_t) (pfile->op_limit - pfile->op_stack);
976 size_t new_size = old_size * 2 + 20;
978 pfile->op_stack = xrealloc (pfile->op_stack, new_size * sizeof (struct op));
979 pfile->op_limit = pfile->op_stack + new_size;
981 return pfile->op_stack + old_size;
984 /* Emits a warning if the effective sign of either operand of OP
985 changes because of integer promotions. */
986 static void
987 check_promotion (cpp_reader *pfile, const struct op *op)
989 if (op->value.unsignedp == op[-1].value.unsignedp)
990 return;
992 if (op->value.unsignedp)
994 if (!num_positive (op[-1].value, CPP_OPTION (pfile, precision)))
995 cpp_error (pfile, CPP_DL_WARNING,
996 "the left operand of \"%s\" changes sign when promoted",
997 cpp_token_as_text (pfile, op->token));
999 else if (!num_positive (op->value, CPP_OPTION (pfile, precision)))
1000 cpp_error (pfile, CPP_DL_WARNING,
1001 "the right operand of \"%s\" changes sign when promoted",
1002 cpp_token_as_text (pfile, op->token));
1005 /* Clears the unused high order bits of the number pointed to by PNUM. */
1006 static cpp_num
1007 num_trim (cpp_num num, size_t precision)
1009 if (precision > PART_PRECISION)
1011 precision -= PART_PRECISION;
1012 if (precision < PART_PRECISION)
1013 num.high &= ((cpp_num_part) 1 << precision) - 1;
1015 else
1017 if (precision < PART_PRECISION)
1018 num.low &= ((cpp_num_part) 1 << precision) - 1;
1019 num.high = 0;
1022 return num;
1025 /* True iff A (presumed signed) >= 0. */
1026 static bool
1027 num_positive (cpp_num num, size_t precision)
1029 if (precision > PART_PRECISION)
1031 precision -= PART_PRECISION;
1032 return (num.high & (cpp_num_part) 1 << (precision - 1)) == 0;
1035 return (num.low & (cpp_num_part) 1 << (precision - 1)) == 0;
1038 /* Sign extend a number, with PRECISION significant bits and all
1039 others assumed clear, to fill out a cpp_num structure. */
1040 cpp_num
1041 cpp_num_sign_extend (cpp_num num, size_t precision)
1043 if (!num.unsignedp)
1045 if (precision > PART_PRECISION)
1047 precision -= PART_PRECISION;
1048 if (precision < PART_PRECISION
1049 && (num.high & (cpp_num_part) 1 << (precision - 1)))
1050 num.high |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1052 else if (num.low & (cpp_num_part) 1 << (precision - 1))
1054 if (precision < PART_PRECISION)
1055 num.low |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1056 num.high = ~(cpp_num_part) 0;
1060 return num;
1063 /* Returns the negative of NUM. */
1064 static cpp_num
1065 num_negate (cpp_num num, size_t precision)
1067 cpp_num copy;
1069 copy = num;
1070 num.high = ~num.high;
1071 num.low = ~num.low;
1072 if (++num.low == 0)
1073 num.high++;
1074 num = num_trim (num, precision);
1075 num.overflow = (!num.unsignedp && num_eq (num, copy) && !num_zerop (num));
1077 return num;
1080 /* Returns true if A >= B. */
1081 static bool
1082 num_greater_eq (cpp_num pa, cpp_num pb, size_t precision)
1084 bool unsignedp;
1086 unsignedp = pa.unsignedp || pb.unsignedp;
1088 if (!unsignedp)
1090 /* Both numbers have signed type. If they are of different
1091 sign, the answer is the sign of A. */
1092 unsignedp = num_positive (pa, precision);
1094 if (unsignedp != num_positive (pb, precision))
1095 return unsignedp;
1097 /* Otherwise we can do an unsigned comparison. */
1100 return (pa.high > pb.high) || (pa.high == pb.high && pa.low >= pb.low);
1103 /* Returns LHS OP RHS, where OP is a bit-wise operation. */
1104 static cpp_num
1105 num_bitwise_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1106 cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1108 lhs.overflow = false;
1109 lhs.unsignedp = lhs.unsignedp || rhs.unsignedp;
1111 /* As excess precision is zeroed, there is no need to num_trim () as
1112 these operations cannot introduce a set bit there. */
1113 if (op == CPP_AND)
1115 lhs.low &= rhs.low;
1116 lhs.high &= rhs.high;
1118 else if (op == CPP_OR)
1120 lhs.low |= rhs.low;
1121 lhs.high |= rhs.high;
1123 else
1125 lhs.low ^= rhs.low;
1126 lhs.high ^= rhs.high;
1129 return lhs;
1132 /* Returns LHS OP RHS, where OP is an inequality. */
1133 static cpp_num
1134 num_inequality_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs,
1135 enum cpp_ttype op)
1137 bool gte = num_greater_eq (lhs, rhs, CPP_OPTION (pfile, precision));
1139 if (op == CPP_GREATER_EQ)
1140 lhs.low = gte;
1141 else if (op == CPP_LESS)
1142 lhs.low = !gte;
1143 else if (op == CPP_GREATER)
1144 lhs.low = gte && !num_eq (lhs, rhs);
1145 else /* CPP_LESS_EQ. */
1146 lhs.low = !gte || num_eq (lhs, rhs);
1148 lhs.high = 0;
1149 lhs.overflow = false;
1150 lhs.unsignedp = false;
1151 return lhs;
1154 /* Returns LHS OP RHS, where OP is == or !=. */
1155 static cpp_num
1156 num_equality_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1157 cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1159 /* Work around a 3.0.4 bug; see PR 6950. */
1160 bool eq = num_eq (lhs, rhs);
1161 if (op == CPP_NOT_EQ)
1162 eq = !eq;
1163 lhs.low = eq;
1164 lhs.high = 0;
1165 lhs.overflow = false;
1166 lhs.unsignedp = false;
1167 return lhs;
1170 /* Shift NUM, of width PRECISION, right by N bits. */
1171 static cpp_num
1172 num_rshift (cpp_num num, size_t precision, size_t n)
1174 cpp_num_part sign_mask;
1175 bool x = num_positive (num, precision);
1177 if (num.unsignedp || x)
1178 sign_mask = 0;
1179 else
1180 sign_mask = ~(cpp_num_part) 0;
1182 if (n >= precision)
1183 num.high = num.low = sign_mask;
1184 else
1186 /* Sign-extend. */
1187 if (precision < PART_PRECISION)
1188 num.high = sign_mask, num.low |= sign_mask << precision;
1189 else if (precision < 2 * PART_PRECISION)
1190 num.high |= sign_mask << (precision - PART_PRECISION);
1192 if (n >= PART_PRECISION)
1194 n -= PART_PRECISION;
1195 num.low = num.high;
1196 num.high = sign_mask;
1199 if (n)
1201 num.low = (num.low >> n) | (num.high << (PART_PRECISION - n));
1202 num.high = (num.high >> n) | (sign_mask << (PART_PRECISION - n));
1206 num = num_trim (num, precision);
1207 num.overflow = false;
1208 return num;
1211 /* Shift NUM, of width PRECISION, left by N bits. */
1212 static cpp_num
1213 num_lshift (cpp_num num, size_t precision, size_t n)
1215 if (n >= precision)
1217 num.overflow = !num.unsignedp && !num_zerop (num);
1218 num.high = num.low = 0;
1220 else
1222 cpp_num orig, maybe_orig;
1223 size_t m = n;
1225 orig = num;
1226 if (m >= PART_PRECISION)
1228 m -= PART_PRECISION;
1229 num.high = num.low;
1230 num.low = 0;
1232 if (m)
1234 num.high = (num.high << m) | (num.low >> (PART_PRECISION - m));
1235 num.low <<= m;
1237 num = num_trim (num, precision);
1239 if (num.unsignedp)
1240 num.overflow = false;
1241 else
1243 maybe_orig = num_rshift (num, precision, n);
1244 num.overflow = !num_eq (orig, maybe_orig);
1248 return num;
1251 /* The four unary operators: +, -, ! and ~. */
1252 static cpp_num
1253 num_unary_op (cpp_reader *pfile, cpp_num num, enum cpp_ttype op)
1255 switch (op)
1257 case CPP_UPLUS:
1258 if (CPP_WTRADITIONAL (pfile) && !pfile->state.skip_eval)
1259 cpp_error (pfile, CPP_DL_WARNING,
1260 "traditional C rejects the unary plus operator");
1261 num.overflow = false;
1262 break;
1264 case CPP_UMINUS:
1265 num = num_negate (num, CPP_OPTION (pfile, precision));
1266 break;
1268 case CPP_COMPL:
1269 num.high = ~num.high;
1270 num.low = ~num.low;
1271 num = num_trim (num, CPP_OPTION (pfile, precision));
1272 num.overflow = false;
1273 break;
1275 default: /* case CPP_NOT: */
1276 num.low = num_zerop (num);
1277 num.high = 0;
1278 num.overflow = false;
1279 num.unsignedp = false;
1280 break;
1283 return num;
1286 /* The various binary operators. */
1287 static cpp_num
1288 num_binary_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1290 cpp_num result;
1291 size_t precision = CPP_OPTION (pfile, precision);
1292 bool gte;
1293 size_t n;
1295 switch (op)
1297 /* Shifts. */
1298 case CPP_LSHIFT:
1299 case CPP_RSHIFT:
1300 if (!rhs.unsignedp && !num_positive (rhs, precision))
1302 /* A negative shift is a positive shift the other way. */
1303 if (op == CPP_LSHIFT)
1304 op = CPP_RSHIFT;
1305 else
1306 op = CPP_LSHIFT;
1307 rhs = num_negate (rhs, precision);
1309 if (rhs.high)
1310 n = ~0; /* Maximal. */
1311 else
1312 n = rhs.low;
1313 if (op == CPP_LSHIFT)
1314 lhs = num_lshift (lhs, precision, n);
1315 else
1316 lhs = num_rshift (lhs, precision, n);
1317 break;
1319 /* Min / Max. */
1320 case CPP_MIN:
1321 case CPP_MAX:
1323 bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1325 gte = num_greater_eq (lhs, rhs, precision);
1326 if (op == CPP_MIN)
1327 gte = !gte;
1328 if (!gte)
1329 lhs = rhs;
1330 lhs.unsignedp = unsignedp;
1332 break;
1334 /* Arithmetic. */
1335 case CPP_MINUS:
1336 rhs = num_negate (rhs, precision);
1337 case CPP_PLUS:
1338 result.low = lhs.low + rhs.low;
1339 result.high = lhs.high + rhs.high;
1340 if (result.low < lhs.low)
1341 result.high++;
1342 result.unsignedp = lhs.unsignedp || rhs.unsignedp;
1343 result.overflow = false;
1345 result = num_trim (result, precision);
1346 if (!result.unsignedp)
1348 bool lhsp = num_positive (lhs, precision);
1349 result.overflow = (lhsp == num_positive (rhs, precision)
1350 && lhsp != num_positive (result, precision));
1352 return result;
1354 /* Comma. */
1355 default: /* case CPP_COMMA: */
1356 if (CPP_PEDANTIC (pfile) && (!CPP_OPTION (pfile, c99)
1357 || !pfile->state.skip_eval))
1358 cpp_error (pfile, CPP_DL_PEDWARN,
1359 "comma operator in operand of #if");
1360 lhs = rhs;
1361 break;
1364 return lhs;
1367 /* Multiplies two unsigned cpp_num_parts to give a cpp_num. This
1368 cannot overflow. */
1369 static cpp_num
1370 num_part_mul (cpp_num_part lhs, cpp_num_part rhs)
1372 cpp_num result;
1373 cpp_num_part middle[2], temp;
1375 result.low = LOW_PART (lhs) * LOW_PART (rhs);
1376 result.high = HIGH_PART (lhs) * HIGH_PART (rhs);
1378 middle[0] = LOW_PART (lhs) * HIGH_PART (rhs);
1379 middle[1] = HIGH_PART (lhs) * LOW_PART (rhs);
1381 temp = result.low;
1382 result.low += LOW_PART (middle[0]) << (PART_PRECISION / 2);
1383 if (result.low < temp)
1384 result.high++;
1386 temp = result.low;
1387 result.low += LOW_PART (middle[1]) << (PART_PRECISION / 2);
1388 if (result.low < temp)
1389 result.high++;
1391 result.high += HIGH_PART (middle[0]);
1392 result.high += HIGH_PART (middle[1]);
1393 result.unsignedp = true;
1394 result.overflow = false;
1396 return result;
1399 /* Multiply two preprocessing numbers. */
1400 static cpp_num
1401 num_mul (cpp_reader *pfile, cpp_num lhs, cpp_num rhs)
1403 cpp_num result, temp;
1404 bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1405 bool overflow, negate = false;
1406 size_t precision = CPP_OPTION (pfile, precision);
1408 /* Prepare for unsigned multiplication. */
1409 if (!unsignedp)
1411 if (!num_positive (lhs, precision))
1412 negate = !negate, lhs = num_negate (lhs, precision);
1413 if (!num_positive (rhs, precision))
1414 negate = !negate, rhs = num_negate (rhs, precision);
1417 overflow = lhs.high && rhs.high;
1418 result = num_part_mul (lhs.low, rhs.low);
1420 temp = num_part_mul (lhs.high, rhs.low);
1421 result.high += temp.low;
1422 if (temp.high)
1423 overflow = true;
1425 temp = num_part_mul (lhs.low, rhs.high);
1426 result.high += temp.low;
1427 if (temp.high)
1428 overflow = true;
1430 temp.low = result.low, temp.high = result.high;
1431 result = num_trim (result, precision);
1432 if (!num_eq (result, temp))
1433 overflow = true;
1435 if (negate)
1436 result = num_negate (result, precision);
1438 if (unsignedp)
1439 result.overflow = false;
1440 else
1441 result.overflow = overflow || (num_positive (result, precision) ^ !negate
1442 && !num_zerop (result));
1443 result.unsignedp = unsignedp;
1445 return result;
1448 /* Divide two preprocessing numbers, returning the answer or the
1449 remainder depending upon OP. */
1450 static cpp_num
1451 num_div_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1453 cpp_num result, sub;
1454 cpp_num_part mask;
1455 bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1456 bool negate = false, lhs_neg = false;
1457 size_t i, precision = CPP_OPTION (pfile, precision);
1459 /* Prepare for unsigned division. */
1460 if (!unsignedp)
1462 if (!num_positive (lhs, precision))
1463 negate = !negate, lhs_neg = true, lhs = num_negate (lhs, precision);
1464 if (!num_positive (rhs, precision))
1465 negate = !negate, rhs = num_negate (rhs, precision);
1468 /* Find the high bit. */
1469 if (rhs.high)
1471 i = precision - 1;
1472 mask = (cpp_num_part) 1 << (i - PART_PRECISION);
1473 for (; ; i--, mask >>= 1)
1474 if (rhs.high & mask)
1475 break;
1477 else if (rhs.low)
1479 if (precision > PART_PRECISION)
1480 i = precision - PART_PRECISION - 1;
1481 else
1482 i = precision - 1;
1483 mask = (cpp_num_part) 1 << i;
1484 for (; ; i--, mask >>= 1)
1485 if (rhs.low & mask)
1486 break;
1488 else
1490 if (!pfile->state.skip_eval)
1491 cpp_error (pfile, CPP_DL_ERROR, "division by zero in #if");
1492 return lhs;
1495 /* First nonzero bit of RHS is bit I. Do naive division by
1496 shifting the RHS fully left, and subtracting from LHS if LHS is
1497 at least as big, and then repeating but with one less shift.
1498 This is not very efficient, but is easy to understand. */
1500 rhs.unsignedp = true;
1501 lhs.unsignedp = true;
1502 i = precision - i - 1;
1503 sub = num_lshift (rhs, precision, i);
1505 result.high = result.low = 0;
1506 for (;;)
1508 if (num_greater_eq (lhs, sub, precision))
1510 lhs = num_binary_op (pfile, lhs, sub, CPP_MINUS);
1511 if (i >= PART_PRECISION)
1512 result.high |= (cpp_num_part) 1 << (i - PART_PRECISION);
1513 else
1514 result.low |= (cpp_num_part) 1 << i;
1516 if (i-- == 0)
1517 break;
1518 sub.low = (sub.low >> 1) | (sub.high << (PART_PRECISION - 1));
1519 sub.high >>= 1;
1522 /* We divide so that the remainder has the sign of the LHS. */
1523 if (op == CPP_DIV)
1525 result.unsignedp = unsignedp;
1526 result.overflow = false;
1527 if (!unsignedp)
1529 if (negate)
1530 result = num_negate (result, precision);
1531 result.overflow = num_positive (result, precision) ^ !negate;
1534 return result;
1537 /* CPP_MOD. */
1538 lhs.unsignedp = unsignedp;
1539 lhs.overflow = false;
1540 if (lhs_neg)
1541 lhs = num_negate (lhs, precision);
1543 return lhs;