#include "config.h"
#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
#include "cpplib.h"
#include "cpphash.h"
-typedef unsigned long cpp_num_part;
-typedef struct cpp_num cpp_num;
-
#define PART_PRECISION (sizeof (cpp_num_part) * CHAR_BIT)
#define HALF_MASK (~(cpp_num_part) 0 >> (PART_PRECISION / 2))
#define LOW_PART(num_part) (num_part & HALF_MASK)
#define HIGH_PART(num_part) (num_part >> (PART_PRECISION / 2))
-/* A preprocessing number. Code assumes that any unused high bits of
- the double integer are set to zero. */
-struct cpp_num
-{
- cpp_num_part high;
- cpp_num_part low;
- bool unsignedp; /* True if value should be treated as unsigned. */
- bool overflow; /* True if the most recent calculation overflowed. */
-};
-
struct op
{
- cpp_num value; /* The value logically "right" of op. */
+ const cpp_token *token; /* The token forming op (for diagnostics). */
+ cpp_num value; /* The value logically "right" of op. */
enum cpp_ttype op;
};
enum cpp_ttype));
static cpp_num num_equality_op PARAMS ((cpp_reader *, cpp_num, cpp_num,
enum cpp_ttype));
-static cpp_num num_mul PARAMS ((cpp_reader *, cpp_num, cpp_num,
- enum cpp_ttype));
+static cpp_num num_mul PARAMS ((cpp_reader *, cpp_num, cpp_num));
static cpp_num num_div_op PARAMS ((cpp_reader *, cpp_num, cpp_num,
enum cpp_ttype));
static cpp_num num_lshift PARAMS ((cpp_num, size_t, size_t));
static cpp_num num_rshift PARAMS ((cpp_num, size_t, size_t));
static cpp_num append_digit PARAMS ((cpp_num, int, int, size_t));
-static cpp_num interpret_number PARAMS ((cpp_reader *, const cpp_token *));
static cpp_num parse_defined PARAMS ((cpp_reader *));
static cpp_num eval_token PARAMS ((cpp_reader *, const cpp_token *));
static struct op *reduce PARAMS ((cpp_reader *, struct op *, enum cpp_ttype));
+static unsigned int interpret_float_suffix PARAMS ((const uchar *, size_t));
+static unsigned int interpret_int_suffix PARAMS ((const uchar *, size_t));
+static void check_promotion PARAMS ((cpp_reader *, const struct op *));
-/* Token type abuse. There is no "error" token, but we can't get
- comments in #if, so we can abuse that token type. Similarly,
- create unary plus and minus operators. */
-#define CPP_ERROR CPP_COMMENT
+/* Token type abuse to create unary plus and minus operators. */
#define CPP_UPLUS (CPP_LAST_CPP_OP + 1)
#define CPP_UMINUS (CPP_LAST_CPP_OP + 2)
#define SYNTAX_ERROR2(msgid, arg) \
do { cpp_error (pfile, DL_ERROR, msgid, arg); goto syntax_error; } while(0)
-struct suffix
+/* Subroutine of cpp_classify_number. S points to a float suffix of
+ length LEN, possibly zero. Returns 0 for an invalid suffix, or a
+ flag vector describing the suffix. */
+static unsigned int
+interpret_float_suffix (s, len)
+ const uchar *s;
+ size_t len;
{
- const unsigned char s[4];
- const unsigned char u;
- const unsigned char l;
-};
+ size_t f = 0, l = 0, i = 0;
-static const struct suffix vsuf_1[] = {
- { "u", 1, 0 }, { "U", 1, 0 },
- { "l", 0, 1 }, { "L", 0, 1 }
-};
+ while (len--)
+ switch (s[len])
+ {
+ case 'f': case 'F': f++; break;
+ case 'l': case 'L': l++; break;
+ case 'i': case 'I':
+ case 'j': case 'J': i++; break;
+ default:
+ return 0;
+ }
-static const struct suffix vsuf_2[] = {
- { "ul", 1, 1 }, { "UL", 1, 1 }, { "uL", 1, 1 }, { "Ul", 1, 1 },
- { "lu", 1, 1 }, { "LU", 1, 1 }, { "Lu", 1, 1 }, { "lU", 1, 1 },
- { "ll", 0, 2 }, { "LL", 0, 2 }
-};
+ if (f + l > 1 || i > 1)
+ return 0;
-static const struct suffix vsuf_3[] = {
- { "ull", 1, 2 }, { "ULL", 1, 2 }, { "uLL", 1, 2 }, { "Ull", 1, 2 },
- { "llu", 1, 2 }, { "LLU", 1, 2 }, { "LLu", 1, 2 }, { "llU", 1, 2 }
-};
+ return ((i ? CPP_N_IMAGINARY : 0)
+ | (f ? CPP_N_SMALL :
+ l ? CPP_N_LARGE : CPP_N_MEDIUM));
+}
+
+/* Subroutine of cpp_classify_number. S points to an integer suffix
+ of length LEN, possibly zero. Returns 0 for an invalid suffix, or a
+ flag vector describing the suffix. */
+static unsigned int
+interpret_int_suffix (s, len)
+ const uchar *s;
+ size_t len;
+{
+ size_t u, l, i;
+
+ u = l = i = 0;
+
+ while (len--)
+ switch (s[len])
+ {
+ case 'u': case 'U': u++; break;
+ case 'i': case 'I':
+ case 'j': case 'J': i++; break;
+ case 'l': case 'L': l++;
+ /* If there are two Ls, they must be adjacent and the same case. */
+ if (l == 2 && s[len] != s[len + 1])
+ return 0;
+ break;
+ default:
+ return 0;
+ }
+
+ if (l > 2 || u > 1 || i > 1)
+ return 0;
+
+ return ((i ? CPP_N_IMAGINARY : 0)
+ | (u ? CPP_N_UNSIGNED : 0)
+ | ((l == 0) ? CPP_N_SMALL
+ : (l == 1) ? CPP_N_MEDIUM : CPP_N_LARGE));
+}
+
+/* Categorize numeric constants according to their field (integer,
+ floating point, or invalid), radix (decimal, octal, hexadecimal),
+ and type suffixes. */
+unsigned int
+cpp_classify_number (pfile, token)
+ cpp_reader *pfile;
+ const cpp_token *token;
+{
+ const uchar *str = token->val.str.text;
+ const uchar *limit;
+ unsigned int max_digit, result, radix;
+ enum {NOT_FLOAT = 0, AFTER_POINT, AFTER_EXPON} float_flag;
+
+ /* If the lexer has done its job, length one can only be a single
+ digit. Fast-path this very common case. */
+ if (token->val.str.len == 1)
+ return CPP_N_INTEGER | CPP_N_SMALL | CPP_N_DECIMAL;
+
+ limit = str + token->val.str.len;
+ float_flag = NOT_FLOAT;
+ max_digit = 0;
+ radix = 10;
+
+ /* First, interpret the radix. */
+ if (*str == '0')
+ {
+ radix = 8;
+ str++;
+
+ /* Require at least one hex digit to classify it as hex. */
+ if ((*str == 'x' || *str == 'X') && ISXDIGIT (str[1]))
+ {
+ radix = 16;
+ str++;
+ }
+ }
+
+ /* Now scan for a well-formed integer or float. */
+ for (;;)
+ {
+ unsigned int c = *str++;
+
+ if (ISDIGIT (c) || (ISXDIGIT (c) && radix == 16))
+ {
+ c = hex_value (c);
+ if (c > max_digit)
+ max_digit = c;
+ }
+ else if (c == '.')
+ {
+ if (float_flag == NOT_FLOAT)
+ float_flag = AFTER_POINT;
+ else
+ SYNTAX_ERROR ("too many decimal points in number");
+ }
+ else if ((radix <= 10 && (c == 'e' || c == 'E'))
+ || (radix == 16 && (c == 'p' || c == 'P')))
+ {
+ float_flag = AFTER_EXPON;
+ break;
+ }
+ else
+ {
+ /* Start of suffix. */
+ str--;
+ break;
+ }
+ }
+
+ if (float_flag != NOT_FLOAT && radix == 8)
+ radix = 10;
+
+ if (max_digit >= radix)
+ SYNTAX_ERROR2 ("invalid digit \"%c\" in octal constant", '0' + max_digit);
+
+ if (float_flag != NOT_FLOAT)
+ {
+ if (radix == 16 && CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, c99))
+ cpp_error (pfile, DL_PEDWARN,
+ "use of C99 hexadecimal floating constant");
+
+ if (float_flag == AFTER_EXPON)
+ {
+ if (*str == '+' || *str == '-')
+ str++;
+
+ /* Exponent is decimal, even if string is a hex float. */
+ if (!ISDIGIT (*str))
+ SYNTAX_ERROR ("exponent has no digits");
+
+ do
+ str++;
+ while (ISDIGIT (*str));
+ }
+ else if (radix == 16)
+ SYNTAX_ERROR ("hexadecimal floating constants require an exponent");
+
+ result = interpret_float_suffix (str, limit - str);
+ if (result == 0)
+ {
+ cpp_error (pfile, DL_ERROR,
+ "invalid suffix \"%.*s\" on floating constant",
+ (int) (limit - str), str);
+ return CPP_N_INVALID;
+ }
+
+ /* Traditional C didn't accept any floating suffixes. */
+ if (limit != str
+ && CPP_WTRADITIONAL (pfile)
+ && ! cpp_sys_macro_p (pfile))
+ cpp_error (pfile, DL_WARNING,
+ "traditional C rejects the \"%.*s\" suffix",
+ (int) (limit - str), str);
+
+ result |= CPP_N_FLOATING;
+ }
+ else
+ {
+ result = interpret_int_suffix (str, limit - str);
+ if (result == 0)
+ {
+ cpp_error (pfile, DL_ERROR,
+ "invalid suffix \"%.*s\" on integer constant",
+ (int) (limit - str), str);
+ return CPP_N_INVALID;
+ }
+
+ /* Traditional C only accepted the 'L' suffix.
+ Suppress warning about 'LL' with -Wno-long-long. */
+ if (CPP_WTRADITIONAL (pfile) && ! cpp_sys_macro_p (pfile))
+ {
+ int u_or_i = (result & (CPP_N_UNSIGNED|CPP_N_IMAGINARY));
+ int large = (result & CPP_N_WIDTH) == CPP_N_LARGE;
+
+ if (u_or_i || (large && CPP_OPTION (pfile, warn_long_long)))
+ cpp_error (pfile, DL_WARNING,
+ "traditional C rejects the \"%.*s\" suffix",
+ (int) (limit - str), str);
+ }
+
+ if ((result & CPP_N_WIDTH) == CPP_N_LARGE
+ && ! CPP_OPTION (pfile, c99)
+ && CPP_OPTION (pfile, warn_long_long))
+ cpp_error (pfile, DL_PEDWARN, "use of C99 long long integer constant");
+
+ result |= CPP_N_INTEGER;
+ }
+
+ if ((result & CPP_N_IMAGINARY) && CPP_PEDANTIC (pfile))
+ cpp_error (pfile, DL_PEDWARN, "imaginary constants are a GCC extension");
+
+ if (radix == 10)
+ result |= CPP_N_DECIMAL;
+ else if (radix == 16)
+ result |= CPP_N_HEX;
+ else
+ result |= CPP_N_OCTAL;
+
+ return result;
+
+ syntax_error:
+ return CPP_N_INVALID;
+}
+
+/* cpp_interpret_integer converts an integer constant into a cpp_num,
+ of precision options->precision.
+
+ We do not provide any interface for decimal->float conversion,
+ because the preprocessor doesn't need it and the floating point
+ handling in GCC proper is too ugly to speak of. */
+cpp_num
+cpp_interpret_integer (pfile, token, type)
+ cpp_reader *pfile;
+ const cpp_token *token;
+ unsigned int type;
+{
+ const uchar *p, *end;
+ cpp_num result;
+
+ result.low = 0;
+ result.high = 0;
+ result.unsignedp = !!(type & CPP_N_UNSIGNED);
+ result.overflow = false;
+
+ p = token->val.str.text;
+ end = p + token->val.str.len;
+
+ /* Common case of a single digit. */
+ if (token->val.str.len == 1)
+ result.low = p[0] - '0';
+ else
+ {
+ cpp_num_part max;
+ size_t precision = CPP_OPTION (pfile, precision);
+ unsigned int base = 10, c = 0;
+ bool overflow = false;
+
+ if ((type & CPP_N_RADIX) == CPP_N_OCTAL)
+ {
+ base = 8;
+ p++;
+ }
+ else if ((type & CPP_N_RADIX) == CPP_N_HEX)
+ {
+ base = 16;
+ p += 2;
+ }
+
+ /* We can add a digit to numbers strictly less than this without
+ needing the precision and slowness of double integers. */
+ max = ~(cpp_num_part) 0;
+ if (precision < PART_PRECISION)
+ max >>= PART_PRECISION - precision;
+ max = (max - base + 1) / base + 1;
+
+ for (; p < end; p++)
+ {
+ c = *p;
+
+ if (ISDIGIT (c) || (base == 16 && ISXDIGIT (c)))
+ c = hex_value (c);
+ else
+ break;
+
+ /* Strict inequality for when max is set to zero. */
+ if (result.low < max)
+ result.low = result.low * base + c;
+ else
+ {
+ result = append_digit (result, c, base, precision);
+ overflow |= result.overflow;
+ max = 0;
+ }
+ }
+
+ if (overflow)
+ cpp_error (pfile, DL_PEDWARN,
+ "integer constant is too large for its type");
+ /* If too big to be signed, consider it unsigned. Only warn for
+ decimal numbers. Traditional numbers were always signed (but
+ we still honor an explicit U suffix); but we only have
+ traditional semantics in directives. */
+ else if (!result.unsignedp
+ && !(CPP_OPTION (pfile, traditional)
+ && pfile->state.in_directive)
+ && !num_positive (result, precision))
+ {
+ if (base == 10)
+ cpp_error (pfile, DL_WARNING,
+ "integer constant is so large that it is unsigned");
+ result.unsignedp = true;
+ }
+ }
+
+ return result;
+}
/* Append DIGIT to NUM, a number of PRECISION bits being read in base
BASE. */
/* Multiply by 8 or 16. Catching this overflow here means we don't
need to worry about add_high overflowing. */
- overflow = num.high >> (PART_PRECISION - shift);
+ overflow = !!(num.high >> (PART_PRECISION - shift));
result.high = num.high << shift;
result.low = num.low << shift;
result.high |= num.low >> (PART_PRECISION - shift);
return result;
}
-/* Parse and convert what is presumably an integer in TOK. Accepts
- decimal, hex, or octal with or without size suffixes. Returned op
- is CPP_ERROR on error, otherwise it is a CPP_NUMBER. */
-static cpp_num
-interpret_number (pfile, tok)
- cpp_reader *pfile;
- const cpp_token *tok;
-{
- cpp_num result;
- const uchar *start = tok->val.str.text;
- const uchar *end = start + tok->val.str.len;
- const uchar *p = start;
- const struct suffix *sufftab;
- size_t precision = CPP_OPTION (pfile, precision);
- unsigned int i, nsuff, base = 10, c = 0, largest_digit = 0;
- bool overflow = false;
-
- result.low = result.high = 0;
- result.unsignedp = 0;
- result.overflow = 0;
-
- if (p[0] == '0')
- {
- if (end - start >= 3 && (p[1] == 'x' || p[1] == 'X'))
- {
- p += 2;
- base = 16;
- }
- else
- {
- p += 1;
- base = 8;
- }
- }
-
- for(; p < end; p++)
- {
- c = *p;
-
- if (ISDIGIT (c) || (base == 16 && ISXDIGIT (c)))
- c = hex_value (c);
- else
- break;
-
- result = append_digit (result, c, base, precision);
- overflow |= result.overflow;
- if (largest_digit < c)
- largest_digit = c;
- }
-
- if (p < end)
- {
- /* Check for a floating point constant. Note that float constants
- with an exponent or suffix but no decimal point are technically
- invalid (C99 6.4.4.2) but accepted elsewhere. */
- if ((c == '.' || c == 'F' || c == 'f')
- || (base == 10 && (c == 'E' || c == 'e')
- && p+1 < end && (p[1] == '+' || p[1] == '-'))
- || (base == 16 && (c == 'P' || c == 'p')
- && p+1 < end && (p[1] == '+' || p[1] == '-')))
- SYNTAX_ERROR ("floating point numbers are not valid in #if");
-
- /* Determine the suffix. l means long, and u means unsigned.
- See the suffix tables, above. */
- switch (end - p)
- {
- case 1: sufftab = vsuf_1; nsuff = ARRAY_SIZE (vsuf_1); break;
- case 2: sufftab = vsuf_2; nsuff = ARRAY_SIZE (vsuf_2); break;
- case 3: sufftab = vsuf_3; nsuff = ARRAY_SIZE (vsuf_3); break;
- default: goto invalid_suffix;
- }
-
- for (i = 0; i < nsuff; i++)
- if (memcmp (p, sufftab[i].s, end - p) == 0)
- break;
- if (i == nsuff)
- goto invalid_suffix;
- result.unsignedp = sufftab[i].u;
-
- if (CPP_WTRADITIONAL (pfile)
- && sufftab[i].u
- && ! cpp_sys_macro_p (pfile))
- cpp_error (pfile, DL_WARNING, "traditional C rejects the `U' suffix");
- if (sufftab[i].l == 2 && CPP_OPTION (pfile, pedantic)
- && ! CPP_OPTION (pfile, c99))
- cpp_error (pfile, DL_PEDWARN,
- "too many 'l' suffixes in integer constant");
- }
-
- if (base <= largest_digit)
- cpp_error (pfile, DL_PEDWARN,
- "integer constant contains digits beyond the radix");
-
- if (overflow)
- cpp_error (pfile, DL_PEDWARN, "integer constant too large for its type");
- /* If too big to be signed, consider it unsigned. */
- else if (!result.unsignedp && !num_positive (result, precision))
- {
- if (base == 10)
- cpp_error (pfile, DL_WARNING,
- "integer constant is so large that it is unsigned");
- result.unsignedp = 1;
- }
-
- return result;
-
- invalid_suffix:
- cpp_error (pfile, DL_ERROR, "invalid suffix '%.*s' on integer constant",
- (int) (end - p), p);
- syntax_error:
- return result;
-}
-
/* Handle meeting "defined" in a preprocessor expression. */
static cpp_num
parse_defined (pfile)
cpp_error (pfile, DL_WARNING,
"this use of \"defined\" may not be portable");
+ _cpp_mark_macro_used (node);
+
/* A possible controlling macro of the form #if !defined ().
_cpp_parse_expr checks there was no other junk on the line. */
pfile->mi_ind_cmacro = node;
pfile->state.prevent_expansion--;
- result.unsignedp = 0;
+ result.unsignedp = false;
result.high = 0;
- result.overflow = 0;
+ result.overflow = false;
result.low = node && node->type == NT_MACRO;
return result;
}
/* Convert a token into a CPP_NUMBER (an interpreted preprocessing
number or character constant, or the result of the "defined" or "#"
- operators), or CPP_ERROR on error. */
+ operators). */
static cpp_num
eval_token (pfile, token)
cpp_reader *pfile;
switch (token->type)
{
case CPP_NUMBER:
- return interpret_number (pfile, token);
+ temp = cpp_classify_number (pfile, token);
+ switch (temp & CPP_N_CATEGORY)
+ {
+ case CPP_N_FLOATING:
+ cpp_error (pfile, DL_ERROR,
+ "floating constant in preprocessor expression");
+ break;
+ case CPP_N_INTEGER:
+ if (!(temp & CPP_N_IMAGINARY))
+ return cpp_interpret_integer (pfile, token, temp);
+ cpp_error (pfile, DL_ERROR,
+ "imaginary number in preprocessor expression");
+ break;
+
+ case CPP_N_INVALID:
+ /* Error already issued. */
+ break;
+ }
+ result.high = result.low = 0;
+ break;
case CPP_WCHAR:
case CPP_CHAR:
result.low = temp;
}
- result.unsignedp = unsignedp;
- result.overflow = 0;
+ result.unsignedp = !!unsignedp;
+ result.overflow = false;
return result;
}
\f
The remaining cases are '(' and ')'. We handle '(' by skipping the
reduction phase completely. ')' is given lower priority than
everything else, including '(', effectively forcing a reduction of the
-parenthesised expression. If there is a matching '(', the routine
+parenthesized expression. If there is a matching '(', the routine
reduce() exits immediately. If the normal exit route sees a ')', then
there cannot have been a matching '(' and an error message is output.
the flag NO_L_OPERAND is set. These semantics are automatic; any
extra semantics need to be handled with operator-specific code. */
-/* Flags. */
+/* Flags. If CHECK_PROMOTION, we warn if the effective sign of an
+ operand changes because of integer promotions. */
#define NO_L_OPERAND (1 << 0)
#define LEFT_ASSOC (1 << 1)
+#define CHECK_PROMOTION (1 << 2)
-/* Arity. */
-#define UNARY (1 << 0)
-#define BINARY (1 << 1)
-#define OTHER (1 << 2)
-
-typedef cpp_num (*binary_handler) PARAMS ((cpp_reader *, cpp_num, cpp_num,
- enum cpp_ttype));
/* Operator to priority map. Must be in the same order as the first
N entries of enum cpp_ttype. */
static const struct operator
{
uchar prio;
uchar flags;
- uchar arity;
- binary_handler handler;
} optab[] =
{
- /* EQ */ {0, 0, OTHER, NULL}, /* Shouldn't happen. */
- /* NOT */ {16, NO_L_OPERAND, UNARY, NULL},
- /* GREATER */ {12, LEFT_ASSOC, BINARY, num_inequality_op},
- /* LESS */ {12, LEFT_ASSOC, BINARY, num_inequality_op},
- /* PLUS */ {14, LEFT_ASSOC, BINARY, num_binary_op},
- /* MINUS */ {14, LEFT_ASSOC, BINARY, num_binary_op},
- /* MULT */ {15, LEFT_ASSOC, BINARY, num_mul},
- /* DIV */ {15, LEFT_ASSOC, BINARY, num_div_op},
- /* MOD */ {15, LEFT_ASSOC, BINARY, num_div_op},
- /* AND */ {9, LEFT_ASSOC, BINARY, num_bitwise_op},
- /* OR */ {7, LEFT_ASSOC, BINARY, num_bitwise_op},
- /* XOR */ {8, LEFT_ASSOC, BINARY, num_bitwise_op},
- /* RSHIFT */ {13, LEFT_ASSOC, BINARY, num_binary_op},
- /* LSHIFT */ {13, LEFT_ASSOC, BINARY, num_binary_op},
-
- /* MIN */ {10, LEFT_ASSOC, BINARY, num_binary_op},
- /* MAX */ {10, LEFT_ASSOC, BINARY, num_binary_op},
-
- /* COMPL */ {16, NO_L_OPERAND, UNARY, NULL},
- /* AND_AND */ {6, LEFT_ASSOC, OTHER, NULL},
- /* OR_OR */ {5, LEFT_ASSOC, OTHER, NULL},
- /* QUERY */ {3, 0, OTHER, NULL},
- /* COLON */ {4, LEFT_ASSOC, OTHER, NULL},
- /* COMMA */ {2, LEFT_ASSOC, BINARY, num_binary_op},
- /* OPEN_PAREN */ {1, NO_L_OPERAND, OTHER, NULL},
- /* CLOSE_PAREN */ {0, 0, OTHER, NULL},
- /* EOF */ {0, 0, OTHER, NULL},
- /* EQ_EQ */ {11, LEFT_ASSOC, BINARY, num_equality_op},
- /* NOT_EQ */ {11, LEFT_ASSOC, BINARY, num_equality_op},
- /* GREATER_EQ */ {12, LEFT_ASSOC, BINARY, num_inequality_op},
- /* LESS_EQ */ {12, LEFT_ASSOC, BINARY, num_inequality_op},
- /* UPLUS */ {16, NO_L_OPERAND, UNARY, NULL},
- /* UMINUS */ {16, NO_L_OPERAND, UNARY, NULL}
+ /* EQ */ {0, 0}, /* Shouldn't happen. */
+ /* NOT */ {16, NO_L_OPERAND},
+ /* GREATER */ {12, LEFT_ASSOC | CHECK_PROMOTION},
+ /* LESS */ {12, LEFT_ASSOC | CHECK_PROMOTION},
+ /* PLUS */ {14, LEFT_ASSOC | CHECK_PROMOTION},
+ /* MINUS */ {14, LEFT_ASSOC | CHECK_PROMOTION},
+ /* MULT */ {15, LEFT_ASSOC | CHECK_PROMOTION},
+ /* DIV */ {15, LEFT_ASSOC | CHECK_PROMOTION},
+ /* MOD */ {15, LEFT_ASSOC | CHECK_PROMOTION},
+ /* AND */ {9, LEFT_ASSOC | CHECK_PROMOTION},
+ /* OR */ {7, LEFT_ASSOC | CHECK_PROMOTION},
+ /* XOR */ {8, LEFT_ASSOC | CHECK_PROMOTION},
+ /* RSHIFT */ {13, LEFT_ASSOC},
+ /* LSHIFT */ {13, LEFT_ASSOC},
+
+ /* MIN */ {10, LEFT_ASSOC | CHECK_PROMOTION},
+ /* MAX */ {10, LEFT_ASSOC | CHECK_PROMOTION},
+
+ /* COMPL */ {16, NO_L_OPERAND},
+ /* AND_AND */ {6, LEFT_ASSOC},
+ /* OR_OR */ {5, LEFT_ASSOC},
+ /* QUERY */ {3, 0},
+ /* COLON */ {4, LEFT_ASSOC | CHECK_PROMOTION},
+ /* COMMA */ {2, LEFT_ASSOC},
+ /* OPEN_PAREN */ {1, NO_L_OPERAND},
+ /* CLOSE_PAREN */ {0, 0},
+ /* EOF */ {0, 0},
+ /* EQ_EQ */ {11, LEFT_ASSOC},
+ /* NOT_EQ */ {11, LEFT_ASSOC},
+ /* GREATER_EQ */ {12, LEFT_ASSOC | CHECK_PROMOTION},
+ /* LESS_EQ */ {12, LEFT_ASSOC | CHECK_PROMOTION},
+ /* UPLUS */ {16, NO_L_OPERAND},
+ /* UMINUS */ {16, NO_L_OPERAND}
};
/* Parse and evaluate a C expression, reading from PFILE.
cpp_reader *pfile;
{
struct op *top = pfile->op_stack;
- const cpp_token *token = NULL, *prev_token;
unsigned int lex_count;
bool saw_leading_not, want_value = true;
{
struct op op;
- prev_token = token;
- token = cpp_get_token (pfile);
lex_count++;
- op.op = token->type;
+ op.token = cpp_get_token (pfile);
+ op.op = op.token->type;
switch (op.op)
{
case CPP_HASH:
if (!want_value)
SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
- cpp_token_as_text (pfile, token));
+ cpp_token_as_text (pfile, op.token));
want_value = false;
- top->value = eval_token (pfile, token);
+ top->value = eval_token (pfile, op.token);
continue;
case CPP_NOT:
op.op = CPP_UMINUS;
break;
case CPP_OTHER:
- if (ISGRAPH (token->val.c))
- SYNTAX_ERROR2 ("invalid character '%c' in #if", token->val.c);
+ if (ISGRAPH (op.token->val.c))
+ SYNTAX_ERROR2 ("invalid character '%c' in #if", op.token->val.c);
else
- SYNTAX_ERROR2 ("invalid character '\\%03o' in #if", token->val.c);
+ SYNTAX_ERROR2 ("invalid character '\\%03o' in #if",
+ op.token->val.c);
default:
if ((int) op.op <= (int) CPP_EQ || (int) op.op >= (int) CPP_PLUS_EQ)
- SYNTAX_ERROR2 ("token \"%s\" is not valid in #if expressions",
- cpp_token_as_text (pfile, token));
+ SYNTAX_ERROR2 ("token \"%s\" is not valid in preprocessor expressions",
+ cpp_token_as_text (pfile, op.token));
break;
}
{
if (!want_value)
SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
- cpp_token_as_text (pfile, token));
+ cpp_token_as_text (pfile, op.token));
}
else if (want_value)
{
- /* Ordering here is subtle and intended to favour the
+ /* Ordering here is subtle and intended to favor the
missing parenthesis diagnostics over alternatives. */
if (op.op == CPP_CLOSE_PAREN)
{
SYNTAX_ERROR ("#if with no expression");
if (top->op != CPP_EOF && top->op != CPP_OPEN_PAREN)
SYNTAX_ERROR2 ("operator '%s' has no right operand",
- cpp_token_as_text (pfile, prev_token));
+ cpp_token_as_text (pfile, top->token));
}
top = reduce (pfile, top, op.op);
top = _cpp_expand_op_stack (pfile);
top->op = op.op;
+ top->token = op.token;
}
/* The controlling macro expression is only valid if we called lex 3
prio = optab[op].prio - ((optab[op].flags & LEFT_ASSOC) != 0);
while (prio < optab[top->op].prio)
{
- if (optab[top->op].arity == UNARY)
- {
- if (!pfile->state.skip_eval)
- top[-1].value = num_unary_op (pfile, top->value, top->op);
- top--;
- }
- else if (optab[top->op].arity == BINARY)
- {
- if (!pfile->state.skip_eval)
- top[-1].value = (* (binary_handler) optab[top->op].handler)
- (pfile, top[-1].value, top->value, top->op);
- top--;
- }
- /* Anything changing skip_eval has to be handled here. */
- else switch (top--->op)
+ if (CPP_OPTION (pfile, warn_num_sign_change)
+ && optab[top->op].flags & CHECK_PROMOTION)
+ check_promotion (pfile, top);
+
+ switch (top->op)
{
+ case CPP_UPLUS:
+ case CPP_UMINUS:
+ case CPP_NOT:
+ case CPP_COMPL:
+ top[-1].value = num_unary_op (pfile, top->value, top->op);
+ break;
+
+ case CPP_PLUS:
+ case CPP_MINUS:
+ case CPP_RSHIFT:
+ case CPP_LSHIFT:
+ case CPP_MIN:
+ case CPP_MAX:
+ case CPP_COMMA:
+ top[-1].value = num_binary_op (pfile, top[-1].value,
+ top->value, top->op);
+ break;
+
+ case CPP_GREATER:
+ case CPP_LESS:
+ case CPP_GREATER_EQ:
+ case CPP_LESS_EQ:
+ top[-1].value
+ = num_inequality_op (pfile, top[-1].value, top->value, top->op);
+ break;
+
+ case CPP_EQ_EQ:
+ case CPP_NOT_EQ:
+ top[-1].value
+ = num_equality_op (pfile, top[-1].value, top->value, top->op);
+ break;
+
+ case CPP_AND:
+ case CPP_OR:
+ case CPP_XOR:
+ top[-1].value
+ = num_bitwise_op (pfile, top[-1].value, top->value, top->op);
+ break;
+
+ case CPP_MULT:
+ top[-1].value = num_mul (pfile, top[-1].value, top->value);
+ break;
+
+ case CPP_DIV:
+ case CPP_MOD:
+ top[-1].value = num_div_op (pfile, top[-1].value,
+ top->value, top->op);
+ break;
+
case CPP_OR_OR:
+ top--;
if (!num_zerop (top->value))
pfile->state.skip_eval--;
- top->value.low = !num_zerop (top->value) || !num_zerop (top[1].value);
+ top->value.low = (!num_zerop (top->value)
+ || !num_zerop (top[1].value));
top->value.high = 0;
top->value.unsignedp = false;
top->value.overflow = false;
- break;
+ continue;
case CPP_AND_AND:
+ top--;
if (num_zerop (top->value))
pfile->state.skip_eval--;
- top->value.low = !num_zerop (top->value) && !num_zerop (top[1].value);
+ top->value.low = (!num_zerop (top->value)
+ && !num_zerop (top[1].value));
top->value.high = 0;
top->value.unsignedp = false;
top->value.overflow = false;
- break;
+ continue;
case CPP_OPEN_PAREN:
if (op != CPP_CLOSE_PAREN)
cpp_error (pfile, DL_ERROR, "missing ')' in expression");
return 0;
}
+ top--;
top->value = top[1].value;
return top;
case CPP_COLON:
- top--;
+ top -= 2;
if (!num_zerop (top->value))
{
pfile->state.skip_eval--;
top->value = top[2].value;
top->value.unsignedp = (top[1].value.unsignedp
|| top[2].value.unsignedp);
- break;
+ continue;
case CPP_QUERY:
cpp_error (pfile, DL_ERROR, "'?' without following ':'");
goto bad_op;
}
+ top--;
if (top->value.overflow && !pfile->state.skip_eval)
cpp_error (pfile, DL_PEDWARN,
"integer overflow in preprocessor expression");
return pfile->op_stack + old_size;
}
+/* Emits a warning if the effective sign of either operand of OP
+ changes because of integer promotions. */
+static void
+check_promotion (pfile, op)
+ cpp_reader *pfile;
+ const struct op *op;
+{
+ if (op->value.unsignedp == op[-1].value.unsignedp)
+ return;
+
+ if (op->value.unsignedp)
+ {
+ if (!num_positive (op[-1].value, CPP_OPTION (pfile, precision)))
+ cpp_error (pfile, DL_WARNING,
+ "the left operand of \"%s\" changes sign when promoted",
+ cpp_token_as_text (pfile, op->token));
+ }
+ else if (!num_positive (op->value, CPP_OPTION (pfile, precision)))
+ cpp_error (pfile, DL_WARNING,
+ "the right operand of \"%s\" changes sign when promoted",
+ cpp_token_as_text (pfile, op->token));
+}
+
/* Clears the unused high order bits of the number pointed to by PNUM. */
static cpp_num
num_trim (num, precision)
{
precision -= PART_PRECISION;
if (precision < PART_PRECISION)
- num.high &= (1 << precision) - 1;
+ num.high &= ((cpp_num_part) 1 << precision) - 1;
}
else
{
if (precision < PART_PRECISION)
- num.low &= (1 << precision) - 1;
+ num.low &= ((cpp_num_part) 1 << precision) - 1;
num.high = 0;
}
if (precision > PART_PRECISION)
{
precision -= PART_PRECISION;
- return (num.high & (1 << (precision - 1))) == 0;
+ return (num.high & (cpp_num_part) 1 << (precision - 1)) == 0;
}
- return (num.low & (1 << (precision - 1))) == 0;
+ return (num.low & (cpp_num_part) 1 << (precision - 1)) == 0;
+}
+
+/* Sign extend a number, with PRECISION significant bits and all
+ others assumed clear, to fill out a cpp_num structure. */
+cpp_num
+cpp_num_sign_extend (num, precision)
+ cpp_num num;
+ size_t precision;
+{
+ if (!num.unsignedp)
+ {
+ if (precision > PART_PRECISION)
+ {
+ precision -= PART_PRECISION;
+ if (precision < PART_PRECISION
+ && (num.high & (cpp_num_part) 1 << (precision - 1)))
+ num.high |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
+ }
+ else if (num.low & (cpp_num_part) 1 << (precision - 1))
+ {
+ if (precision < PART_PRECISION)
+ num.low |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
+ num.high = ~(cpp_num_part) 0;
+ }
+ }
+
+ return num;
}
/* Returns the negative of NUM. */
cpp_num lhs, rhs;
enum cpp_ttype op;
{
- lhs.low = num_eq (lhs, rhs);
+ /* Work around a 3.0.4 bug; see PR 6950. */
+ bool eq = num_eq (lhs, rhs);
if (op == CPP_NOT_EQ)
- lhs.low = !lhs.low;
+ eq = !eq;
+ lhs.low = eq;
lhs.high = 0;
lhs.overflow = false;
lhs.unsignedp = false;
switch (op)
{
case CPP_UPLUS:
- if (CPP_WTRADITIONAL (pfile))
+ if (CPP_WTRADITIONAL (pfile) && !pfile->state.skip_eval)
cpp_error (pfile, DL_WARNING,
"traditional C rejects the unary plus operator");
num.overflow = false;
/* Comma. */
default: /* case CPP_COMMA: */
- if (CPP_PEDANTIC (pfile))
+ if (CPP_PEDANTIC (pfile) && !pfile->state.skip_eval)
cpp_error (pfile, DL_PEDWARN,
"comma operator in operand of #if");
lhs = rhs;
result.high += HIGH_PART (middle[0]);
result.high += HIGH_PART (middle[1]);
+ result.unsignedp = 1;
return result;
}
/* Multiply two preprocessing numbers. */
static cpp_num
-num_mul (pfile, lhs, rhs, op)
+num_mul (pfile, lhs, rhs)
cpp_reader *pfile;
cpp_num lhs, rhs;
- enum cpp_ttype op ATTRIBUTE_UNUSED;
{
cpp_num result, temp;
bool unsignedp = lhs.unsignedp || rhs.unsignedp;
if (rhs.high)
{
i = precision - 1;
- mask = 1 << (i - PART_PRECISION);
+ mask = (cpp_num_part) 1 << (i - PART_PRECISION);
for (; ; i--, mask >>= 1)
if (rhs.high & mask)
break;
i = precision - PART_PRECISION - 1;
else
i = precision - 1;
- mask = 1 << i;
+ mask = (cpp_num_part) 1 << i;
for (; ; i--, mask >>= 1)
if (rhs.low & mask)
break;
}
else
{
- cpp_error (pfile, DL_ERROR, "division by zero in #if");
+ if (!pfile->state.skip_eval)
+ cpp_error (pfile, DL_ERROR, "division by zero in #if");
return lhs;
}
- /* First non-zero bit of RHS is bit I. Do naive division by
+ /* First nonzero bit of RHS is bit I. Do naive division by
shifting the RHS fully left, and subtracting from LHS if LHS is
at least as big, and then repeating but with one less shift.
This is not very efficient, but is easy to understand. */
{
lhs = num_binary_op (pfile, lhs, sub, CPP_MINUS);
if (i >= PART_PRECISION)
- result.high |= 1 << (i - PART_PRECISION);
+ result.high |= (cpp_num_part) 1 << (i - PART_PRECISION);
else
- result.low |= 1 << i;
+ result.low |= (cpp_num_part) 1 << i;
}
if (i-- == 0)
break;
OSDN Git Service
