2 ** Splint - annotation-assisted static program checker
3 ** Copyright (C) 1994-2003 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, unsigned long);
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++)
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")))
286 /* Some buggy compilers (e.g. MPW C) seem to need both casts. */
287 ULONG_MAX_over_base = ((unsigned long) -1) / ((unsigned long) base);
289 for (; len > 0; len--) {
292 if (c >= '0' && c <= '9')
294 digit = (int) (c - '0');
296 else if (base == 16 && c >= 'a' && c <= 'f')
298 digit = (int) (c - 'a') + 10;
300 else if (base == 16 && c >= 'A' && c <= 'F')
302 digit = (int) (c - 'A') + 10;
306 /* `l' means long, and `u' means unsigned. */
309 if (c == 'l' || c == 'L')
312 cppReader_errorLit (pfile,
313 cstring_makeLiteralTemp ("two `l's in integer constant"));
316 else if (c == 'u' || c == 'U')
319 cppReader_errorLit (pfile,
320 cstring_makeLiteralTemp ("two `u's in integer constant"));
325 /*@innerbreak@*/ break;
330 /*@innerbreak@*/ break;
335 /* Don't look for any more digits after the suffixes. */
339 if (largest_digit < digit)
341 largest_digit = digit;
344 nd = (long unsigned) (n * base + digit);
345 overflow |= (ULONG_MAX_over_base < (unsigned long) n)
346 | (nd < (unsigned long) n);
354 cstring_makeLiteralTemp ("Invalid number in #if expression"));
355 op.op = CPPREADER_ERRORTOK;
359 if (base <= largest_digit)
363 cstring_makeLiteralTemp
364 ("Integer constant contains digits beyond the radix"));
371 cstring_makeLiteralTemp ("Integer constant out of range"));
374 /* If too big to be signed, consider it unsigned. */
375 if ((long) n < 0 && ! op.unsignedp)
381 cstring_makeLiteralTemp ("Integer constant is so large that it is unsigned"));
389 DPRINTF (("Parse number: %d", op.value));
394 /*@null@*/ /*@observer@*/ char *operator;
398 static struct token tokentab2[] = {
403 { "==", CPP_EQUALTOK },
407 { "++", CPPREADER_ERRORTOK },
408 { "--", CPPREADER_ERRORTOK },
409 { NULL, CPPREADER_ERRORTOK }
412 /* Read one token. */
414 struct operation cppexp_lex (cppReader *pfile)
418 register struct token *toktab;
419 enum cpp_token token;
421 char *tok_start, *tok_end;
426 old_written = size_toInt (cpplib_getWritten (pfile));
427 cppSkipHspace (pfile);
428 ic = cpplib_bufPeek (cppReader_getBufferSafe (pfile));
434 /* was: llassert (c != '#'); - Solaris uses this, attempt to continue anyway... */
435 cppReader_pedwarn (pfile,
436 message ("non-standard pre-processor directive: %c", c));
439 DPRINTF (("Read: %c", c));
447 token = cpplib_getTokenForceExpand (pfile);
449 tok_start = pfile->token_buffer + old_written;
450 tok_end = cpplib_getPWritten (pfile);
452 DPRINTF (("Token: %s < %s", tok_start, tok_end));
454 pfile->limit = tok_start;
458 case CPP_EOF: /* Should not happen ... */
463 if (cstring_isDefined (cppReader_getBufferSafe (pfile)->fname))
468 (void) cppReader_popBuffer (pfile);
470 case CPP_HSPACE: case CPP_COMMENT:
473 return cppReader_parseNumber (pfile, tok_start, tok_end - tok_start);
475 cppReader_errorLit (pfile,
476 cstring_makeLiteralTemp ("string constants not allowed in #if expressions"));
477 op.op = CPPREADER_ERRORTOK;
480 /* This code for reading a character constant
481 handles multicharacter constants and wide characters.
482 It is mostly copied from c-lex.c. */
486 size_t width = MAX_CHAR_TYPE_SIZE;
489 char *ptr = tok_start;
490 #ifdef MULTIBYTE_CHARS
491 char token_buffer[MAX_LONG_TYPE_SIZE/MAX_CHAR_TYPE_SIZE + MB_CUR_MAX];
493 char token_buffer[MAX_LONG_TYPE_SIZE/MAX_CHAR_TYPE_SIZE + 1];
500 width = MAX_WCHAR_TYPE_SIZE;
501 #ifdef MULTIBYTE_CHARS
502 max_chars = MB_CUR_MAX;
509 max_chars = size_toInt (MAX_LONG_TYPE_SIZE / width);
513 while (ptr < tok_end && ((c = *ptr++) != '\''))
517 c = cppReader_parseEscape (pfile, &ptr);
518 if (width < HOST_BITS_PER_INT && c >= (1 << width))
522 cstring_makeLiteralTemp ("Escape sequence out of range for character"));
528 /* Merge character into result; ignore excess chars. */
529 if (num_chars < max_chars + 1)
531 if (width < HOST_BITS_PER_INT)
533 result = (int) ((unsigned) result << width) | (c & ((1 << width) - 1));
540 token_buffer[num_chars - 1] = c;
544 token_buffer[num_chars] = 0;
547 cppReader_errorLit (pfile,
548 cstring_makeLiteralTemp ("malformatted character constant"));
549 else if (num_chars == 0)
550 cppReader_errorLit (pfile,
551 cstring_makeLiteralTemp ("empty character constant"));
552 else if (num_chars > max_chars)
554 num_chars = max_chars;
555 cppReader_errorLit (pfile,
556 cstring_makeLiteralTemp ("character constant too long"));
558 else if (num_chars != 1 && ! cppReader_isTraditional (pfile))
560 cppReader_warningLit (pfile,
561 cstring_makeLiteralTemp ("multi-character character constant"));
568 /* If char type is signed, sign-extend the constant. */
571 int num_bits = num_chars * width;
573 if ((cpphash_lookup ("__CHAR_UNSIGNED__",
574 sizeof ("__CHAR_UNSIGNED__") - 1, -1) != NULL)
575 || (((unsigned) result >> (int_toNonNegative (num_bits - 1))) & 1) == 0)
578 = result & ((unsigned long) ~0
579 >> int_toNonNegative ((HOST_BITS_PER_LONG - num_bits)));
584 = result | ~((unsigned long) ~0
585 >> int_toNonNegative ((HOST_BITS_PER_LONG - num_bits)));
590 #ifdef MULTIBYTE_CHARS
591 /* Set the initial shift state and convert the next sequence. */
593 /* In all locales L'\0' is zero and mbtowc will return zero,
596 || (num_chars == 1 && token_buffer[0] != '\0'))
599 (void) mbtowc (NULL, NULL, 0);
600 if (mbtowc (& wc, token_buffer, num_chars) == num_chars)
603 cppReader_pedwarn (pfile,"Ignoring invalid multibyte character");
610 /* This is always a signed type. */
611 op.unsignedp = FALSE;
618 return cppReader_parseNumber (pfile, "0", 0);
621 /* See if it is a special token of length 2. */
622 if (tok_start + 2 == tok_end)
624 for (toktab = tokentab2; toktab->operator != NULL; toktab++)
626 if (tok_start[0] == toktab->operator[0] &&
627 tok_start[1] == toktab->operator[1])
629 /*@loopbreak@*/ break;
633 if (toktab->token == CPPREADER_ERRORTOK)
635 cppReader_error (pfile,
636 message ("`%s' not allowed in operand of `#if'",
637 cstring_fromChars (tok_start)));
640 op.op = toktab->token;
654 /* Parse a C escape sequence. STRING_PTR points to a variable
655 containing a pointer to the string to parse. That pointer
656 is updated past the characters we use. The value of the
657 escape sequence is returned.
659 A negative value means the sequence \ newline was seen,
660 which is supposed to be equivalent to nothing at all.
662 If \ is followed by a null character, we return a negative
663 value and leave the string pointer pointing at the null character.
665 If \ is followed by 000, we return 0 and leave the string pointer
666 after the zeros. A value of 0 does not mean end of string. */
669 cppReader_parseEscape (cppReader *pfile, char **string_ptr)
671 char c = *(*string_ptr)++;
681 if (cppReader_isPedantic (pfile))
683 cppReader_pedwarn (pfile,
684 message ("non-standard escape sequence, `\\%c'", c));
690 return TARGET_NEWLINE;
712 int i = (int) c - '0';
717 c = *(*string_ptr)++;
718 if (c >= '0' && c <= '7')
720 i = ((unsigned) i << 3) + c - '0';
726 /*@loopbreak@*/ break;
729 if ((i & ~((1 << MAX_CHAR_TYPE_SIZE) - 1)) != 0)
731 i &= (1 << MAX_CHAR_TYPE_SIZE) - 1;
732 cppReader_pedwarnLit (pfile,
733 cstring_makeLiteralTemp ("octal character constant does not fit in a byte"));
739 register unsigned i = 0, overflow = 0, digits_found = 0, digit;
742 c = *(*string_ptr)++;
744 if (c >= '0' && c <= '9')
746 digit = (unsigned int) (c - '0');
748 else if (c >= 'a' && c <= 'f')
750 digit = (unsigned int) (c - 'a') + 10;
752 else if (c >= 'A' && c <= 'F')
754 digit = (unsigned int) (c - 'A') + 10;
759 /*@loopbreak@*/ break;
761 overflow |= i ^ (i << 4 >> 4);
762 i = (i << 4) + digit;
766 if (digits_found == 0)
768 cppReader_errorLit (pfile,
769 cstring_makeLiteralTemp ("\\x used with no following hex digits"));
772 if ((overflow | (i & ~((1 << int_toNonNegative (BITS_PER_UNIT)) - 1))) != 0)
774 i &= (1 << BITS_PER_UNIT) - 1;
775 cppReader_pedwarnLit (pfile,
776 cstring_makeLiteralTemp ("hex character constant does not fit in a byte"));
787 integer_overflow (cppReader *pfile)
789 if (cppReader_isPedantic (pfile))
790 cppReader_pedwarnLit (pfile,
791 cstring_makeLiteralTemp ("integer overflow in preprocessor expression"));
795 left_shift (cppReader *pfile, long a, bool unsignedp, unsigned long b)
797 if (b >= HOST_BITS_PER_LONG)
799 if (!unsignedp && a != 0)
801 integer_overflow (pfile);
808 return (unsigned long) a << b;
812 /*@-shiftimplementation@*/
813 long l = a << b; /* int_toNonNegative removed (allow shifts of negative values) */
816 # pragma warning( disable : 4018 )
819 if (l >> b != a) /* int_toNonNegative removed (allow shifts of negative values) */
821 integer_overflow (pfile);
829 right_shift (long a, bool unsignedp, unsigned long b)
831 if (b >= HOST_BITS_PER_LONG)
832 return (unsignedp ? 0 : int_toNonNegative (a) >> (HOST_BITS_PER_LONG - 1));
834 return (unsigned long) a >> b;
836 return a >> b; /* int_toNonNegative removed (allow shifts of negative values) */
837 /*@=shiftimplementation@*/
840 /* These priorities are all even, so we can handle associatively. */
842 /*@constant int PAREN_INNER_PRIO@*/
843 #define PAREN_INNER_PRIO 0
845 /*@constant int COMMA_PRIO@*/
848 /*@constant int COND_PRIO@*/
849 #define COND_PRIO (COMMA_PRIO+2)
851 /*@constant int OROR_PRIO@*/
852 #define OROR_PRIO (COND_PRIO+2)
854 /*@constant int ANDAND_PRIO@*/
855 #define ANDAND_PRIO (OROR_PRIO+2)
857 /*@constant int OR_PRIO@*/
858 #define OR_PRIO (ANDAND_PRIO+2)
860 /*@constant int XOR_PRIO@*/
861 #define XOR_PRIO (OR_PRIO+2)
863 /*@constant int AND_PRIO@*/
864 #define AND_PRIO (XOR_PRIO+2)
866 /*@constant int CPP_EQUAL_PRIO@*/
867 #define CPP_EQUAL_PRIO (AND_PRIO+2)
869 /*@constant int LESS_PRIO@*/
870 #define LESS_PRIO (CPP_EQUAL_PRIO+2)
872 /*@constant int SHIFT_PRIO@*/
873 #define SHIFT_PRIO (LESS_PRIO+2)
875 /*@constant int PLUS_PRIO@*/
876 #define PLUS_PRIO (SHIFT_PRIO+2)
878 /*@constant int MUL_PRIO@*/
879 #define MUL_PRIO (PLUS_PRIO+2)
881 /*@constant int UNARY_PRIO@*/
882 #define UNARY_PRIO (MUL_PRIO+2)
884 /*@constant int PAREN_OUTER_PRIO@*/
885 #define PAREN_OUTER_PRIO (UNARY_PRIO+2)
888 #define COMPARE(OP) \
889 top->unsignedp = FALSE;\
890 top->value = ((unsigned1 || unsigned2) \
891 ? (unsigned long) v1 OP (unsigned long) v2 \
892 : ((long) v1 OP (long) v2)) ? 1 : 0
894 /* Parse and evaluate a C expression, reading from PFILE.
895 Returns the value of the expression. */
897 /*@constant int INIT_STACK_SIZE@*/
898 # define INIT_STACK_SIZE 20
901 cppReader_parseExpression (cppReader *pfile)
903 /* The implementation is an operator precedence parser,
904 i.e. a bottom-up parser, using a stack for not-yet-reduced tokens.
906 The stack base is 'stack', and the current stack pointer is 'top'.
907 There is a stack element for each operator (only),
908 and the most recently pushed operator is 'top->op'.
909 An operand (value) is stored in the 'value' field of the stack
910 element of the operator that precedes it.
911 In that case the 'flags' field has the HAVE_VALUE flag set. */
913 struct operation init_stack[INIT_STACK_SIZE];
914 struct operation *stack = init_stack;
915 struct operation *limit = stack + INIT_STACK_SIZE;
916 register struct operation *top = stack;
917 int lprio, rprio = 0;
918 int skip_evaluation = 0;
929 op = cppexp_lex (pfile);
931 /* See if the token is an operand, in which case go to set_value.
932 If the token is an operator, figure out its left and right
933 priorities, and then goto maybe_reduce. */
938 top->value = 0, top->unsignedp = FALSE;
942 top->value = op.value;
943 top->unsignedp = op.unsignedp;
946 lprio = 0; goto maybe_reduce;
948 /* Is this correct if unary ? FIXME */
949 flags = RIGHT_OPERAND_REQUIRED;
950 lprio = PLUS_PRIO; rprio = lprio + 1; goto maybe_reduce;
952 flags = RIGHT_OPERAND_REQUIRED;
953 rprio = UNARY_PRIO; lprio = rprio + 1; goto maybe_reduce;
954 case '*': case '/': case '%':
955 lprio = MUL_PRIO; goto binop;
956 case '<': case '>': case LEQ: case GEQ:
957 lprio = LESS_PRIO; goto binop;
958 case CPP_EQUALTOK: case NOTEQUAL:
959 lprio = CPP_EQUAL_PRIO; goto binop;
961 lprio = SHIFT_PRIO; goto binop;
962 case '&': lprio = AND_PRIO; goto binop;
963 case '^': lprio = XOR_PRIO; goto binop;
964 case '|': lprio = OR_PRIO; goto binop;
965 case ANDAND: lprio = ANDAND_PRIO; goto binop;
966 case OROR: lprio = OROR_PRIO; goto binop;
968 lprio = COMMA_PRIO; goto binop;
970 lprio = PAREN_OUTER_PRIO; rprio = PAREN_INNER_PRIO;
973 lprio = PAREN_INNER_PRIO; rprio = PAREN_OUTER_PRIO;
976 lprio = COND_PRIO; rprio = COND_PRIO;
979 lprio = COND_PRIO + 1; rprio = COND_PRIO;
982 flags = LEFT_OPERAND_REQUIRED | RIGHT_OPERAND_REQUIRED;
988 message ("Invalid character in #if: %c",
994 /* Push a value onto the stack. */
995 if ((top->flags & HAVE_VALUE) != 0)
997 cppReader_errorLit (pfile,
998 cstring_makeLiteralTemp ("syntax error in #if"));
1001 top->flags |= HAVE_VALUE;
1005 /* Push an operator, and check if we can reduce now. */
1006 while (top->rprio > lprio)
1009 HOST_WIDE_INT v1 = top[-1].value;
1010 HOST_WIDE_INT v2 = top[0].value;
1011 bool unsigned1 = top[-1].unsignedp;
1012 bool unsigned2 = top[0].unsignedp;
1016 if (((top[1].flags & LEFT_OPERAND_REQUIRED) != 0)
1017 && ((top[0].flags & HAVE_VALUE) == 0))
1019 cppReader_errorLit (pfile,
1020 cstring_makeLiteralTemp ("syntax error - missing left operand"));
1023 if (((top[1].flags & RIGHT_OPERAND_REQUIRED) != 0)
1024 && ((top[1].flags & HAVE_VALUE) == 0))
1026 cppReader_errorLit (pfile,
1027 cstring_makeLiteralTemp ("syntax error - missing right operand"));
1030 /* top[0].value = (top[1].op)(v1, v2);*/
1034 if ((top->flags & HAVE_VALUE) == 0)
1037 top->unsignedp = unsigned2;
1038 top->flags |= HAVE_VALUE;
1042 top->value = v1 + v2;
1043 top->unsignedp = unsigned1 || unsigned2;
1044 if (!top->unsignedp && (skip_evaluation == 0)
1045 && ! possibleSumSign (v1, v2, top->value))
1046 integer_overflow (pfile);
1048 /*@switchbreak@*/ break;
1050 if ((top->flags & HAVE_VALUE) == 0)
1053 if ((skip_evaluation == 0)
1054 && (top->value & v2) < 0 && !unsigned2)
1055 integer_overflow (pfile);
1056 top->unsignedp = unsigned2;
1057 top->flags |= HAVE_VALUE;
1061 top->value = v1 - v2;
1062 top->unsignedp = unsigned1 || unsigned2;
1063 if (!top->unsignedp && (skip_evaluation == 0)
1064 && !possibleSumSign (top->value, v2, v1))
1066 integer_overflow (pfile);
1069 /*@switchbreak@*/ break;
1071 top->unsignedp = unsigned1 || unsigned2;
1075 top->value = (unsigned long) v1 * v2;
1077 else if (skip_evaluation == 0)
1079 top->value = v1 * v2;
1081 && (top->value / v1 != v2
1082 || (top->value & v1 & v2) < 0))
1084 integer_overflow (pfile);
1092 /*@switchbreak@*/ break;
1094 if (skip_evaluation != 0)
1095 /*@switchbreak@*/ break;
1098 cppReader_errorLit (pfile,
1099 cstring_makeLiteralTemp ("Division by zero in #if"));
1102 top->unsignedp = unsigned1 || unsigned2;
1104 top->value = (unsigned long) v1 / v2;
1107 top->value = v1 / v2;
1108 if ((top->value & v1 & v2) < 0)
1109 integer_overflow (pfile);
1111 /*@switchbreak@*/ break;
1113 if (skip_evaluation != 0)
1114 /*@switchbreak@*/ break;
1117 cppReader_errorLit (pfile,
1118 cstring_makeLiteralTemp ("Division by zero in #if"));
1121 top->unsignedp = unsigned1 || unsigned2;
1123 top->value = (unsigned long) v1 % v2;
1125 top->value = v1 % v2;
1126 /*@switchbreak@*/ break;
1128 if ((top->flags & HAVE_VALUE) != 0)
1130 cppReader_errorLit (pfile,
1131 cstring_makeLiteralTemp ("Syntax error"));
1135 top->value = (v2 == 0) ? 1 : 0;
1136 top->unsignedp = FALSE;
1137 top->flags |= HAVE_VALUE;
1138 /*@switchbreak@*/ break;
1140 if ((top->flags & HAVE_VALUE) != 0)
1142 cppReader_errorLit (pfile,
1143 cstring_makeLiteralTemp ("syntax error"));
1147 top->unsignedp = unsigned2;
1148 top->flags |= HAVE_VALUE;
1149 /*@switchbreak@*/ break;
1150 case '<': COMPARE(<); /*@switchbreak@*/ break;
1151 case '>': COMPARE(>); /*@switchbreak@*/ break;
1152 case LEQ: COMPARE(<=); /*@switchbreak@*/ break;
1153 case GEQ: COMPARE(>=); /*@switchbreak@*/ break;
1155 top->value = (v1 == v2) ? 1 : 0;
1156 top->unsignedp = FALSE;
1157 /*@switchbreak@*/ break;
1159 top->value = (v1 != v2) ? 1 : 0;
1160 top->unsignedp = FALSE;
1161 /*@switchbreak@*/ break;
1163 if (skip_evaluation != 0)
1165 /*@switchbreak@*/ break;
1168 top->unsignedp = unsigned1;
1169 if (v2 < 0 && ! unsigned2)
1170 top->value = right_shift (v1, unsigned1, -v2);
1172 top->value = left_shift (pfile, v1, unsigned1, v2);
1173 /*@switchbreak@*/ break;
1175 if (skip_evaluation != 0)
1177 /*@switchbreak@*/ break;
1179 top->unsignedp = unsigned1;
1180 if (v2 < 0 && ! unsigned2)
1181 top->value = left_shift (pfile, v1, unsigned1, -v2);
1183 top->value = right_shift (v1, unsigned1, v2);
1184 /*@switchbreak@*/ break;
1187 #define LOGICAL(OP) \
1188 top->value = v1 OP v2;\
1189 top->unsignedp = unsigned1 || unsigned2;
1191 case '&': LOGICAL(&); /*@switchbreak@*/ break;
1192 case '^': LOGICAL(^); /*@switchbreak@*/ break;
1193 case '|': LOGICAL(|); /*@switchbreak@*/ break;
1195 top->value = ((v1 != 0) && (v2 != 0)) ? 1 : 0;
1196 top->unsignedp = FALSE;
1202 /*@switchbreak@*/ break;
1204 top->value = ((v1 != 0) || (v2 != 0)) ? 1 : 0;
1205 top->unsignedp = FALSE;
1210 /*@switchbreak@*/ break;
1212 if (cppReader_isPedantic (pfile))
1213 cppReader_pedwarnLit (pfile,
1214 cstring_makeLiteralTemp ("comma operator in operand of `#if'"));
1216 top->unsignedp = unsigned2;
1217 /*@switchbreak@*/ break;
1219 cppReader_errorLit (pfile,
1220 cstring_makeLiteralTemp ("syntax error in #if"));
1223 if (top[0].op != '?')
1225 cppReader_errorLit (pfile,
1226 cstring_makeLiteralTemp ("syntax error ':' without preceding '?'"));
1229 else if (((top[1].flags & HAVE_VALUE) == 0)
1230 || ((top[-1].flags & HAVE_VALUE) == 0)
1231 || ((top[0].flags & HAVE_VALUE) == 0))
1233 cppReader_errorLit (pfile,
1234 cstring_makeLiteralTemp ("bad syntax for ?: operator"));
1240 if (top->value != 0)
1245 top->value = (top->value != 0) ? v1 : v2;
1246 top->unsignedp = unsigned1 || unsigned2;
1248 /*@switchbreak@*/ break;
1250 if (((top[1].flags & HAVE_VALUE) != 0)
1251 || ((top[0].flags & HAVE_VALUE) == 0)
1253 || ((top[-1].flags & HAVE_VALUE) != 0))
1255 cppReader_errorLit (pfile,
1256 cstring_makeLiteralTemp ("mismatched parentheses in #if"));
1263 top->unsignedp = unsigned1;
1264 top->flags |= HAVE_VALUE;
1266 /*@switchbreak@*/ break;
1270 top[1].op >= ' ' && top[1].op <= '~'
1271 ? "unimplemented operator '%c'\n"
1272 : "unimplemented operator '\\%03o'\n",
1283 cppReader_errorLit (pfile,
1284 cstring_makeLiteralTemp ("internal error in #if expression"));
1289 if (stack != init_stack)
1293 } /*@=branchstate@*/
1299 /* Check for and handle stack overflow. */
1302 struct operation *new_stack;
1303 size_t old_size = size_fromInt ((char *) limit - (char *) stack);
1304 size_t new_size = (size_t) (2 * old_size);
1306 if (stack != init_stack)
1308 new_stack = (struct operation *) drealloc ((char *) stack,
1313 new_stack = (struct operation *) dmalloc (new_size);
1315 /* Bug: the parameters were in the wrong order! */
1316 memcpy ((char *) new_stack, (char *) stack, old_size);
1318 } /*@=branchstate@*/
1321 top = (struct operation *) ((char *) new_stack + old_size);
1322 limit = (struct operation *) ((char *) new_stack + new_size);
1324 } /*@=branchstate@*/
1329 if ((op.op == OROR && (top[-1].value != 0))
1330 || (op.op == ANDAND && (top[-1].value == 0))
1331 || (op.op == '?' && (top[-1].value == 0)))
1335 else if (op.op == ':')
1337 if (top[-2].value != 0) /* Was condition true? */
1353 if (stack != init_stack)
1357 } /*@=branchstate@*/
1360 cppReader_skipRestOfLine (pfile);