summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorkan <kan@FreeBSD.org>2003-07-11 04:49:30 +0000
committerkan <kan@FreeBSD.org>2003-07-11 04:49:30 +0000
commit50259c63c1059e9ef5011b1ff72a9f6dd5366f95 (patch)
treea158d40bd3ab1c16e985508b76532d9409c28abe
parent3af246c7f23c2d1ef9c0c5835c056f851436974c (diff)
downloadFreeBSD-src-50259c63c1059e9ef5011b1ff72a9f6dd5366f95.zip
FreeBSD-src-50259c63c1059e9ef5011b1ff72a9f6dd5366f95.tar.gz
Merge FreeBSD modifications into gcc 3.3.1-prerelease:
1.2 don't let gcc(1) hide warnings in system headers.
-rw-r--r--contrib/gcc/c-lex.c856
1 files changed, 243 insertions, 613 deletions
diff --git a/contrib/gcc/c-lex.c b/contrib/gcc/c-lex.c
index 3659872..30f89ab 100644
--- a/contrib/gcc/c-lex.c
+++ b/contrib/gcc/c-lex.c
@@ -1,6 +1,6 @@
-/* Lexical analyzer for C and Objective C.
+/* Mainly the interface between cpplib and the C front ends.
Copyright (C) 1987, 1988, 1989, 1992, 1994, 1995, 1996, 1997
- 1998, 1999, 2000 Free Software Foundation, Inc.
+ 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
This file is part of GCC.
@@ -24,13 +24,14 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
#include "config.h"
#include "system.h"
+#include "real.h"
#include "rtl.h"
#include "tree.h"
#include "expr.h"
#include "input.h"
#include "output.h"
-#include "c-lex.h"
#include "c-tree.h"
+#include "c-common.h"
#include "flags.h"
#include "timevar.h"
#include "cpplib.h"
@@ -41,20 +42,10 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
#include "splay-tree.h"
#include "debug.h"
-/* MULTIBYTE_CHARS support only works for native compilers.
- ??? Ideally what we want is to model widechar support after
- the current floating point support. */
-#ifdef CROSS_COMPILE
-#undef MULTIBYTE_CHARS
-#endif
-
#ifdef MULTIBYTE_CHARS
#include "mbchar.h"
#include <locale.h>
#endif /* MULTIBYTE_CHARS */
-#ifndef GET_ENVIRONMENT
-#define GET_ENVIRONMENT(ENV_VALUE,ENV_NAME) ((ENV_VALUE) = getenv (ENV_NAME))
-#endif
/* The current line map. */
static const struct line_map *map;
@@ -66,9 +57,6 @@ static unsigned int src_lineno;
static int header_time, body_time;
static splay_tree file_info_tree;
-/* Cause the `yydebug' variable to be defined. */
-#define YYDEBUG 1
-
/* File used for outputting assembler code. */
extern FILE *asm_out_file;
@@ -78,15 +66,18 @@ extern FILE *asm_out_file;
/* Number of bytes in a wide character. */
#define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
-int indent_level; /* Number of { minus number of }. */
int pending_lang_change; /* If we need to switch languages - C++ only */
int c_header_level; /* depth in C headers - C++ only */
/* Nonzero tells yylex to ignore \ in string constants. */
static int ignore_escape_flag;
-static void parse_float PARAMS ((PTR));
-static tree lex_number PARAMS ((const char *, unsigned int));
+static tree interpret_integer PARAMS ((const cpp_token *, unsigned int));
+static tree interpret_float PARAMS ((const cpp_token *, unsigned int));
+static enum integer_type_kind
+ narrowest_unsigned_type PARAMS ((tree, unsigned int));
+static enum integer_type_kind
+ narrowest_signed_type PARAMS ((tree, unsigned int));
static tree lex_string PARAMS ((const unsigned char *, unsigned int,
int));
static tree lex_charconst PARAMS ((const cpp_token *));
@@ -146,9 +137,6 @@ init_c_lex (filename)
/* Start it at 0. */
lineno = 0;
- if (filename == NULL || !strcmp (filename, "-"))
- filename = "";
-
return cpp_read_main_file (parse_in, filename, ident_hash);
}
@@ -157,13 +145,21 @@ init_c_lex (filename)
Also, make sure the start_source_file debug hook gets called for
the primary source file. */
-int
-yyparse()
+void
+c_common_parse_file (set_yydebug)
+ int set_yydebug ATTRIBUTE_UNUSED;
{
+#if YYDEBUG != 0
+ yydebug = set_yydebug;
+#else
+ warning ("YYDEBUG not defined");
+#endif
+
(*debug_hooks->start_source_file) (lineno, input_filename);
cpp_finish_options (parse_in);
- return yyparse_1();
+ yyparse ();
+ free_parser_stacks ();
}
struct c_fileinfo *
@@ -229,9 +225,6 @@ dump_time_statistics ()
splay_tree_foreach (file_info_tree, dump_one_header, 0);
}
-/* Not yet handled: #pragma, #define, #undef.
- No need to deal with linemarkers under normal conditions. */
-
static void
cb_ident (pfile, line, str)
cpp_reader *pfile ATTRIBUTE_UNUSED;
@@ -278,7 +271,6 @@ cb_file_change (pfile, new_map)
lineno = included_at;
push_srcloc (new_map->to_file, 1);
- input_file_stack->indent_level = indent_level;
(*debug_hooks->start_source_file) (included_at, new_map->to_file);
#ifndef NO_IMPLICIT_EXTERN_C
if (c_header_level)
@@ -301,16 +293,6 @@ cb_file_change (pfile, new_map)
--pending_lang_change;
}
#endif
-#if 0
- if (indent_level != input_file_stack->indent_level)
- {
- warning_with_file_and_line
- (input_filename, lineno,
- "this file contains more '%c's than '%c's",
- indent_level > input_file_stack->indent_level ? '{' : '}',
- indent_level > input_file_stack->indent_level ? '}' : '{');
- }
-#endif
pop_srcloc ();
(*debug_hooks->end_source_file) (to_line);
@@ -688,88 +670,7 @@ utf8_extend_token (c)
while (shift);
}
#endif
-
-#if 0
-struct try_type
-{
- tree *const node_var;
- const char unsigned_flag;
- const char long_flag;
- const char long_long_flag;
-};
-
-struct try_type type_sequence[] =
-{
- { &integer_type_node, 0, 0, 0},
- { &unsigned_type_node, 1, 0, 0},
- { &long_integer_type_node, 0, 1, 0},
- { &long_unsigned_type_node, 1, 1, 0},
- { &long_long_integer_type_node, 0, 1, 1},
- { &long_long_unsigned_type_node, 1, 1, 1}
-};
-#endif /* 0 */
-struct pf_args
-{
- /* Input */
- const char *str;
- int fflag;
- int lflag;
- int base;
- /* Output */
- int conversion_errno;
- REAL_VALUE_TYPE value;
- tree type;
-};
-
-static void
-parse_float (data)
- PTR data;
-{
- struct pf_args * args = (struct pf_args *) data;
- const char *typename;
-
- args->conversion_errno = 0;
- args->type = double_type_node;
- typename = "double";
-
- /* The second argument, machine_mode, of REAL_VALUE_ATOF
- tells the desired precision of the binary result
- of decimal-to-binary conversion. */
-
- if (args->fflag)
- {
- if (args->lflag)
- error ("both 'f' and 'l' suffixes on floating constant");
-
- args->type = float_type_node;
- typename = "float";
- }
- else if (args->lflag)
- {
- args->type = long_double_type_node;
- typename = "long double";
- }
- else if (flag_single_precision_constant)
- {
- args->type = float_type_node;
- typename = "float";
- }
-
- errno = 0;
- if (args->base == 16)
- args->value = REAL_VALUE_HTOF (args->str, TYPE_MODE (args->type));
- else
- args->value = REAL_VALUE_ATOF (args->str, TYPE_MODE (args->type));
-
- args->conversion_errno = errno;
- /* A diagnostic is required here by some ISO C testsuites.
- This is not pedwarn, because some people don't want
- an error for this. */
- if (REAL_VALUE_ISINF (args->value) && pedantic)
- warning ("floating point number exceeds range of '%s'", typename);
-}
-
int
c_lex (value)
tree *value;
@@ -791,9 +692,6 @@ c_lex (value)
*value = NULL_TREE;
switch (tok->type)
{
- case CPP_OPEN_BRACE: indent_level++; break;
- case CPP_CLOSE_BRACE: indent_level--; break;
-
/* Issue this error here, where we can get at tok->val.c. */
case CPP_OTHER:
if (ISGRAPH (tok->val.c))
@@ -807,7 +705,28 @@ c_lex (value)
break;
case CPP_NUMBER:
- *value = lex_number ((const char *)tok->val.str.text, tok->val.str.len);
+ {
+ unsigned int flags = cpp_classify_number (parse_in, tok);
+
+ switch (flags & CPP_N_CATEGORY)
+ {
+ case CPP_N_INVALID:
+ /* cpplib has issued an error. */
+ *value = error_mark_node;
+ break;
+
+ case CPP_N_INTEGER:
+ *value = interpret_integer (tok, flags);
+ break;
+
+ case CPP_N_FLOATING:
+ *value = interpret_float (tok, flags);
+ break;
+
+ default:
+ abort ();
+ }
+ }
break;
case CPP_CHAR:
@@ -833,476 +752,203 @@ c_lex (value)
return tok->type;
}
-#define ERROR(msgid) do { error(msgid); goto syntax_error; } while(0)
-
-static tree
-lex_number (str, len)
- const char *str;
- unsigned int len;
+/* Returns the narrowest C-visible unsigned type, starting with the
+ minimum specified by FLAGS, that can fit VALUE, or itk_none if
+ there isn't one. */
+static enum integer_type_kind
+narrowest_unsigned_type (value, flags)
+ tree value;
+ unsigned int flags;
{
- int base = 10;
- int count = 0;
- int largest_digit = 0;
- int numdigits = 0;
- int overflow = 0;
- int c;
- tree value;
- const char *p;
- enum anon1 { NOT_FLOAT = 0, AFTER_POINT, AFTER_EXPON } floatflag = NOT_FLOAT;
-
- /* We actually store only HOST_BITS_PER_CHAR bits in each part.
- The code below which fills the parts array assumes that a host
- int is at least twice as wide as a host char, and that
- HOST_BITS_PER_WIDE_INT is an even multiple of HOST_BITS_PER_CHAR.
- Two HOST_WIDE_INTs is the largest int literal we can store.
- In order to detect overflow below, the number of parts (TOTAL_PARTS)
- must be exactly the number of parts needed to hold the bits
- of two HOST_WIDE_INTs. */
-#define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2)
- unsigned int parts[TOTAL_PARTS];
-
- /* Optimize for most frequent case. */
- if (len == 1)
- {
- if (*str == '0')
- return integer_zero_node;
- else if (*str == '1')
- return integer_one_node;
- else
- return build_int_2 (*str - '0', 0);
- }
+ enum integer_type_kind itk;
- for (count = 0; count < TOTAL_PARTS; count++)
- parts[count] = 0;
-
- /* len is known to be >1 at this point. */
- p = str;
-
- if (len > 2 && str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
- {
- base = 16;
- p = str + 2;
- }
- /* The ISDIGIT check is so we are not confused by a suffix on 0. */
- else if (str[0] == '0' && ISDIGIT (str[1]))
- {
- base = 8;
- p = str + 1;
- }
-
- do
- {
- c = *p++;
-
- if (c == '.')
- {
- if (floatflag == AFTER_POINT)
- ERROR ("too many decimal points in floating constant");
- else if (floatflag == AFTER_EXPON)
- ERROR ("decimal point in exponent - impossible!");
- else
- floatflag = AFTER_POINT;
-
- if (base == 8)
- base = 10;
- }
- else if (c == '_')
- /* Possible future extension: silently ignore _ in numbers,
- permitting cosmetic grouping - e.g. 0x8000_0000 == 0x80000000
- but somewhat easier to read. Ada has this? */
- ERROR ("underscore in number");
- else
- {
- int n;
- /* It is not a decimal point.
- It should be a digit (perhaps a hex digit). */
-
- if (ISDIGIT (c)
- || (base == 16 && ISXDIGIT (c)))
- {
- n = hex_value (c);
- }
- else if (base <= 10 && (c == 'e' || c == 'E'))
- {
- base = 10;
- floatflag = AFTER_EXPON;
- break;
- }
- else if (base == 16 && (c == 'p' || c == 'P'))
- {
- floatflag = AFTER_EXPON;
- break; /* start of exponent */
- }
- else
- {
- p--;
- break; /* start of suffix */
- }
-
- if (n >= largest_digit)
- largest_digit = n;
- numdigits++;
-
- for (count = 0; count < TOTAL_PARTS; count++)
- {
- parts[count] *= base;
- if (count)
- {
- parts[count]
- += (parts[count-1] >> HOST_BITS_PER_CHAR);
- parts[count-1]
- &= (1 << HOST_BITS_PER_CHAR) - 1;
- }
- else
- parts[0] += n;
- }
-
- /* If the highest-order part overflows (gets larger than
- a host char will hold) then the whole number has
- overflowed. Record this and truncate the highest-order
- part. */
- if (parts[TOTAL_PARTS - 1] >> HOST_BITS_PER_CHAR)
- {
- overflow = 1;
- parts[TOTAL_PARTS - 1] &= (1 << HOST_BITS_PER_CHAR) - 1;
- }
- }
- }
- while (p < str + len);
-
- /* This can happen on input like `int i = 0x;' */
- if (numdigits == 0)
- ERROR ("numeric constant with no digits");
-
- if (largest_digit >= base)
- ERROR ("numeric constant contains digits beyond the radix");
-
- if (floatflag != NOT_FLOAT)
- {
- tree type;
- int imag, fflag, lflag, conversion_errno;
- REAL_VALUE_TYPE real;
- struct pf_args args;
- char *copy;
-
- if (base == 16 && pedantic && !flag_isoc99)
- pedwarn ("floating constant may not be in radix 16");
-
- if (base == 16 && floatflag != AFTER_EXPON)
- ERROR ("hexadecimal floating constant has no exponent");
-
- /* Read explicit exponent if any, and put it in tokenbuf. */
- if ((base == 10 && ((c == 'e') || (c == 'E')))
- || (base == 16 && (c == 'p' || c == 'P')))
- {
- if (p < str + len)
- c = *p++;
- if (p < str + len && (c == '+' || c == '-'))
- c = *p++;
- /* Exponent is decimal, even if string is a hex float. */
- if (! ISDIGIT (c))
- ERROR ("floating constant exponent has no digits");
- while (p < str + len && ISDIGIT (c))
- c = *p++;
- if (! ISDIGIT (c))
- p--;
- }
+ if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
+ itk = itk_unsigned_int;
+ else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
+ itk = itk_unsigned_long;
+ else
+ itk = itk_unsigned_long_long;
- /* Copy the float constant now; we don't want any suffixes in the
- string passed to parse_float. */
- copy = alloca (p - str + 1);
- memcpy (copy, str, p - str);
- copy[p - str] = '\0';
+ /* int_fits_type_p must think the type of its first argument is
+ wider than its second argument, or it won't do the proper check. */
+ TREE_TYPE (value) = widest_unsigned_literal_type_node;
- /* Now parse suffixes. */
- fflag = lflag = imag = 0;
- while (p < str + len)
- switch (*p++)
- {
- case 'f': case 'F':
- if (fflag)
- ERROR ("more than one 'f' suffix on floating constant");
- else if (warn_traditional && !in_system_header
- && ! cpp_sys_macro_p (parse_in))
- warning ("traditional C rejects the 'f' suffix");
-
- fflag = 1;
- break;
+ for (; itk < itk_none; itk += 2 /* skip unsigned types */)
+ if (int_fits_type_p (value, integer_types[itk]))
+ return itk;
- case 'l': case 'L':
- if (lflag)
- ERROR ("more than one 'l' suffix on floating constant");
- else if (warn_traditional && !in_system_header
- && ! cpp_sys_macro_p (parse_in))
- warning ("traditional C rejects the 'l' suffix");
+ return itk_none;
+}
- lflag = 1;
- break;
+/* Ditto, but narrowest signed type. */
+static enum integer_type_kind
+narrowest_signed_type (value, flags)
+ tree value;
+ unsigned int flags;
+{
+ enum integer_type_kind itk;
- case 'i': case 'I':
- case 'j': case 'J':
- if (imag)
- ERROR ("more than one 'i' or 'j' suffix on floating constant");
- else if (pedantic)
- pedwarn ("ISO C forbids imaginary numeric constants");
- imag = 1;
- break;
+ if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
+ itk = itk_int;
+ else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
+ itk = itk_long;
+ else
+ itk = itk_long_long;
- default:
- ERROR ("invalid suffix on floating constant");
- }
+ /* int_fits_type_p must think the type of its first argument is
+ wider than its second argument, or it won't do the proper check. */
+ TREE_TYPE (value) = widest_unsigned_literal_type_node;
- /* Setup input for parse_float() */
- args.str = copy;
- args.fflag = fflag;
- args.lflag = lflag;
- args.base = base;
+ for (; itk < itk_none; itk += 2 /* skip signed types */)
+ if (int_fits_type_p (value, integer_types[itk]))
+ return itk;
- /* Convert string to a double, checking for overflow. */
- if (do_float_handler (parse_float, (PTR) &args))
- {
- /* Receive output from parse_float() */
- real = args.value;
- }
- else
- /* We got an exception from parse_float() */
- ERROR ("floating constant out of range");
-
- /* Receive output from parse_float() */
- conversion_errno = args.conversion_errno;
- type = args.type;
-
-#ifdef ERANGE
- /* ERANGE is also reported for underflow,
- so test the value to distinguish overflow from that. */
- if (conversion_errno == ERANGE && !flag_traditional && pedantic
- && (REAL_VALUES_LESS (dconst1, real)
- || REAL_VALUES_LESS (real, dconstm1)))
- warning ("floating point number exceeds range of 'double'");
-#endif
+ return itk_none;
+}
- /* Create a node with determined type and value. */
- if (imag)
- value = build_complex (NULL_TREE, convert (type, integer_zero_node),
- build_real (type, real));
- else
- value = build_real (type, real);
- }
+/* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
+static tree
+interpret_integer (token, flags)
+ const cpp_token *token;
+ unsigned int flags;
+{
+ tree value, type;
+ enum integer_type_kind itk;
+ cpp_num integer;
+ cpp_options *options = cpp_get_options (parse_in);
+
+ integer = cpp_interpret_integer (parse_in, token, flags);
+ integer = cpp_num_sign_extend (integer, options->precision);
+ value = build_int_2_wide (integer.low, integer.high);
+
+ /* The type of a constant with a U suffix is straightforward. */
+ if (flags & CPP_N_UNSIGNED)
+ itk = narrowest_unsigned_type (value, flags);
else
{
- tree trad_type, ansi_type, type;
- HOST_WIDE_INT high, low;
- int spec_unsigned = 0;
- int spec_long = 0;
- int spec_long_long = 0;
- int spec_imag = 0;
- int suffix_lu = 0;
- int warn = 0, i;
-
- trad_type = ansi_type = type = NULL_TREE;
- while (p < str + len)
+ /* The type of a potentially-signed integer constant varies
+ depending on the base it's in, the standard in use, and the
+ length suffixes. */
+ enum integer_type_kind itk_u = narrowest_unsigned_type (value, flags);
+ enum integer_type_kind itk_s = narrowest_signed_type (value, flags);
+
+ /* In both C89 and C99, octal and hex constants may be signed or
+ unsigned, whichever fits tighter. We do not warn about this
+ choice differing from the traditional choice, as the constant
+ is probably a bit pattern and either way will work. */
+ if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
+ itk = MIN (itk_u, itk_s);
+ else
{
- c = *p++;
- switch (c)
+ /* In C99, decimal constants are always signed.
+ In C89, decimal constants that don't fit in long have
+ undefined behavior; we try to make them unsigned long.
+ In GCC's extended C89, that last is true of decimal
+ constants that don't fit in long long, too. */
+
+ itk = itk_s;
+ if (itk_s > itk_u && itk_s > itk_long)
{
- case 'u': case 'U':
- if (spec_unsigned)
- error ("two 'u' suffixes on integer constant");
- else if (warn_traditional && !in_system_header
- && ! cpp_sys_macro_p (parse_in))
- warning ("traditional C rejects the 'u' suffix");
-
- spec_unsigned = 1;
- if (spec_long)
- suffix_lu = 1;
- break;
-
- case 'l': case 'L':
- if (spec_long)
+ if (!flag_isoc99)
{
- if (spec_long_long)
- error ("three 'l' suffixes on integer constant");
- else if (suffix_lu)
- error ("'lul' is not a valid integer suffix");
- else if (c != spec_long)
- error ("'Ll' and 'lL' are not valid integer suffixes");
- else if (pedantic && ! flag_isoc99
- && ! in_system_header && warn_long_long)
- pedwarn ("ISO C89 forbids long long integer constants");
- spec_long_long = 1;
+ if (itk_u < itk_unsigned_long)
+ itk_u = itk_unsigned_long;
+ itk = itk_u;
+ warning ("this decimal constant is unsigned only in ISO C90");
}
- spec_long = c;
- break;
-
- case 'i': case 'I': case 'j': case 'J':
- if (spec_imag)
- error ("more than one 'i' or 'j' suffix on integer constant");
- else if (pedantic)
- pedwarn ("ISO C forbids imaginary numeric constants");
- spec_imag = 1;
- break;
-
- default:
- ERROR ("invalid suffix on integer constant");
+ else if (warn_traditional)
+ warning ("this decimal constant would be unsigned in ISO C90");
}
}
+ }
- /* If the literal overflowed, pedwarn about it now. */
- if (overflow)
- {
- warn = 1;
- pedwarn ("integer constant is too large for this configuration of the compiler - truncated to %d bits", HOST_BITS_PER_WIDE_INT * 2);
- }
-
- /* This is simplified by the fact that our constant
- is always positive. */
-
- high = low = 0;
-
- for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; i++)
- {
- high |= ((HOST_WIDE_INT) parts[i + (HOST_BITS_PER_WIDE_INT
- / HOST_BITS_PER_CHAR)]
- << (i * HOST_BITS_PER_CHAR));
- low |= (HOST_WIDE_INT) parts[i] << (i * HOST_BITS_PER_CHAR);
- }
-
- value = build_int_2 (low, high);
- TREE_TYPE (value) = long_long_unsigned_type_node;
-
- /* If warn_traditional, calculate both the ISO type and the
- traditional type, then see if they disagree.
- Otherwise, calculate only the type for the dialect in use. */
- if (warn_traditional || flag_traditional)
- {
- /* Calculate the traditional type. */
- /* Traditionally, any constant is signed; but if unsigned is
- specified explicitly, obey that. Use the smallest size
- with the right number of bits, except for one special
- case with decimal constants. */
- if (! spec_long && base != 10
- && int_fits_type_p (value, unsigned_type_node))
- trad_type = spec_unsigned ? unsigned_type_node : integer_type_node;
- /* A decimal constant must be long if it does not fit in
- type int. I think this is independent of whether the
- constant is signed. */
- else if (! spec_long && base == 10
- && int_fits_type_p (value, integer_type_node))
- trad_type = spec_unsigned ? unsigned_type_node : integer_type_node;
- else if (! spec_long_long)
- trad_type = (spec_unsigned
- ? long_unsigned_type_node
- : long_integer_type_node);
- else if (int_fits_type_p (value,
- spec_unsigned
- ? long_long_unsigned_type_node
- : long_long_integer_type_node))
- trad_type = (spec_unsigned
- ? long_long_unsigned_type_node
- : long_long_integer_type_node);
- else
- trad_type = (spec_unsigned
- ? widest_unsigned_literal_type_node
- : widest_integer_literal_type_node);
- }
- if (warn_traditional || ! flag_traditional)
- {
- /* Calculate the ISO type. */
- if (! spec_long && ! spec_unsigned
- && int_fits_type_p (value, integer_type_node))
- ansi_type = integer_type_node;
- else if (! spec_long && (base != 10 || spec_unsigned)
- && int_fits_type_p (value, unsigned_type_node))
- ansi_type = unsigned_type_node;
- else if (! spec_unsigned && !spec_long_long
- && int_fits_type_p (value, long_integer_type_node))
- ansi_type = long_integer_type_node;
- else if (! spec_long_long
- && int_fits_type_p (value, long_unsigned_type_node))
- ansi_type = long_unsigned_type_node;
- else if (! spec_unsigned
- && int_fits_type_p (value, long_long_integer_type_node))
- ansi_type = long_long_integer_type_node;
- else if (int_fits_type_p (value, long_long_unsigned_type_node))
- ansi_type = long_long_unsigned_type_node;
- else if (! spec_unsigned
- && int_fits_type_p (value, widest_integer_literal_type_node))
- ansi_type = widest_integer_literal_type_node;
- else
- ansi_type = widest_unsigned_literal_type_node;
- }
-
- type = flag_traditional ? trad_type : ansi_type;
+ if (itk == itk_none)
+ /* cpplib has already issued a warning for overflow. */
+ type = ((flags & CPP_N_UNSIGNED)
+ ? widest_unsigned_literal_type_node
+ : widest_integer_literal_type_node);
+ else
+ type = integer_types[itk];
- /* We assume that constants specified in a non-decimal
- base are bit patterns, and that the programmer really
- meant what they wrote. */
- if (warn_traditional && !in_system_header
- && base == 10 && trad_type != ansi_type)
- {
- if (TYPE_PRECISION (trad_type) != TYPE_PRECISION (ansi_type))
- warning ("width of integer constant changes with -traditional");
- else if (TREE_UNSIGNED (trad_type) != TREE_UNSIGNED (ansi_type))
- warning ("integer constant is unsigned in ISO C, signed with -traditional");
- else
- warning ("width of integer constant may change on other systems with -traditional");
- }
+ if (itk > itk_unsigned_long
+ && (flags & CPP_N_WIDTH) != CPP_N_LARGE
+ && ! in_system_header && ! flag_isoc99)
+ pedwarn ("integer constant is too large for \"%s\" type",
+ (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
- if (pedantic && !flag_traditional && (flag_isoc99 || !spec_long_long)
- && !warn
- && ((flag_isoc99
- ? TYPE_PRECISION (long_long_integer_type_node)
- : TYPE_PRECISION (long_integer_type_node)) < TYPE_PRECISION (type)))
- {
- warn = 1;
- pedwarn ("integer constant larger than the maximum value of %s",
- (flag_isoc99
- ? (TREE_UNSIGNED (type)
- ? _("an unsigned long long int")
- : _("a long long int"))
- : _("an unsigned long int")));
- }
+ TREE_TYPE (value) = type;
- if (base == 10 && ! spec_unsigned && TREE_UNSIGNED (type))
- warning ("decimal constant is so large that it is unsigned");
+ /* Convert imaginary to a complex type. */
+ if (flags & CPP_N_IMAGINARY)
+ value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
- if (spec_imag)
- {
- if (TYPE_PRECISION (type)
- <= TYPE_PRECISION (integer_type_node))
- value = build_complex (NULL_TREE, integer_zero_node,
- convert (integer_type_node, value));
- else
- ERROR ("complex integer constant is too wide for 'complex int'");
- }
- else if (flag_traditional && !int_fits_type_p (value, type))
- /* The traditional constant 0x80000000 is signed
- but doesn't fit in the range of int.
- This will change it to -0x80000000, which does fit. */
- {
- TREE_TYPE (value) = unsigned_type (type);
- value = convert (type, value);
- TREE_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (value) = 0;
- }
- else
- TREE_TYPE (value) = type;
+ return value;
+}
- /* If it's still an integer (not a complex), and it doesn't
- fit in the type we choose for it, then pedwarn. */
+/* Interpret TOKEN, a floating point number with FLAGS as classified
+ by cpplib. */
+static tree
+interpret_float (token, flags)
+ const cpp_token *token;
+ unsigned int flags;
+{
+ tree type;
+ tree value;
+ REAL_VALUE_TYPE real;
+ char *copy;
+ size_t copylen;
+ const char *typename;
- if (! warn
- && TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
- && ! int_fits_type_p (value, TREE_TYPE (value)))
- pedwarn ("integer constant is larger than the maximum value for its type");
+ /* FIXME: make %T work in error/warning, then we don't need typename. */
+ if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
+ {
+ type = long_double_type_node;
+ typename = "long double";
+ }
+ else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
+ || flag_single_precision_constant)
+ {
+ type = float_type_node;
+ typename = "float";
+ }
+ else
+ {
+ type = double_type_node;
+ typename = "double";
}
- if (p < str + len)
- error ("missing white space after number '%.*s'", (int) (p - str), str);
+ /* Copy the constant to a nul-terminated buffer. If the constant
+ has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
+ can't handle them. */
+ copylen = token->val.str.len;
+ if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
+ /* Must be an F or L suffix. */
+ copylen--;
+ if (flags & CPP_N_IMAGINARY)
+ /* I or J suffix. */
+ copylen--;
+
+ copy = alloca (copylen + 1);
+ memcpy (copy, token->val.str.text, copylen);
+ copy[copylen] = '\0';
+
+ real_from_string (&real, copy);
+ real_convert (&real, TYPE_MODE (type), &real);
+
+ /* A diagnostic is required for "soft" overflow by some ISO C
+ testsuites. This is not pedwarn, because some people don't want
+ an error for this.
+ ??? That's a dubious reason... is this a mandatory diagnostic or
+ isn't it? -- zw, 2001-08-21. */
+ if (REAL_VALUE_ISINF (real) && pedantic)
+ warning ("floating constant exceeds range of \"%s\"", typename);
+
+ /* Create a node with determined type and value. */
+ value = build_real (type, real);
+ if (flags & CPP_N_IMAGINARY)
+ value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
return value;
-
- syntax_error:
- return integer_zero_node;
}
static tree
@@ -1315,9 +961,7 @@ lex_string (str, len, wide)
char *buf = alloca ((len + 1) * (wide ? WCHAR_BYTES : 1));
char *q = buf;
const unsigned char *p = str, *limit = str + len;
- unsigned int c;
- unsigned width = wide ? WCHAR_TYPE_SIZE
- : TYPE_PRECISION (char_type_node);
+ cppchar_t c;
#ifdef MULTIBYTE_CHARS
/* Reset multibyte conversion state. */
@@ -1347,19 +991,10 @@ lex_string (str, len, wide)
#endif
if (c == '\\' && !ignore_escape_flag)
- {
- unsigned int mask;
-
- if (width < HOST_BITS_PER_INT)
- mask = ((unsigned int) 1 << width) - 1;
- else
- mask = ~0;
- c = cpp_parse_escape (parse_in, &p, limit,
- mask, flag_traditional);
- }
+ c = cpp_parse_escape (parse_in, &p, limit, wide);
- /* Add this single character into the buffer either as a wchar_t
- or as a single byte. */
+ /* Add this single character into the buffer either as a wchar_t,
+ a multibyte sequence, or as a single byte. */
if (wide)
{
unsigned charwidth = TYPE_PRECISION (char_type_node);
@@ -1380,6 +1015,16 @@ lex_string (str, len, wide)
}
q += WCHAR_BYTES;
}
+#ifdef MULTIBYTE_CHARS
+ else if (char_len > 1)
+ {
+ /* We're dealing with a multibyte character. */
+ for ( ; char_len >0; --char_len)
+ {
+ *q++ = *(p - char_len);
+ }
+ }
+#endif
else
{
*q++ = c;
@@ -1413,45 +1058,30 @@ static tree
lex_charconst (token)
const cpp_token *token;
{
- HOST_WIDE_INT result;
+ cppchar_t result;
tree type, value;
unsigned int chars_seen;
-
- result = cpp_interpret_charconst (parse_in, token, warn_multichar,
- flag_traditional, &chars_seen);
- if (token->type == CPP_WCHAR)
- {
- value = build_int_2 (result, 0);
- type = wchar_type_node;
- }
- else
- {
- if (result < 0)
- value = build_int_2 (result, -1);
- else
- value = build_int_2 (result, 0);
-
- /* In C, a character constant has type 'int'.
- In C++ 'char', but multi-char charconsts have type 'int'. */
- if (c_language == clk_cplusplus && chars_seen <= 1)
- type = char_type_node;
- else
- type = integer_type_node;
- }
+ int unsignedp;
- /* cpp_interpret_charconst issues a warning if the constant
- overflows, but if the number fits in HOST_WIDE_INT anyway, it
- will return it un-truncated, which may cause problems down the
- line. So set the type to widest_integer_literal_type, call
- convert to truncate it to the proper type, then clear
- TREE_OVERFLOW so we don't get a second warning.
+ result = cpp_interpret_charconst (parse_in, token,
+ &chars_seen, &unsignedp);
- FIXME: cpplib's assessment of overflow may not be accurate on a
- platform where the final type can change at (compiler's) runtime. */
+ /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
+ before possibly widening to HOST_WIDE_INT for build_int_2. */
+ if (unsignedp || (cppchar_signed_t) result >= 0)
+ value = build_int_2 (result, 0);
+ else
+ value = build_int_2 ((cppchar_signed_t) result, -1);
- TREE_TYPE (value) = widest_integer_literal_type_node;
- value = convert (type, value);
- TREE_OVERFLOW (value) = 0;
+ if (token->type == CPP_WCHAR)
+ type = wchar_type_node;
+ /* In C, a character constant has type 'int'.
+ In C++ 'char', but multi-char charconsts have type 'int'. */
+ else if ((c_language == clk_c) || chars_seen > 1)
+ type = integer_type_node;
+ else
+ type = char_type_node;
+ TREE_TYPE (value) = type;
return value;
}
OpenPOWER on IntegriCloud