Merge FreeBSD modifications into gcc 3.3.1-prerelease:

  1.2	don't let gcc(1) hide warnings in system headers.

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;
 }