/* 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 */ #include "config.h" #include "cpplib.h" #include "cpphash.h" #ifdef __EMX__ #include #endif #ifdef MULTIBYTE_CHARS #include #endif #include #include #include /* 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; }