/* Parse C expressions for CCCP.
* Copyright (C) 1987, 1992, 1994, 1995 Free Software Foundation.
* Copyright (C) 2003-2011 Kim Woelders
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2, or (at your option) any
* later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
*
* In other words, you are welcome to use, share and improve this program.
* You are forbidden to forbid anyone else to use, share and improve
* what you give them. Help stamp out software-hoarding!
*
* Written by Per Bothner 1994. */
/* Parse a C expression from text in a string */
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#ifdef __EMX__
# include <strings.h>
#endif
#ifdef MULTIBYTE_CHARS
# include <locale.h>
#endif
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "cpplib.h"
#include "cpphash.h"
/* This is used for communicating lists of keywords with cccp.c. */
struct arglist {
struct arglist *next;
unsigned char *name;
int length;
int argno;
};
/* Define a generic NULL if one hasn't already been defined. */
#ifndef NULL
#define NULL 0
#endif
#ifndef GENERIC_PTR
#if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
#define GENERIC_PTR void *
#else
#define GENERIC_PTR char *
#endif
#endif
#ifndef NULL_PTR
#define NULL_PTR ((GENERIC_PTR)0)
#endif
#ifndef CHAR_TYPE_SIZE
#define CHAR_TYPE_SIZE BITS_PER_UNIT
#endif
#ifndef INT_TYPE_SIZE
#define INT_TYPE_SIZE BITS_PER_WORD
#endif
#ifndef LONG_TYPE_SIZE
#define LONG_TYPE_SIZE BITS_PER_WORD
#endif
#ifndef WCHAR_TYPE_SIZE
#define WCHAR_TYPE_SIZE INT_TYPE_SIZE
#endif
#ifndef MAX_CHAR_TYPE_SIZE
#define MAX_CHAR_TYPE_SIZE CHAR_TYPE_SIZE
#endif
#ifndef MAX_INT_TYPE_SIZE
#define MAX_INT_TYPE_SIZE INT_TYPE_SIZE
#endif
#ifndef MAX_LONG_TYPE_SIZE
#define MAX_LONG_TYPE_SIZE LONG_TYPE_SIZE
#endif
#ifndef MAX_WCHAR_TYPE_SIZE
#define MAX_WCHAR_TYPE_SIZE WCHAR_TYPE_SIZE
#endif
/* Yield nonzero if adding two numbers with A's and B's signs can yield a
* number with SUM's sign, where A, B, and SUM are all C integers. */
#define possible_sum_sign(a, b, sum) ((((a) ^ (b)) | ~ ((a) ^ (sum))) < 0)
#define ERROR 299
#define OROR 300
#define ANDAND 301
#define EQUAL 302
#define NOTEQUAL 303
#define LEQ 304
#define GEQ 305
#define LSH 306
#define RSH 307
#define NAME 308
#define INT 309
#define CHAR 310
#define LEFT_OPERAND_REQUIRED 1
#define RIGHT_OPERAND_REQUIRED 2
#define HAVE_VALUE 4
/* SKIP_OPERAND is set for '&&' '||' '?' and ':' when the
* following operand should be short-circuited instead of evaluated. */
#define SKIP_OPERAND 8
/*#define UNSIGNEDP 16 */
struct operation {
short op;
char rprio; /* Priority of op (relative to it right operand). */
char flags;
char unsignedp; /* true if value should be treated as unsigned */
HOST_WIDE_INT value; /* The value logically "right" of op. */
};
/* Take care of parsing a number (anything that starts with a digit).
* LEN is the number of characters in it. */
/* maybe needs to actually deal with floating point numbers */
static void
parse_number(struct operation *op, cpp_reader * pfile, const char *start,
int olen)
{
const char *p = start;
int c;
unsigned long n = 0, nd, ULONG_MAX_over_base;
int base = 10;
int len = olen;
int overflow = 0;
int digit, largest_digit = 0;
int spec_long = 0;
op->unsignedp = 0;
for (c = 0; c < len; c++)
if (p[c] == '.')
{
/* It's a float since it contains a point. */
cpp_error(pfile,
"floating point numbers not allowed in #if expressions");
op->op = ERROR;
return;
}
if (len >= 3 && (!strncmp(p, "0x", 2) || !strncmp(p, "0X", 2)))
{
p += 2;
base = 16;
len -= 2;
}
else if (*p == '0')
base = 8;
/* Some buggy compilers (e.g. MPW C) seem to need both casts. */
ULONG_MAX_over_base = ((unsigned long)-1) / ((unsigned long)base);
for (; len > 0; len--)
{
c = *p++;
if (c >= '0' && c <= '9')
digit = c - '0';
else if (base == 16 && c >= 'a' && c <= 'f')
digit = c - 'a' + 10;
else if (base == 16 && c >= 'A' && c <= 'F')
digit = c - 'A' + 10;
else
{
/* `l' means long, and `u' means unsigned. */
while (1)
{
if (c == 'l' || c == 'L')
{
if (spec_long)
cpp_error(pfile, "two `l's in integer constant");
spec_long = 1;
}
else if (c == 'u' || c == 'U')
{
if (op->unsignedp)
cpp_error(pfile, "two `u's in integer constant");
op->unsignedp = 1;
}
else
break;
if (--len == 0)
break;
c = *p++;
}
/* Don't look for any more digits after the suffixes. */
break;
}
if (largest_digit < digit)
largest_digit = digit;
nd = n * base + digit;
overflow |= (ULONG_MAX_over_base < n) | (nd < n);
n = nd;
}
if (len != 0)
{
cpp_error(pfile, "Invalid number in #if expression");
op->op = ERROR;
return;
}
if (base <= largest_digit)
cpp_warning(pfile, "integer constant contains digits beyond the radix");
if (overflow)
cpp_warning(pfile, "integer constant out of range");
/* If too big to be signed, consider it unsigned. */
if ((long)n < 0 && !op->unsignedp)
{
if (base == 10)
cpp_warning(pfile,
"integer constant is so large that it is unsigned");
op->unsignedp = 1;
}
op->value = n;
op->op = INT;
}
struct token {
const char *oper;
int token;
};
static struct token tokentab2[] = {
{"&&", ANDAND},
{"||", OROR},
{"<<", LSH},
{">>", RSH},
{"==", EQUAL},
{"!=", NOTEQUAL},
{"<=", LEQ},
{">=", GEQ},
{"++", ERROR},
{"--", ERROR},
{NULL, ERROR}
};
/* Read one token. */
static void
cpp_lex(struct operation *op, cpp_reader * pfile)
{
int c;
struct token *toktab;
enum cpp_token token;
unsigned char *tok_start, *tok_end;
int old_written;
op->value = 0;
op->unsignedp = 0;
retry:
old_written = CPP_WRITTEN(pfile);
cpp_skip_hspace(pfile);
c = CPP_BUF_PEEK(CPP_BUFFER(pfile));
if (c == '#')
{
parse_number(op, pfile, cpp_read_check_assertion(pfile) ? "1" : "0", 1);
return;
}
if (c == '\n')
{
op->op = 0;
return;
}
token = cpp_get_token(pfile);
tok_start = pfile->token_buffer + old_written;
tok_end = CPP_PWRITTEN(pfile);
pfile->limit = tok_start;
switch (token)
{
case CPP_EOF: /* Should not happen ... */
op->op = 0;
break;
case CPP_VSPACE:
case CPP_POP:
if (CPP_BUFFER(pfile)->fname)
{
op->op = 0;
break;
}
goto retry;
case CPP_HSPACE:
case CPP_COMMENT:
goto retry;
case CPP_NUMBER:
parse_number(op, pfile, (char *)tok_start, tok_end - tok_start);
break;
case CPP_STRING:
cpp_error(pfile, "string constants not allowed in #if expressions");
op->op = ERROR;
break;
case CPP_CHAR:
/* This code for reading a character constant
* handles multicharacter constants and wide characters.
* It is mostly copied from c-lex.c. */
{
int result = 0;
int num_chars = 0;
unsigned width = MAX_CHAR_TYPE_SIZE;
int wide_flag = 0;
int max_chars;
char *ptr = (char *)tok_start;
#ifdef MULTIBYTE_CHARS
char token_buffer[MAX_LONG_TYPE_SIZE /
MAX_CHAR_TYPE_SIZE + MB_CUR_MAX];
#endif
if (*ptr == 'L')
{
ptr++;
wide_flag = 1;
width = MAX_WCHAR_TYPE_SIZE;
#ifdef MULTIBYTE_CHARS
max_chars = MB_CUR_MAX;
#else
max_chars = 1;
#endif
}
else
max_chars = MAX_LONG_TYPE_SIZE / width;
while (1)
{
if (ptr >= (char *)CPP_PWRITTEN(pfile) || (c = *ptr++) == '\'')
break;
if (c == '\\')
{
c = cpp_parse_escape(pfile, &ptr);
if (width < HOST_BITS_PER_INT
&& (unsigned)c >= (unsigned)(1 << width))
cpp_pedwarn(pfile,
"escape sequence out of range for character");
}
num_chars++;
/* Merge character into result; ignore excess chars. */
if (num_chars < max_chars + 1)
{
if (width < HOST_BITS_PER_INT)
result = (result << width) | (c & ((1 << width) - 1));
else
result = c;
#ifdef MULTIBYTE_CHARS
token_buffer[num_chars - 1] = c;
#endif
}
}
#ifdef MULTIBYTE_CHARS
token_buffer[num_chars] = 0;
#endif
if (c != '\'')
cpp_error(pfile, "malformatted character constant");
else if (num_chars == 0)
cpp_error(pfile, "empty character constant");
else if (num_chars > max_chars)
{
num_chars = max_chars;
cpp_error(pfile, "character constant too long");
}
else if (num_chars != 1 && !CPP_TRADITIONAL(pfile))
cpp_warning(pfile, "multi-character character constant");
/* If char type is signed, sign-extend the constant. */
if (!wide_flag)
{
int num_bits = num_chars * width;
if (cpp_lookup("__CHAR_UNSIGNED__",
sizeof("__CHAR_UNSIGNED__") - 1, -1)
|| ((result >> (num_bits - 1)) & 1) == 0)
op->value =
result & ((unsigned long)~0 >>
(HOST_BITS_PER_LONG - num_bits));
else
op->value =
result | ~((unsigned long)~0 >>
(HOST_BITS_PER_LONG - num_bits));
}
else
{
#ifdef MULTIBYTE_CHARS
/* Set the initial shift state and convert the next sequence. */
result = 0;
/* In all locales L'\0' is zero and mbtowc will return zero,
* so don't use it. */
if (num_chars > 1
|| (num_chars == 1 && token_buffer[0] != '\0'))
{
wchar_t wc;
(void)mbtowc(NULL_PTR, NULL_PTR, 0);
if (mbtowc(&wc, token_buffer, num_chars) == num_chars)
result = wc;
else
cpp_warning(pfile,
"Ignoring invalid multibyte character");
}
#endif
op->value = result;
}
}
/* This is always a signed type. */
op->unsignedp = 0;
op->op = CHAR;
break;
case CPP_NAME:
parse_number(op, pfile, "0", 0);
break;
case CPP_OTHER:
/* See if it is a special token of length 2. */
if (tok_start + 2 == tok_end)
{
for (toktab = tokentab2; toktab->oper; toktab++)
if (tok_start[0] == toktab->oper[0]
&& tok_start[1] == toktab->oper[1])
break;
if (toktab->token == ERROR)
{
char *buf = (char *)malloc(40);
memset(buf, 0, 40);
sprintf(buf, "`%s' not allowed in operand of `#if'",
tok_start);
cpp_error(pfile, buf);
free(buf);
}
op->op = toktab->token;
break;
}
/* fall through */
default:
op->op = *tok_start;
break;
}
}
/* Parse a C escape sequence. STRING_PTR points to a variable
* containing a pointer to the string to parse. That pointer
* is updated past the characters we use. The value of the
* escape sequence is returned.
*
* A negative value means the sequence \ newline was seen,
* which is supposed to be equivalent to nothing at all.
*
* If \ is followed by a null character, we return a negative
* value and leave the string pointer pointing at the null character.
*
* If \ is followed by 000, we return 0 and leave the string pointer
* after the zeros. A value of 0 does not mean end of string. */
int
cpp_parse_escape(cpp_reader * pfile, char **string_ptr)
{
int c = *(*string_ptr)++;
switch (c)
{
case 'a':
return TARGET_BELL;
case 'b':
return TARGET_BS;
case 'e':
case 'E':
if (CPP_PEDANTIC(pfile))
cpp_pedwarn(pfile, "non-ANSI-standard escape sequence, `\\%c'", c);
return 033;
case 'f':
return TARGET_FF;
case 'n':
return TARGET_NEWLINE;
case 'r':
return TARGET_CR;
case 't':
return TARGET_TAB;
case 'v':
return TARGET_VT;
case '\n':
return -2;
case 0:
(*string_ptr)--;
return 0;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
{
int i = c - '0';
int count = 0;
while (++count < 3)
{
c = *(*string_ptr)++;
if (c >= '0' && c <= '7')
i = (i << 3) + c - '0';
else
{
(*string_ptr)--;
break;
}
}
if ((i & ~((1 << MAX_CHAR_TYPE_SIZE) - 1)) != 0)
{
i &= (1 << MAX_CHAR_TYPE_SIZE) - 1;
cpp_warning(pfile,
"octal character constant does not fit in a byte");
}
return i;
}
case 'x':
{
unsigned i = 0, overflow = 0, digits_found = 0, digit;
for (;;)
{
c = *(*string_ptr)++;
if (c >= '0' && c <= '9')
digit = c - '0';
else if (c >= 'a' && c <= 'f')
digit = c - 'a' + 10;
else if (c >= 'A' && c <= 'F')
digit = c - 'A' + 10;
else
{
(*string_ptr)--;
break;
}
overflow |= i ^ (i << 4 >> 4);
i = (i << 4) + digit;
digits_found = 1;
}
if (!digits_found)
cpp_error(pfile, "\\x used with no following hex digits");
if (overflow | (i & ~((1 << BITS_PER_UNIT) - 1)))
{
i &= (1 << BITS_PER_UNIT) - 1;
cpp_warning(pfile,
"hex character constant does not fit in a byte");
}
return i;
}
default:
return c;
}
}
static void
integer_overflow(cpp_reader * pfile)
{
if (CPP_PEDANTIC(pfile))
cpp_pedwarn(pfile, "integer overflow in preprocessor expression");
}
static long
left_shift(cpp_reader * pfile, long a, int unsignedp, unsigned long b)
{
if (b >= HOST_BITS_PER_LONG)
{
if (!unsignedp && a != 0)
integer_overflow(pfile);
return 0;
}
else if (unsignedp)
return (unsigned long)a << b;
else
{
long l = a << b;
if (l >> b != a)
integer_overflow(pfile);
return l;
}
}
static long
right_shift(cpp_reader * pfile __UNUSED__, long a, int unsignedp,
unsigned long b)
{
if (b >= HOST_BITS_PER_LONG)
{
return unsignedp ? 0 : a >> (HOST_BITS_PER_LONG - 1);
}
else if (unsignedp)
{
return (unsigned long)a >> b;
}
else
{
return a >> b;
}
}
/* These priorities are all even, so we can handle associatively. */
#define PAREN_INNER_PRIO 0
#define COMMA_PRIO 4
#define COND_PRIO (COMMA_PRIO+2)
#define OROR_PRIO (COND_PRIO+2)
#define ANDAND_PRIO (OROR_PRIO+2)
#define OR_PRIO (ANDAND_PRIO+2)
#define XOR_PRIO (OR_PRIO+2)
#define AND_PRIO (XOR_PRIO+2)
#define EQUAL_PRIO (AND_PRIO+2)
#define LESS_PRIO (EQUAL_PRIO+2)
#define SHIFT_PRIO (LESS_PRIO+2)
#define PLUS_PRIO (SHIFT_PRIO+2)
#define MUL_PRIO (PLUS_PRIO+2)
#define UNARY_PRIO (MUL_PRIO+2)
#define PAREN_OUTER_PRIO (UNARY_PRIO+2)
#define COMPARE(OP) \
top->unsignedp = 0;\
top->value = (unsigned1 || unsigned2) ? (unsigned long) v1 OP (unsigned long) v2 : (v1 OP v2)
/* Parse and evaluate a C expression, reading from PFILE.
* Returns the value of the expression. */
HOST_WIDE_INT
cpp_parse_expr(cpp_reader * pfile)
{
/* The implementation is an operator precedence parser,
* i.e. a bottom-up parser, using a stack for not-yet-reduced tokens.
*
* The stack base is 'stack', and the current stack pointer is 'top'.
* There is a stack element for each operator (only),
* and the most recently pushed operator is 'top->op'.
* An operand (value) is stored in the 'value' field of the stack
* element of the operator that precedes it.
* In that case the 'flags' field has the HAVE_VALUE flag set. */
#define INIT_STACK_SIZE 20
struct operation init_stack[INIT_STACK_SIZE];
struct operation *stack = init_stack;
struct operation *limit = stack + INIT_STACK_SIZE;
struct operation *top = stack;
int lprio = 0, rprio = 0;
int skip_evaluation = 0;
top->rprio = 0;
top->flags = 0;
for (;;)
{
struct operation op;
char flags = 0;
/* Read a token */
cpp_lex(&op, pfile);
/* See if the token is an operand, in which case go to set_value.
* If the token is an operator, figure out its left and right
* priorities, and then goto maybe_reduce. */
switch (op.op)
{
case NAME:
top->value = 0, top->unsignedp = 0;
goto set_value;
case INT:
case CHAR:
top->value = op.value;
top->unsignedp = op.unsignedp;
goto set_value;
case 0:
lprio = 0;
goto maybe_reduce;
case '+':
case '-':
/* Is this correct if unary ? FIXME */
flags = RIGHT_OPERAND_REQUIRED;
lprio = PLUS_PRIO;
rprio = lprio + 1;
goto maybe_reduce;
case '!':
case '~':
flags = RIGHT_OPERAND_REQUIRED;
rprio = UNARY_PRIO;
lprio = rprio + 1;
goto maybe_reduce;
case '*':
case '/':
case '%':
lprio = MUL_PRIO;
goto binop;
case '<':
case '>':
case LEQ:
case GEQ:
lprio = LESS_PRIO;
goto binop;
case EQUAL:
case NOTEQUAL:
lprio = EQUAL_PRIO;
goto binop;
case LSH:
case RSH:
lprio = SHIFT_PRIO;
goto binop;
case '&':
lprio = AND_PRIO;
goto binop;
case '^':
lprio = XOR_PRIO;
goto binop;
case '|':
lprio = OR_PRIO;
goto binop;
case ANDAND:
lprio = ANDAND_PRIO;
goto binop;
case OROR:
lprio = OROR_PRIO;
goto binop;
case ',':
lprio = COMMA_PRIO;
goto binop;
case '(':
lprio = PAREN_OUTER_PRIO;
rprio = PAREN_INNER_PRIO;
goto maybe_reduce;
case ')':
lprio = PAREN_INNER_PRIO;
rprio = PAREN_OUTER_PRIO;
goto maybe_reduce;
case ':':
lprio = COND_PRIO;
rprio = COND_PRIO;
goto maybe_reduce;
case '?':
lprio = COND_PRIO + 1;
rprio = COND_PRIO;
goto maybe_reduce;
binop:
flags = LEFT_OPERAND_REQUIRED | RIGHT_OPERAND_REQUIRED;
rprio = lprio + 1;
goto maybe_reduce;
default:
cpp_error(pfile, "invalid character in #if");
goto syntax_error;
}
set_value:
/* Push a value onto the stack. */
if (top->flags & HAVE_VALUE)
{
cpp_error(pfile, "syntax error in #if");
goto syntax_error;
}
top->flags |= HAVE_VALUE;
continue;
maybe_reduce:
/* Push an operator, and check if we can reduce now. */
while (top->rprio > lprio)
{
long v1 = top[-1].value, v2 = top[0].value;
int unsigned1 = top[-1].unsignedp, unsigned2 =
top[0].unsignedp;
top--;
if ((top[1].flags & LEFT_OPERAND_REQUIRED)
&& !(top[0].flags & HAVE_VALUE))
{
cpp_error(pfile, "syntax error - missing left operand");
goto syntax_error;
}
if ((top[1].flags & RIGHT_OPERAND_REQUIRED)
&& !(top[1].flags & HAVE_VALUE))
{
cpp_error(pfile, "syntax error - missing right operand");
goto syntax_error;
}
/* top[0].value = (top[1].op)(v1, v2); */
switch (top[1].op)
{
case '+':
if (!(top->flags & HAVE_VALUE))
{ /* Unary '+' */
top->value = v2;
top->unsignedp = unsigned2;
top->flags |= HAVE_VALUE;
}
else
{
top->value = v1 + v2;
top->unsignedp = unsigned1 || unsigned2;
if (!top->unsignedp && !skip_evaluation
&& !possible_sum_sign(v1, v2, top->value))
integer_overflow(pfile);
}
break;
case '-':
if (skip_evaluation); /* do nothing */
else if (!(top->flags & HAVE_VALUE))
{ /* Unary '-' */
top->value = -v2;
if ((top->value & v2) < 0 && !unsigned2)
integer_overflow(pfile);
top->unsignedp = unsigned2;
top->flags |= HAVE_VALUE;
}
else
{ /* Binary '-' */
top->value = v1 - v2;
top->unsignedp = unsigned1 || unsigned2;
if (!top->unsignedp
&& !possible_sum_sign(top->value, v2, v1))
integer_overflow(pfile);
}
break;
case '*':
top->unsignedp = unsigned1 || unsigned2;
if (top->unsignedp)
top->value = (unsigned long)v1 *v2;
else if (!skip_evaluation)
{
top->value = v1 * v2;
if (v1
&& (top->value / v1 != v2
|| (top->value & v1 & v2) < 0))
integer_overflow(pfile);
}
break;
case '/':
if (skip_evaluation)
break;
if (v2 == 0)
{
cpp_error(pfile, "division by zero in #if");
v2 = 1;
}
top->unsignedp = unsigned1 || unsigned2;
if (top->unsignedp)
top->value = (unsigned long)v1 / v2;
else
{
top->value = v1 / v2;
if ((top->value & v1 & v2) < 0)
integer_overflow(pfile);
}
break;
case '%':
if (skip_evaluation)
break;
if (v2 == 0)
{
cpp_error(pfile, "division by zero in #if");
v2 = 1;
}
top->unsignedp = unsigned1 || unsigned2;
if (top->unsignedp)
top->value = (unsigned long)v1 % v2;
else
top->value = v1 % v2;
break;
case '!':
if (top->flags & HAVE_VALUE)
{
cpp_error(pfile, "syntax error");
goto syntax_error;
}
top->value = !v2;
top->unsignedp = 0;
top->flags |= HAVE_VALUE;
break;
case '~':
if (top->flags & HAVE_VALUE)
{
cpp_error(pfile, "syntax error");
goto syntax_error;
}
top->value = ~v2;
top->unsignedp = unsigned2;
top->flags |= HAVE_VALUE;
break;
case '<':
COMPARE(<);
break;
case '>':
COMPARE(>);
break;
case LEQ:
COMPARE(<=);
break;
case GEQ:
COMPARE(>=);
break;
case EQUAL:
top->value = (v1 == v2);
top->unsignedp = 0;
break;
case NOTEQUAL:
top->value = (v1 != v2);
top->unsignedp = 0;
break;
case LSH:
if (skip_evaluation)
break;
top->unsignedp = unsigned1;
if (v2 < 0 && !unsigned2)
top->value = right_shift(pfile, v1, unsigned1, -v2);
else
top->value = left_shift(pfile, v1, unsigned1, v2);
break;
case RSH:
if (skip_evaluation)
break;
top->unsignedp = unsigned1;
if (v2 < 0 && !unsigned2)
top->value = left_shift(pfile, v1, unsigned1, -v2);
else
top->value = right_shift(pfile, v1, unsigned1, v2);
break;
#define LOGICAL(OP) \
top->value = v1 OP v2;\
top->unsignedp = unsigned1 || unsigned2;
case '&':
LOGICAL(&);
break;
case '^':
LOGICAL(^);
break;
case '|':
LOGICAL(|);
break;
case ANDAND:
top->value = v1 && v2;
top->unsignedp = 0;
if (!v1)
skip_evaluation--;
break;
case OROR:
top->value = v1 || v2;
top->unsignedp = 0;
if (v1)
skip_evaluation--;
break;
case ',':
if (CPP_PEDANTIC(pfile))
cpp_pedwarn(pfile, "comma operator in operand of `#if'");
top->value = v2;
top->unsignedp = unsigned2;
break;
case '(':
case '?':
cpp_error(pfile, "syntax error in #if");
goto syntax_error;
case ':':
if (top[0].op != '?')
{
cpp_error(pfile,
"syntax error ':' without preceding '?'");
goto syntax_error;
}
else if (!(top[1].flags & HAVE_VALUE)
|| !(top[-1].flags & HAVE_VALUE)
|| !(top[0].flags & HAVE_VALUE))
{
cpp_error(pfile, "bad syntax for ?: operator");
goto syntax_error;
}
else
{
top--;
if (top->value)
skip_evaluation--;
top->value = top->value ? v1 : v2;
top->unsignedp = unsigned1 || unsigned2;
}
break;
case ')':
if ((top[1].flags & HAVE_VALUE)
|| !(top[0].flags & HAVE_VALUE)
|| top[0].op != '(' || (top[-1].flags & HAVE_VALUE))
{
cpp_error(pfile, "mismatched parentheses in #if");
goto syntax_error;
}
else
{
top--;
top->value = v1;
top->unsignedp = unsigned1;
top->flags |= HAVE_VALUE;
}
break;
default:
fprintf(stderr,
top[1].op >= ' ' && top[1].op <= '~'
? "unimplemented operator '%c'\n"
: "unimplemented operator '\\%03o'\n", top[1].op);
}
}
if (op.op == 0)
{
if (top != stack)
cpp_error(pfile, "internal error in #if expression");
if (stack != init_stack)
free(stack);
return top->value;
}
top++;
/* Check for and handle stack overflow. */
if (top == limit)
{
struct operation *new_stack;
int old_size = (char *)limit - (char *)stack;
int new_size = 2 * old_size;
if (stack != init_stack)
new_stack = (struct operation *)xrealloc(stack, new_size);
else
{
new_stack = (struct operation *)xmalloc(new_size);
memcpy((char *)new_stack, (char *)stack, old_size);
}
stack = new_stack;
top = (struct operation *)((char *)new_stack + old_size);
limit = (struct operation *)((char *)new_stack + new_size);
}
top->flags = flags;
top->rprio = rprio;
top->op = op.op;
if ((op.op == OROR && top[-1].value)
|| (op.op == ANDAND && !top[-1].value)
|| (op.op == '?' && !top[-1].value))
{
skip_evaluation++;
}
else if (op.op == ':')
{
if (top[-2].value) /* Was condition true? */
skip_evaluation++;
else
skip_evaluation--;
}
}
syntax_error:
if (stack != init_stack)
free(stack);
skip_rest_of_line(pfile);
return 0;
}