/* Parse C expressions for cpplib.
- Copyright (C) 1987-2013 Free Software Foundation, Inc.
+ Copyright (C) 1987-2018 Free Software Foundation, Inc.
Contributed by Per Bothner, 1994.
This program is free software; you can redistribute it and/or modify it
static unsigned int interpret_int_suffix (cpp_reader *, const uchar *, size_t);
static void check_promotion (cpp_reader *, const struct op *);
+static cpp_num parse_has_include (cpp_reader *, enum include_type);
+
/* Token type abuse to create unary plus and minus operators. */
#define CPP_UPLUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 1))
#define CPP_UMINUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 2))
/* 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. */
+ flag vector (of CPP_N_* bits) describing the suffix. */
static unsigned int
interpret_float_suffix (cpp_reader *pfile, const uchar *s, size_t len)
{
+ size_t orig_len = len;
+ const uchar *orig_s = s;
size_t flags;
- size_t f, d, l, w, q, i;
+ size_t f, d, l, w, q, i, fn, fnx, fn_bits;
flags = 0;
- f = d = l = w = q = i = 0;
+ f = d = l = w = q = i = fn = fnx = fn_bits = 0;
+
+ /* The following decimal float suffixes, from TR 24732:2009 and TS
+ 18661-2:2015, are supported:
+
+ df, DF - _Decimal32.
+ dd, DD - _Decimal64.
+ dl, DL - _Decimal128.
+
+ The dN and DN suffixes for _DecimalN, and dNx and DNx for
+ _DecimalNx, defined in TS 18661-3:2015, are not supported.
+
+ Fixed-point suffixes, from TR 18037:2008, are supported. They
+ consist of three parts, in order:
+
+ (i) An optional u or U, for unsigned types.
+
+ (ii) An optional h or H, for short types, or l or L, for long
+ types, or ll or LL, for long long types. Use of ll or LL is a
+ GNU extension.
+
+ (iii) r or R, for _Fract types, or k or K, for _Accum types.
+
+ Otherwise the suffix is for a binary or standard floating-point
+ type. Such a suffix, or the absence of a suffix, may be preceded
+ or followed by i, I, j or J, to indicate an imaginary number with
+ the corresponding complex type. The following suffixes for
+ binary or standard floating-point types are supported:
+
+ f, F - float (ISO C and C++).
+ l, L - long double (ISO C and C++).
+ d, D - double, even with the FLOAT_CONST_DECIMAL64 pragma in
+ operation (from TR 24732:2009; the pragma and the suffix
+ are not included in TS 18661-2:2015).
+ w, W - machine-specific type such as __float80 (GNU extension).
+ q, Q - machine-specific type such as __float128 (GNU extension).
+ fN, FN - _FloatN (TS 18661-3:2015).
+ fNx, FNx - _FloatNx (TS 18661-3:2015). */
/* Process decimal float suffixes, which are two letters starting
with d or D. Order and case are significant. */
/* In any remaining valid suffix, the case and order don't matter. */
while (len--)
- switch (s[len])
- {
- case 'f': case 'F': f++; break;
- case 'd': case 'D': d++; break;
- case 'l': case 'L': l++; break;
- case 'w': case 'W': w++; break;
- case 'q': case 'Q': q++; break;
- case 'i': case 'I':
- case 'j': case 'J': i++; break;
- default:
- return 0;
- }
+ {
+ switch (s[0])
+ {
+ case 'f': case 'F':
+ f++;
+ if (len > 0
+ && !CPP_OPTION (pfile, cplusplus)
+ && s[1] >= '1'
+ && s[1] <= '9'
+ && fn_bits == 0)
+ {
+ f--;
+ while (len > 0
+ && s[1] >= '0'
+ && s[1] <= '9'
+ && fn_bits < CPP_FLOATN_MAX)
+ {
+ fn_bits = fn_bits * 10 + (s[1] - '0');
+ len--;
+ s++;
+ }
+ if (len > 0 && s[1] == 'x')
+ {
+ fnx++;
+ len--;
+ s++;
+ }
+ else
+ fn++;
+ }
+ break;
+ case 'd': case 'D': d++; break;
+ case 'l': case 'L': l++; break;
+ case 'w': case 'W': w++; break;
+ case 'q': case 'Q': q++; break;
+ case 'i': case 'I':
+ case 'j': case 'J': i++; break;
+ default:
+ return 0;
+ }
+ s++;
+ }
- if (f + d + l + w + q > 1 || i > 1)
+ /* Reject any case of multiple suffixes specifying types, multiple
+ suffixes specifying an imaginary constant, _FloatN or _FloatNx
+ suffixes for invalid values of N, and _FloatN suffixes for values
+ of N larger than can be represented in the return value. The
+ caller is responsible for rejecting _FloatN suffixes where
+ _FloatN is not supported on the chosen target. */
+ if (f + d + l + w + q + fn + fnx > 1 || i > 1)
return 0;
-
- if (i && !CPP_OPTION (pfile, ext_numeric_literals))
+ if (fn_bits > CPP_FLOATN_MAX)
+ return 0;
+ if (fnx && fn_bits != 32 && fn_bits != 64 && fn_bits != 128)
+ return 0;
+ if (fn && fn_bits != 16 && fn_bits % 32 != 0)
+ return 0;
+ if (fn && fn_bits == 96)
return 0;
+ if (i)
+ {
+ if (!CPP_OPTION (pfile, ext_numeric_literals))
+ return 0;
+
+ /* In C++14 and up these suffixes are in the standard library, so treat
+ them as user-defined literals. */
+ if (CPP_OPTION (pfile, cplusplus)
+ && CPP_OPTION (pfile, lang) > CLK_CXX11
+ && orig_s[0] == 'i'
+ && (orig_len == 1
+ || (orig_len == 2
+ && (orig_s[1] == 'f' || orig_s[1] == 'l'))))
+ return 0;
+ }
+
if ((w || q) && !CPP_OPTION (pfile, ext_numeric_literals))
return 0;
d ? CPP_N_MEDIUM :
l ? CPP_N_LARGE :
w ? CPP_N_MD_W :
- q ? CPP_N_MD_Q : CPP_N_DEFAULT));
+ q ? CPP_N_MD_Q :
+ fn ? CPP_N_FLOATN | (fn_bits << CPP_FLOATN_SHIFT) :
+ fnx ? CPP_N_FLOATNX | (fn_bits << CPP_FLOATN_SHIFT) :
+ CPP_N_DEFAULT));
}
/* Return the classification flags for a float suffix. */
static unsigned int
interpret_int_suffix (cpp_reader *pfile, const uchar *s, size_t len)
{
+ size_t orig_len = len;
size_t u, l, i;
u = l = i = 0;
if (l > 2 || u > 1 || i > 1)
return 0;
- if (i && !CPP_OPTION (pfile, ext_numeric_literals))
- return 0;
+ if (i)
+ {
+ if (!CPP_OPTION (pfile, ext_numeric_literals))
+ return 0;
+
+ /* In C++14 and up these suffixes are in the standard library, so treat
+ them as user-defined literals. */
+ if (CPP_OPTION (pfile, cplusplus)
+ && CPP_OPTION (pfile, lang) > CLK_CXX11
+ && s[0] == 'i'
+ && (orig_len == 1 || (orig_len == 2 && s[1] == 'l')))
+ return 0;
+ }
return ((i ? CPP_N_IMAGINARY : 0)
| (u ? CPP_N_UNSIGNED : 0)
return CPP_CHAR16;
else if (type == CPP_CHAR32_USERDEF)
return CPP_CHAR32;
+ else if (type == CPP_UTF8CHAR_USERDEF)
+ return CPP_UTF8CHAR;
else
return type;
}
return CPP_CHAR16_USERDEF;
else if (type == CPP_CHAR32)
return CPP_CHAR32_USERDEF;
+ else if (type == CPP_UTF8CHAR)
+ return CPP_UTF8CHAR_USERDEF;
else
return type;
}
if (type == CPP_CHAR_USERDEF
|| type == CPP_WCHAR_USERDEF
|| type == CPP_CHAR16_USERDEF
- || type == CPP_CHAR32_USERDEF)
+ || type == CPP_CHAR32_USERDEF
+ || type == CPP_UTF8CHAR_USERDEF)
return true;
else
return false;
unsigned int max_digit, result, radix;
enum {NOT_FLOAT = 0, AFTER_POINT, AFTER_EXPON} float_flag;
bool seen_digit;
+ bool seen_digit_sep;
if (ud_suffix)
*ud_suffix = NULL;
max_digit = 0;
radix = 10;
seen_digit = false;
+ seen_digit_sep = false;
/* First, interpret the radix. */
if (*str == '0')
str++;
/* Require at least one hex digit to classify it as hex. */
- if ((*str == 'x' || *str == 'X')
- && (str[1] == '.' || ISXDIGIT (str[1])))
+ if (*str == 'x' || *str == 'X')
{
- radix = 16;
- str++;
+ if (str[1] == '.' || ISXDIGIT (str[1]))
+ {
+ radix = 16;
+ str++;
+ }
+ else if (DIGIT_SEP (str[1]))
+ SYNTAX_ERROR_AT (virtual_location,
+ "digit separator after base indicator");
}
- else if ((*str == 'b' || *str == 'B') && (str[1] == '0' || str[1] == '1'))
+ else if (*str == 'b' || *str == 'B')
{
- radix = 2;
- str++;
+ if (str[1] == '0' || str[1] == '1')
+ {
+ radix = 2;
+ str++;
+ }
+ else if (DIGIT_SEP (str[1]))
+ SYNTAX_ERROR_AT (virtual_location,
+ "digit separator after base indicator");
}
}
if (ISDIGIT (c) || (ISXDIGIT (c) && radix == 16))
{
+ seen_digit_sep = false;
seen_digit = true;
c = hex_value (c);
if (c > max_digit)
max_digit = c;
}
+ else if (DIGIT_SEP (c))
+ {
+ if (seen_digit_sep)
+ SYNTAX_ERROR_AT (virtual_location, "adjacent digit separators");
+ seen_digit_sep = true;
+ }
else if (c == '.')
{
+ if (seen_digit_sep || DIGIT_SEP (*str))
+ SYNTAX_ERROR_AT (virtual_location,
+ "digit separator adjacent to decimal point");
+ seen_digit_sep = false;
if (float_flag == NOT_FLOAT)
float_flag = AFTER_POINT;
else
else if ((radix <= 10 && (c == 'e' || c == 'E'))
|| (radix == 16 && (c == 'p' || c == 'P')))
{
+ if (seen_digit_sep || DIGIT_SEP (*str))
+ SYNTAX_ERROR_AT (virtual_location,
+ "digit separator adjacent to exponent");
float_flag = AFTER_EXPON;
break;
}
}
}
+ if (seen_digit_sep && float_flag != AFTER_EXPON)
+ SYNTAX_ERROR_AT (virtual_location,
+ "digit separator outside digit sequence");
+
/* The suffix may be for decimal fixed-point constants without exponent. */
if (radix != 16 && float_flag == NOT_FLOAT)
{
SYNTAX_ERROR_AT (virtual_location,
"no digits in hexadecimal floating constant");
- if (radix == 16 && CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, c99))
- cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
- "use of C99 hexadecimal floating constant");
+ if (radix == 16 && CPP_PEDANTIC (pfile)
+ && !CPP_OPTION (pfile, extended_numbers))
+ {
+ if (CPP_OPTION (pfile, cplusplus))
+ cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
+ "use of C++17 hexadecimal floating constant");
+ else
+ cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
+ "use of C99 hexadecimal floating constant");
+ }
if (float_flag == AFTER_EXPON)
{
/* Exponent is decimal, even if string is a hex float. */
if (!ISDIGIT (*str))
- SYNTAX_ERROR_AT (virtual_location, "exponent has no digits");
-
+ {
+ if (DIGIT_SEP (*str))
+ SYNTAX_ERROR_AT (virtual_location,
+ "digit separator adjacent to exponent");
+ else
+ SYNTAX_ERROR_AT (virtual_location, "exponent has no digits");
+ }
do
- str++;
- while (ISDIGIT (*str));
+ {
+ seen_digit_sep = DIGIT_SEP (*str);
+ str++;
+ }
+ while (ISDIGIT (*str) || DIGIT_SEP (*str));
}
else if (radix == 16)
SYNTAX_ERROR_AT (virtual_location,
"hexadecimal floating constants require an exponent");
+ if (seen_digit_sep)
+ SYNTAX_ERROR_AT (virtual_location,
+ "digit separator outside digit sequence");
+
result = interpret_float_suffix (pfile, str, limit - str);
if (result == 0)
{
&& CPP_PEDANTIC (pfile))
cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
CPP_OPTION (pfile, cplusplus)
- ? "binary constants are a C++1y feature "
- "or GCC extension"
- : "binary constants are a GCC extension");
+ ? N_("binary constants are a C++14 feature "
+ "or GCC extension")
+ : N_("binary constants are a GCC extension"));
if (radix == 10)
result |= CPP_N_DECIMAL;
if (ISDIGIT (c) || (base == 16 && ISXDIGIT (c)))
c = hex_value (c);
+ else if (DIGIT_SEP (c))
+ continue;
else
break;
if (node)
{
- if (pfile->context != initial_context && CPP_PEDANTIC (pfile))
- cpp_error (pfile, CPP_DL_WARNING,
- "this use of \"defined\" may not be portable");
+ if ((pfile->context != initial_context
+ || initial_context != &pfile->base_context)
+ && CPP_OPTION (pfile, warn_expansion_to_defined))
+ cpp_pedwarning (pfile, CPP_W_EXPANSION_TO_DEFINED,
+ "this use of \"defined\" may not be portable");
_cpp_mark_macro_used (node);
if (!(node->flags & NODE_USED))
case CPP_CHAR:
case CPP_CHAR16:
case CPP_CHAR32:
+ case CPP_UTF8CHAR:
{
cppchar_t cc = cpp_interpret_charconst (pfile, token,
&temp, &unsignedp);
case CPP_NAME:
if (token->val.node.node == pfile->spec_nodes.n_defined)
return parse_defined (pfile);
+ else if (token->val.node.node == pfile->spec_nodes.n__has_include__)
+ return parse_has_include (pfile, IT_INCLUDE);
+ else if (token->val.node.node == pfile->spec_nodes.n__has_include_next__)
+ return parse_has_include (pfile, IT_INCLUDE_NEXT);
else if (CPP_OPTION (pfile, cplusplus)
&& (token->val.node.node == pfile->spec_nodes.n_true
|| token->val.node.node == pfile->spec_nodes.n_false))
result.low = 0;
if (CPP_OPTION (pfile, warn_undef) && !pfile->state.skip_eval)
cpp_warning_with_line (pfile, CPP_W_UNDEF, virtual_location, 0,
- "\"%s\" is not defined",
+ "\"%s\" is not defined, evaluates to 0",
NODE_NAME (token->val.node.node));
}
break;
case CPP_WCHAR:
case CPP_CHAR16:
case CPP_CHAR32:
+ case CPP_UTF8CHAR:
case CPP_NAME:
case CPP_HASH:
if (!want_value)
/* Arithmetic. */
case CPP_MINUS:
- rhs = num_negate (rhs, precision);
+ result.low = lhs.low - rhs.low;
+ result.high = lhs.high - rhs.high;
+ if (result.low > lhs.low)
+ result.high--;
+ result.unsignedp = lhs.unsignedp || rhs.unsignedp;
+ result.overflow = false;
+
+ result = num_trim (result, precision);
+ if (!result.unsignedp)
+ {
+ bool lhsp = num_positive (lhs, precision);
+ result.overflow = (lhsp != num_positive (rhs, precision)
+ && lhsp != num_positive (result, precision));
+ }
+ return result;
+
case CPP_PLUS:
result.low = lhs.low + rhs.low;
result.high = lhs.high + rhs.high;
default: /* case CPP_COMMA: */
if (CPP_PEDANTIC (pfile) && (!CPP_OPTION (pfile, c99)
|| !pfile->state.skip_eval))
- cpp_error (pfile, CPP_DL_PEDWARN,
- "comma operator in operand of #if");
+ cpp_pedwarning (pfile, CPP_W_PEDANTIC,
+ "comma operator in operand of #if");
lhs = rhs;
break;
}
return lhs;
}
+
+/* Handle meeting "__has_include__" in a preprocessor expression. */
+static cpp_num
+parse_has_include (cpp_reader *pfile, enum include_type type)
+{
+ cpp_num result;
+ bool paren = false;
+ cpp_hashnode *node = 0;
+ const cpp_token *token;
+ bool bracket = false;
+ char *fname = 0;
+
+ result.unsignedp = false;
+ result.high = 0;
+ result.overflow = false;
+ result.low = 0;
+
+ pfile->state.in__has_include__++;
+
+ token = cpp_get_token (pfile);
+ if (token->type == CPP_OPEN_PAREN)
+ {
+ paren = true;
+ token = cpp_get_token (pfile);
+ }
+
+ if (token->type == CPP_STRING || token->type == CPP_HEADER_NAME)
+ {
+ if (token->type == CPP_HEADER_NAME)
+ bracket = true;
+ fname = XNEWVEC (char, token->val.str.len - 1);
+ memcpy (fname, token->val.str.text + 1, token->val.str.len - 2);
+ fname[token->val.str.len - 2] = '\0';
+ node = token->val.node.node;
+ }
+ else if (token->type == CPP_LESS)
+ {
+ bracket = true;
+ fname = _cpp_bracket_include (pfile);
+ }
+ else
+ cpp_error (pfile, CPP_DL_ERROR,
+ "operator \"__has_include__\" requires a header string");
+
+ if (fname)
+ {
+ int angle_brackets = (bracket ? 1 : 0);
+
+ if (_cpp_has_header (pfile, fname, angle_brackets, type))
+ result.low = 1;
+ else
+ result.low = 0;
+
+ XDELETEVEC (fname);
+ }
+
+ if (paren && cpp_get_token (pfile)->type != CPP_CLOSE_PAREN)
+ cpp_error (pfile, CPP_DL_ERROR,
+ "missing ')' after \"__has_include__\"");
+
+ /* A possible controlling macro of the form #if !__has_include__ ().
+ _cpp_parse_expr checks there was no other junk on the line. */
+ if (node)
+ pfile->mi_ind_cmacro = node;
+
+ pfile->state.in__has_include__--;
+
+ return result;
+}
projects / thirdparty / gcc.git / blobdiff