2 ** Splint - annotation-assisted static program checker
3 ** Copyright (C) 1994-2002 University of Virginia,
4 ** Massachusetts Institute of Technology
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 of the License, or (at your
9 ** option) any later version.
11 ** This program is distributed in the hope that it will be useful, but
12 ** WITHOUT ANY WARRANTY; without even the implied warranty of
13 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 ** General Public License for more details.
16 ** The GNU General Public License is available from http://www.gnu.org/ or
17 ** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
18 ** MA 02111-1307, USA.
20 ** For information on splint: info@splint.org
21 ** To report a bug: splint-bug@splint.org
22 ** For more information: http://www.splint.org
27 /* Parse C expressions for CCCP.
28 Copyright (C) 1987, 1992, 1994, 1995, 1997 Free Software Foundation.
30 This program is free software; you can redistribute it and/or modify it
31 under the terms of the GNU General Public License as published by the
32 Free Software Foundation; either version 2, or (at your option) any
35 This program is distributed in the hope that it will be useful,
36 but WITHOUT ANY WARRANTY; without even the implied warranty of
37 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
38 GNU General Public License for more details.
40 You should have received a copy of the GNU General Public License
41 along with this program; if not, write to the Free Software
42 Foundation, 59 Temple Place - Suite 330,
43 Boston, MA 02111-1307, USA.
45 In other words, you are welcome to use, share and improve this program.
46 You are forbidden to forbid anyone else to use, share and improve
47 what you give them. Help stamp out software-hoarding!
49 Written by Per Bothner 1994. */
51 /* Parse a C expression from text in a string */
56 /*@+matchanyintegral@*/
59 # include "splintMacros.nf"
64 # include "cpperror.h"
66 /* Yield nonzero if adding two numbers with A's and B's signs can yield a
67 number with SUM's sign, where A, B, and SUM are all C integers. */
69 /*@function static bool possibleSumSign (sef int, int, int)
70 modifies nothing ; @*/
72 #define possibleSumSign(a, b, sum) ((((a) ^ (b)) | ~ ((a) ^ (sum))) < 0)
74 /* these are guesses! */
76 /*@constant int BITS_PER_UNIT = 8@*/
77 # define BITS_PER_UNIT 8
79 /*@constant size_t BITS_PER_CHAR@*/
80 # define BITS_PER_CHAR 8
82 /*@constant size_t BITS_PER_WORD@*/
83 # define BITS_PER_WORD 32
85 /*@constant size_t HOST_BITS_PER_INT@*/
86 # define HOST_BITS_PER_INT 32
88 /*@constant size_t HOST_BITS_PER_LONG = 32@*/
89 # define HOST_BITS_PER_LONG 32
91 /*@constant char TARGET_BELL@*/
92 # define TARGET_BELL (char) 6
94 /*@constant char TARGET_BS@*/
95 # define TARGET_BS (char) 7
97 /*@constant char TARGET_FF@*/
98 # define TARGET_FF (char) 8
100 /*@constant char TARGET_NEWLINE@*/
101 # define TARGET_NEWLINE '\n'
103 /*@constant char TARGET_CR@*/
104 # define TARGET_CR '\n'
106 /*@constant char TARGET_TAB@*/
107 # define TARGET_TAB '\t'
109 /*@constant char TARGET_VT@*/
110 # define TARGET_VT '\v'
112 #ifdef MULTIBYTE_CHARS
119 #ifndef INT_TYPE_SIZE
120 /*@constant size_t INT_TYPE_SIZE@*/
121 #define INT_TYPE_SIZE BITS_PER_WORD
124 #ifndef LONG_TYPE_SIZE
125 /*@constant size_t LONG_TYPE_SIZE@*/
126 #define LONG_TYPE_SIZE BITS_PER_WORD
129 #ifndef WCHAR_TYPE_SIZE
130 /*@constant size_t WCHAR_TYPE_SIZE@*/
131 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
134 # ifndef CHAR_TYPE_SIZE
135 /*@constant size_t CHAR_TYPE_SIZE@*/
136 # define CHAR_TYPE_SIZE BITS_PER_CHAR
139 #ifndef MAX_CHAR_TYPE_SIZE
140 /*@constant size_t MAX_CHAR_TYPE_SIZE@*/
141 #define MAX_CHAR_TYPE_SIZE CHAR_TYPE_SIZE
144 #ifndef MAX_LONG_TYPE_SIZE
145 /*@constant size_t MAX_LONG_TYPE_SIZE@*/
146 #define MAX_LONG_TYPE_SIZE LONG_TYPE_SIZE
149 #ifndef MAX_WCHAR_TYPE_SIZE
150 /*@constant size_t MAX_WCHAR_TYPE_SIZE@*/
151 #define MAX_WCHAR_TYPE_SIZE WCHAR_TYPE_SIZE
154 static struct operation cppexp_lex (cppReader *);
155 static void integer_overflow (cppReader *);
156 static long left_shift (cppReader *, long, bool p_unsignedp, size_t);
157 static long right_shift (long, bool p_unsignedp, unsigned long);
159 /*@constant short CPPREADER_ERRORTOK@*/
160 #define CPPREADER_ERRORTOK 299
162 /*@constant int OROR@*/
165 /*@constant int ANDAND@*/
168 /*@constant int CPP_EQUALTOK@*/
169 #define CPP_EQUALTOK 302
171 /*@constant int NOTEQUAL@*/
174 /*@constant int LEQ@*/
177 /*@constant int GEQ@*/
180 /*@constant int LSH@*/
183 /*@constant int RSH@*/
186 /*@constant int NAME@*/
189 /*@constant short CPPEXP_INT@*/
190 #define CPPEXP_INT 309
192 /*@constant short CPPEXP_CHAR@*/
193 #define CPPEXP_CHAR 310
195 /*@constant int LEFT_OPERAND_REQUIRED@*/
196 #define LEFT_OPERAND_REQUIRED 1
198 /*@constant int RIGHT_OPERAND_REQUIRED@*/
199 #define RIGHT_OPERAND_REQUIRED 2
201 /*@constant int HAVE_VALUE@*/
204 #ifndef HOST_BITS_PER_WIDE_INT
206 #if HOST_BITS_PER_LONG > HOST_BITS_PER_INT
207 /*@constant int HOST_BITS_PER_WIDE_INT@*/
208 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
210 #define HOST_WIDE_INT long
212 /*@constant int HOST_BITS_PER_WIDE_INT@*/
213 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT
215 #define HOST_WIDE_INT long
223 /* Priority of op (relative to it right operand). */
224 /*@reldef@*/ char rprio;
226 /*@reldef@*/ char flags;
228 /* true if value should be treated as unsigned */
229 /*@reldef@*/ bool unsignedp;
231 /* The value logically "right" of op. */
232 /*@reldef@*/ HOST_WIDE_INT value;
235 /* Take care of parsing a number (anything that starts with a digit).
236 LEN is the number of characters in it. */
238 /* maybe needs to actually deal with floating point numbers */
241 cppReader_parseNumber (cppReader *pfile, char *start, int olen) /*@requires maxRead(start) >= (olen - 1) @*/
248 unsigned long nd, ULONG_MAX_over_base;
251 bool overflow = FALSE;
252 int digit, largest_digit = 0;
253 bool spec_long = FALSE;
255 op.unsignedp = FALSE;
257 for (i = 0; i < len; i++)
259 /*drl bee: is*/ if (p[i] == '.') {
260 /* It's a float since it contains a point. */
263 cstring_makeLiteralTemp
264 ("Floating point numbers not allowed in #if expressions"));
265 op.op = CPPREADER_ERRORTOK;
270 if (len >= 3 && (mstring_equalPrefix (p, "0x")
271 || mstring_equalPrefix (p, "0X")))
280 /* drl: see if there is a reason that we shouldn't do
291 /* Some buggy compilers (e.g. MPW C) seem to need both casts. */
292 ULONG_MAX_over_base = ((unsigned long) -1) / ((unsigned long) base);
294 for (; len > 0; len--) {
297 if (c >= '0' && c <= '9')
299 digit = (int) (c - '0');
301 else if (base == 16 && c >= 'a' && c <= 'f')
303 digit = (int) (c - 'a') + 10;
305 else if (base == 16 && c >= 'A' && c <= 'F')
307 digit = (int) (c - 'A') + 10;
311 /* `l' means long, and `u' means unsigned. */
314 if (c == 'l' || c == 'L')
317 cppReader_errorLit (pfile,
318 cstring_makeLiteralTemp ("two `l's in integer constant"));
321 else if (c == 'u' || c == 'U')
324 cppReader_errorLit (pfile,
325 cstring_makeLiteralTemp ("two `u's in integer constant"));
330 /*@innerbreak@*/ break;
335 /*@innerbreak@*/ break;
338 /*drl bee: ltc*/ c = *p++;
340 /* Don't look for any more digits after the suffixes. */
344 if (largest_digit < digit)
346 largest_digit = digit;
349 nd = (long unsigned) (n * base + digit);
350 overflow |= (ULONG_MAX_over_base < (unsigned long) n)
351 | (nd < (unsigned long) n);
359 cstring_makeLiteralTemp ("Invalid number in #if expression"));
360 op.op = CPPREADER_ERRORTOK;
364 if (base <= largest_digit)
368 cstring_makeLiteralTemp
369 ("Integer constant contains digits beyond the radix"));
374 /*@i23 add flags for all these...*/
377 cstring_makeLiteralTemp ("Integer constant out of range"));
380 /* If too big to be signed, consider it unsigned. */
381 if ((long) n < 0 && ! op.unsignedp)
387 cstring_makeLiteralTemp ("Integer constant is so large that it is unsigned"));
395 DPRINTF (("Parse number: %d", op.value));
400 /*@null@*/ /*@observer@*/ char *operator;
404 static struct token tokentab2[] = {
409 { "==", CPP_EQUALTOK },
413 { "++", CPPREADER_ERRORTOK },
414 { "--", CPPREADER_ERRORTOK },
415 { NULL, CPPREADER_ERRORTOK }
418 /* Read one token. */
420 struct operation cppexp_lex (cppReader *pfile)
424 register struct token *toktab;
425 enum cpp_token token;
427 char *tok_start, *tok_end;
432 old_written = size_toInt (cpplib_getWritten (pfile));
433 cppSkipHspace (pfile);
434 ic = cpplib_bufPeek (cppReader_getBufferSafe (pfile));
440 /* was: llassert (c != '#'); - Solaris uses this, attempt to continue anyway... */
441 cppReader_pedwarn (pfile,
442 message ("non-standard pre-processor directive: %c", c));
445 DPRINTF (("Read: %c", c));
453 token = cpplib_getTokenForceExpand (pfile);
455 tok_start = pfile->token_buffer + old_written;
456 tok_end = cpplib_getPWritten (pfile);
458 DPRINTF (("Token: %s < %s", tok_start, tok_end));
460 pfile->limit = tok_start;
464 case CPP_EOF: /* Should not happen ... */
469 if (cstring_isDefined (cppReader_getBufferSafe (pfile)->fname))
474 (void) cppReader_popBuffer (pfile);
476 case CPP_HSPACE: case CPP_COMMENT:
479 return cppReader_parseNumber (pfile, tok_start, tok_end - tok_start);
481 cppReader_errorLit (pfile,
482 cstring_makeLiteralTemp ("string constants not allowed in #if expressions"));
483 op.op = CPPREADER_ERRORTOK;
486 /* This code for reading a character constant
487 handles multicharacter constants and wide characters.
488 It is mostly copied from c-lex.c. */
492 size_t width = MAX_CHAR_TYPE_SIZE;
495 char *ptr = tok_start;
496 #ifdef MULTIBYTE_CHARS
497 char token_buffer[MAX_LONG_TYPE_SIZE/MAX_CHAR_TYPE_SIZE + MB_CUR_MAX];
499 char token_buffer[MAX_LONG_TYPE_SIZE/MAX_CHAR_TYPE_SIZE + 1];
506 width = MAX_WCHAR_TYPE_SIZE;
507 #ifdef MULTIBYTE_CHARS
508 max_chars = MB_CUR_MAX;
515 max_chars = size_toInt (MAX_LONG_TYPE_SIZE / width);
519 /*drl bee: hda*/ while (ptr < tok_end && ((c = *ptr++) != '\''))
523 c = cppReader_parseEscape (pfile, &ptr);
524 if (width < HOST_BITS_PER_INT && c >= (1 << width))
528 cstring_makeLiteralTemp ("Escape sequence out of range for character"));
534 /* Merge character into result; ignore excess chars. */
535 if (num_chars < max_chars + 1)
537 if (width < HOST_BITS_PER_INT)
539 result = (int) ((unsigned) result << width) | (c & ((1 << width) - 1));
546 token_buffer[num_chars - 1] = c;
550 /*drl bee: dad*/ token_buffer[num_chars] = 0;
553 cppReader_errorLit (pfile,
554 cstring_makeLiteralTemp ("malformatted character constant"));
555 else if (num_chars == 0)
556 cppReader_errorLit (pfile,
557 cstring_makeLiteralTemp ("empty character constant"));
558 else if (num_chars > max_chars)
560 num_chars = max_chars;
561 cppReader_errorLit (pfile,
562 cstring_makeLiteralTemp ("character constant too long"));
564 else if (num_chars != 1 && ! cppReader_isTraditional (pfile))
566 cppReader_warningLit (pfile,
567 cstring_makeLiteralTemp ("multi-character character constant"));
574 /* If char type is signed, sign-extend the constant. */
577 int num_bits = num_chars * width;
579 if ((cpphash_lookup ("__CHAR_UNSIGNED__",
580 sizeof ("__CHAR_UNSIGNED__") - 1, -1) != NULL)
581 || (((unsigned) result >> (int_toNonNegative (num_bits - 1))) & 1) == 0)
584 = result & ((unsigned long) ~0
585 >> int_toNonNegative ((HOST_BITS_PER_LONG - num_bits)));
590 = result | ~((unsigned long) ~0
591 >> int_toNonNegative ((HOST_BITS_PER_LONG - num_bits)));
596 #ifdef MULTIBYTE_CHARS
597 /* Set the initial shift state and convert the next sequence. */
599 /* In all locales L'\0' is zero and mbtowc will return zero,
602 || (num_chars == 1 && token_buffer[0] != '\0'))
605 (void) mbtowc (NULL, NULL, 0);
606 if (mbtowc (& wc, token_buffer, num_chars) == num_chars)
609 cppReader_pedwarn (pfile,"Ignoring invalid multibyte character");
616 /* This is always a signed type. */
617 op.unsignedp = FALSE;
624 return cppReader_parseNumber (pfile, "0", 0);
627 /* See if it is a special token of length 2. */
628 if (tok_start + 2 == tok_end)
630 for (toktab = tokentab2; toktab->operator != NULL; toktab++)
632 /*drl bee: hda*/ if (tok_start[0] == /*drl bee: hda*/ toktab->operator[0]
633 && /*drl bee: hda*/ tok_start[1] == /*drl bee: hda*/ toktab->operator[1])
635 /*@loopbreak@*/ break;
639 if (toktab->token == CPPREADER_ERRORTOK)
641 cppReader_error (pfile,
642 message ("`%s' not allowed in operand of `#if'",
643 cstring_fromChars (tok_start)));
646 op.op = toktab->token;
660 /* Parse a C escape sequence. STRING_PTR points to a variable
661 containing a pointer to the string to parse. That pointer
662 is updated past the characters we use. The value of the
663 escape sequence is returned.
665 A negative value means the sequence \ newline was seen,
666 which is supposed to be equivalent to nothing at all.
668 If \ is followed by a null character, we return a negative
669 value and leave the string pointer pointing at the null character.
671 If \ is followed by 000, we return 0 and leave the string pointer
672 after the zeros. A value of 0 does not mean end of string. */
675 cppReader_parseEscape (cppReader *pfile, char **string_ptr)
677 /*drl bee: pbr*/ char c = *(*string_ptr)++;
687 if (cppReader_isPedantic (pfile))
689 cppReader_pedwarn (pfile,
690 message ("non-standard escape sequence, `\\%c'", c));
696 return TARGET_NEWLINE;
718 int i = (int) c - '0';
723 c = *(*string_ptr)++;
724 if (c >= '0' && c <= '7')
726 i = ((unsigned) i << 3) + c - '0';
731 /*drl bee: pbr*/ (*string_ptr)--;
732 /*@loopbreak@*/ break;
735 if ((i & ~((1 << MAX_CHAR_TYPE_SIZE) - 1)) != 0)
737 i &= (1 << MAX_CHAR_TYPE_SIZE) - 1;
738 cppReader_pedwarnLit (pfile,
739 cstring_makeLiteralTemp ("octal character constant does not fit in a byte"));
745 register unsigned i = 0, overflow = 0, digits_found = 0, digit;
748 c = *(*string_ptr)++;
750 if (c >= '0' && c <= '9')
752 digit = (unsigned int) (c - '0');
754 else if (c >= 'a' && c <= 'f')
756 digit = (unsigned int) (c - 'a') + 10;
758 else if (c >= 'A' && c <= 'F')
760 digit = (unsigned int) (c - 'A') + 10;
765 /*@loopbreak@*/ break;
767 overflow |= i ^ (i << 4 >> 4);
768 i = (i << 4) + digit;
772 if (digits_found == 0)
774 cppReader_errorLit (pfile,
775 cstring_makeLiteralTemp ("\\x used with no following hex digits"));
778 if ((overflow | (i & ~((1 << int_toNonNegative (BITS_PER_UNIT)) - 1))) != 0)
780 i &= (1 << BITS_PER_UNIT) - 1;
781 cppReader_pedwarnLit (pfile,
782 cstring_makeLiteralTemp ("hex character constant does not fit in a byte"));
793 integer_overflow (cppReader *pfile)
795 if (cppReader_isPedantic (pfile))
796 cppReader_pedwarnLit (pfile,
797 cstring_makeLiteralTemp ("integer overflow in preprocessor expression"));
801 left_shift (cppReader *pfile, long a, bool unsignedp, size_t b)
803 if (b >= HOST_BITS_PER_LONG)
805 if (!unsignedp && a != 0)
807 integer_overflow (pfile);
814 return (unsigned long) a << b;
818 long l = int_toNonNegative (a) << b;
821 # pragma warning( disable : 4018 )
824 if (int_toNonNegative (l) >> b != a)
826 integer_overflow (pfile);
834 right_shift (long a, bool unsignedp, unsigned long b)
836 if (b >= HOST_BITS_PER_LONG)
837 return (unsignedp ? 0 : int_toNonNegative (a) >> (HOST_BITS_PER_LONG - 1));
839 return (unsigned long) a >> b;
841 return int_toNonNegative (a) >> b;
844 /* These priorities are all even, so we can handle associatively. */
846 /*@constant int PAREN_INNER_PRIO@*/
847 #define PAREN_INNER_PRIO 0
849 /*@constant int COMMA_PRIO@*/
852 /*@constant int COND_PRIO@*/
853 #define COND_PRIO (COMMA_PRIO+2)
855 /*@constant int OROR_PRIO@*/
856 #define OROR_PRIO (COND_PRIO+2)
858 /*@constant int ANDAND_PRIO@*/
859 #define ANDAND_PRIO (OROR_PRIO+2)
861 /*@constant int OR_PRIO@*/
862 #define OR_PRIO (ANDAND_PRIO+2)
864 /*@constant int XOR_PRIO@*/
865 #define XOR_PRIO (OR_PRIO+2)
867 /*@constant int AND_PRIO@*/
868 #define AND_PRIO (XOR_PRIO+2)
870 /*@constant int CPP_EQUAL_PRIO@*/
871 #define CPP_EQUAL_PRIO (AND_PRIO+2)
873 /*@constant int LESS_PRIO@*/
874 #define LESS_PRIO (CPP_EQUAL_PRIO+2)
876 /*@constant int SHIFT_PRIO@*/
877 #define SHIFT_PRIO (LESS_PRIO+2)
879 /*@constant int PLUS_PRIO@*/
880 #define PLUS_PRIO (SHIFT_PRIO+2)
882 /*@constant int MUL_PRIO@*/
883 #define MUL_PRIO (PLUS_PRIO+2)
885 /*@constant int UNARY_PRIO@*/
886 #define UNARY_PRIO (MUL_PRIO+2)
888 /*@constant int PAREN_OUTER_PRIO@*/
889 #define PAREN_OUTER_PRIO (UNARY_PRIO+2)
892 #define COMPARE(OP) \
893 top->unsignedp = FALSE;\
894 top->value = ((unsigned1 || unsigned2) \
895 ? (unsigned long) v1 OP (unsigned long) v2 \
896 : ((long) v1 OP (long) v2)) ? 1 : 0
898 /* Parse and evaluate a C expression, reading from PFILE.
899 Returns the value of the expression. */
901 /*@constant int INIT_STACK_SIZE@*/
902 # define INIT_STACK_SIZE 20
905 cppReader_parseExpression (cppReader *pfile)
907 /* The implementation is an operator precedence parser,
908 i.e. a bottom-up parser, using a stack for not-yet-reduced tokens.
910 The stack base is 'stack', and the current stack pointer is 'top'.
911 There is a stack element for each operator (only),
912 and the most recently pushed operator is 'top->op'.
913 An operand (value) is stored in the 'value' field of the stack
914 element of the operator that precedes it.
915 In that case the 'flags' field has the HAVE_VALUE flag set. */
917 struct operation init_stack[INIT_STACK_SIZE];
918 struct operation *stack = init_stack;
919 struct operation *limit = stack + INIT_STACK_SIZE;
920 register struct operation *top = stack;
921 int lprio, rprio = 0;
922 int skip_evaluation = 0;
933 op = cppexp_lex (pfile);
935 /* See if the token is an operand, in which case go to set_value.
936 If the token is an operator, figure out its left and right
937 priorities, and then goto maybe_reduce. */
942 top->value = 0, top->unsignedp = FALSE;
946 top->value = op.value;
947 top->unsignedp = op.unsignedp;
950 lprio = 0; goto maybe_reduce;
952 /* Is this correct if unary ? FIXME */
953 flags = RIGHT_OPERAND_REQUIRED;
954 lprio = PLUS_PRIO; rprio = lprio + 1; goto maybe_reduce;
956 flags = RIGHT_OPERAND_REQUIRED;
957 rprio = UNARY_PRIO; lprio = rprio + 1; goto maybe_reduce;
958 case '*': case '/': case '%':
959 lprio = MUL_PRIO; goto binop;
960 case '<': case '>': case LEQ: case GEQ:
961 lprio = LESS_PRIO; goto binop;
962 case CPP_EQUALTOK: case NOTEQUAL:
963 lprio = CPP_EQUAL_PRIO; goto binop;
965 lprio = SHIFT_PRIO; goto binop;
966 case '&': lprio = AND_PRIO; goto binop;
967 case '^': lprio = XOR_PRIO; goto binop;
968 case '|': lprio = OR_PRIO; goto binop;
969 case ANDAND: lprio = ANDAND_PRIO; goto binop;
970 case OROR: lprio = OROR_PRIO; goto binop;
972 lprio = COMMA_PRIO; goto binop;
974 lprio = PAREN_OUTER_PRIO; rprio = PAREN_INNER_PRIO;
977 lprio = PAREN_INNER_PRIO; rprio = PAREN_OUTER_PRIO;
980 lprio = COND_PRIO; rprio = COND_PRIO;
983 lprio = COND_PRIO + 1; rprio = COND_PRIO;
986 flags = LEFT_OPERAND_REQUIRED | RIGHT_OPERAND_REQUIRED;
992 message ("Invalid character in #if: %c",
998 /* Push a value onto the stack. */
999 if ((top->flags & HAVE_VALUE) != 0)
1001 cppReader_errorLit (pfile,
1002 cstring_makeLiteralTemp ("syntax error in #if"));
1005 top->flags |= HAVE_VALUE;
1009 /* Push an operator, and check if we can reduce now. */
1010 while (top->rprio > lprio)
1013 long v1 = top[-1].value, v2 = top[0].value;
1014 bool unsigned1 = top[-1].unsignedp;
1015 bool unsigned2 = top[0].unsignedp;
1019 if (((top[1].flags & LEFT_OPERAND_REQUIRED) != 0)
1020 && ((top[0].flags & HAVE_VALUE) == 0))
1022 cppReader_errorLit (pfile,
1023 cstring_makeLiteralTemp ("syntax error - missing left operand"));
1026 if (((top[1].flags & RIGHT_OPERAND_REQUIRED) != 0)
1027 && ((top[1].flags & HAVE_VALUE) == 0))
1029 cppReader_errorLit (pfile,
1030 cstring_makeLiteralTemp ("syntax error - missing right operand"));
1033 /* top[0].value = (top[1].op)(v1, v2);*/
1037 if ((top->flags & HAVE_VALUE) == 0)
1040 top->unsignedp = unsigned2;
1041 top->flags |= HAVE_VALUE;
1045 top->value = v1 + v2;
1046 top->unsignedp = unsigned1 || unsigned2;
1047 if (!top->unsignedp && (skip_evaluation == 0)
1048 && ! possibleSumSign (v1, v2, top->value))
1049 integer_overflow (pfile);
1051 /*@switchbreak@*/ break;
1053 if ((top->flags & HAVE_VALUE) == 0)
1056 if ((skip_evaluation == 0)
1057 && (top->value & v2) < 0 && !unsigned2)
1058 integer_overflow (pfile);
1059 top->unsignedp = unsigned2;
1060 top->flags |= HAVE_VALUE;
1064 top->value = v1 - v2;
1065 top->unsignedp = unsigned1 || unsigned2;
1066 if (!top->unsignedp && (skip_evaluation == 0)
1067 && !possibleSumSign (top->value, v2, v1))
1069 integer_overflow (pfile);
1072 /*@switchbreak@*/ break;
1074 top->unsignedp = unsigned1 || unsigned2;
1078 top->value = (unsigned long) v1 * v2;
1080 else if (skip_evaluation == 0)
1082 top->value = v1 * v2;
1084 && (top->value / v1 != v2
1085 || (top->value & v1 & v2) < 0))
1087 integer_overflow (pfile);
1095 /*@switchbreak@*/ break;
1097 if (skip_evaluation != 0)
1098 /*@switchbreak@*/ break;
1101 cppReader_errorLit (pfile,
1102 cstring_makeLiteralTemp ("Division by zero in #if"));
1105 top->unsignedp = unsigned1 || unsigned2;
1107 top->value = (unsigned long) v1 / v2;
1110 top->value = v1 / v2;
1111 if ((top->value & v1 & v2) < 0)
1112 integer_overflow (pfile);
1114 /*@switchbreak@*/ break;
1116 if (skip_evaluation != 0)
1117 /*@switchbreak@*/ break;
1120 cppReader_errorLit (pfile,
1121 cstring_makeLiteralTemp ("Division by zero in #if"));
1124 top->unsignedp = unsigned1 || unsigned2;
1126 top->value = (unsigned long) v1 % v2;
1128 top->value = v1 % v2;
1129 /*@switchbreak@*/ break;
1131 if ((top->flags & HAVE_VALUE) != 0)
1133 cppReader_errorLit (pfile,
1134 cstring_makeLiteralTemp ("Syntax error"));
1138 top->value = (v2 == 0) ? 1 : 0;
1139 top->unsignedp = FALSE;
1140 top->flags |= HAVE_VALUE;
1141 /*@switchbreak@*/ break;
1143 if ((top->flags & HAVE_VALUE) != 0)
1145 cppReader_errorLit (pfile,
1146 cstring_makeLiteralTemp ("syntax error"));
1150 top->unsignedp = unsigned2;
1151 top->flags |= HAVE_VALUE;
1152 /*@switchbreak@*/ break;
1153 case '<': COMPARE(<); /*@switchbreak@*/ break;
1154 case '>': COMPARE(>); /*@switchbreak@*/ break;
1155 case LEQ: COMPARE(<=); /*@switchbreak@*/ break;
1156 case GEQ: COMPARE(>=); /*@switchbreak@*/ break;
1158 top->value = (v1 == v2) ? 1 : 0;
1159 top->unsignedp = FALSE;
1160 /*@switchbreak@*/ break;
1162 top->value = (v1 != v2) ? 1 : 0;
1163 top->unsignedp = FALSE;
1164 /*@switchbreak@*/ break;
1166 if (skip_evaluation != 0)
1168 /*@switchbreak@*/ break;
1171 top->unsignedp = unsigned1;
1172 if (v2 < 0 && ! unsigned2)
1173 top->value = right_shift (v1, unsigned1, -v2);
1175 top->value = left_shift (pfile, v1, unsigned1, v2);
1176 /*@switchbreak@*/ break;
1178 if (skip_evaluation != 0)
1180 /*@switchbreak@*/ break;
1182 top->unsignedp = unsigned1;
1183 if (v2 < 0 && ! unsigned2)
1184 top->value = left_shift (pfile, v1, unsigned1, -v2);
1186 top->value = right_shift (v1, unsigned1, v2);
1187 /*@switchbreak@*/ break;
1190 #define LOGICAL(OP) \
1191 top->value = v1 OP v2;\
1192 top->unsignedp = unsigned1 || unsigned2;
1194 case '&': LOGICAL(&); /*@switchbreak@*/ break;
1195 case '^': LOGICAL(^); /*@switchbreak@*/ break;
1196 case '|': LOGICAL(|); /*@switchbreak@*/ break;
1198 top->value = ((v1 != 0) && (v2 != 0)) ? 1 : 0;
1199 top->unsignedp = FALSE;
1205 /*@switchbreak@*/ break;
1207 top->value = ((v1 != 0) || (v2 != 0)) ? 1 : 0;
1208 top->unsignedp = FALSE;
1213 /*@switchbreak@*/ break;
1215 if (cppReader_isPedantic (pfile))
1216 cppReader_pedwarnLit (pfile,
1217 cstring_makeLiteralTemp ("comma operator in operand of `#if'"));
1219 top->unsignedp = unsigned2;
1220 /*@switchbreak@*/ break;
1222 cppReader_errorLit (pfile,
1223 cstring_makeLiteralTemp ("syntax error in #if"));
1226 if (top[0].op != '?')
1228 cppReader_errorLit (pfile,
1229 cstring_makeLiteralTemp ("syntax error ':' without preceding '?'"));
1232 else if (((top[1].flags & HAVE_VALUE) == 0)
1233 || ((top[-1].flags & HAVE_VALUE) == 0)
1234 || ((top[0].flags & HAVE_VALUE) == 0))
1236 cppReader_errorLit (pfile,
1237 cstring_makeLiteralTemp ("bad syntax for ?: operator"));
1243 if (top->value != 0)
1248 top->value = (top->value != 0) ? v1 : v2;
1249 top->unsignedp = unsigned1 || unsigned2;
1251 /*@switchbreak@*/ break;
1253 if (((top[1].flags & HAVE_VALUE) != 0)
1254 || ((top[0].flags & HAVE_VALUE) == 0)
1256 || ((top[-1].flags & HAVE_VALUE) != 0))
1258 cppReader_errorLit (pfile,
1259 cstring_makeLiteralTemp ("mismatched parentheses in #if"));
1266 top->unsignedp = unsigned1;
1267 top->flags |= HAVE_VALUE;
1269 /*@switchbreak@*/ break;
1273 top[1].op >= ' ' && top[1].op <= '~'
1274 ? "unimplemented operator '%c'\n"
1275 : "unimplemented operator '\\%03o'\n",
1286 cppReader_errorLit (pfile,
1287 cstring_makeLiteralTemp ("internal error in #if expression"));
1292 if (stack != init_stack)
1296 } /*@=branchstate@*/
1302 /* Check for and handle stack overflow. */
1305 struct operation *new_stack;
1306 int old_size = (char *) limit - (char *) stack;
1307 size_t new_size = size_fromInt (2 * old_size);
1309 if (stack != init_stack)
1311 new_stack = (struct operation *) drealloc ((char *) stack,
1316 new_stack = (struct operation *) dmalloc (new_size);
1318 /* Bug: the parameters were in the wrong order! */
1319 memcpy ((char *) new_stack, (char *) stack, old_size);
1321 } /*@=branchstate@*/
1324 top = (struct operation *) ((char *) new_stack + old_size);
1325 limit = (struct operation *) ((char *) new_stack + new_size);
1327 } /*@=branchstate@*/
1332 if ((op.op == OROR && (top[-1].value != 0))
1333 || (op.op == ANDAND && (top[-1].value == 0))
1334 || (op.op == '?' && (top[-1].value == 0)))
1338 else if (op.op == ':')
1340 if (top[-2].value != 0) /* Was condition true? */
1356 if (stack != init_stack)
1360 } /*@=branchstate@*/
1363 cppReader_skipRestOfLine (pfile);