X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=gcc%2Fcp%2Ferror.c;h=22c2d304d88ca02e84dfb14619d2a2a766fcd57e;hp=8eab229269675be69c23c62a482dba14eb52e159;hb=d65b3a4091670f1e49fadb3f1a0a336dd96ae7d7;hpb=97d541d588e6185728e9e13f874ddb16b115e9f1

diff --git a/gcc/cp/error.c b/gcc/cp/error.c
index 8eab2292696..22c2d304d88 100644
--- a/gcc/cp/error.c
+++ b/gcc/cp/error.c
@@ -16,8 +16,8 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING.  If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA.  */
+the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA.  */
 
 #include "config.h"
 #include "system.h"
@@ -81,13 +81,13 @@ static const char *function_category (tree);
 static void maybe_print_instantiation_context (diagnostic_context *);
 static void print_instantiation_full_context (diagnostic_context *);
 static void print_instantiation_partial_context (diagnostic_context *,
-                                                 tree, location_t);
+						 tree, location_t);
 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
 static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
 
-static bool cp_printer (pretty_printer *, text_info *);
-static tree locate_error (const char *, va_list);
+static bool cp_printer (pretty_printer *, text_info *, const char *,
+			int, bool, bool, bool);
 static location_t location_of (tree);
 
 void
@@ -114,10 +114,10 @@ dump_scope (tree scope, int flags)
   if (TREE_CODE (scope) == NAMESPACE_DECL)
     {
       if (scope != global_namespace)
-        {
-          dump_decl (scope, f);
-          pp_cxx_colon_colon (cxx_pp);
-        }
+	{
+	  dump_decl (scope, f);
+	  pp_cxx_colon_colon (cxx_pp);
+	}
     }
   else if (AGGREGATE_TYPE_P (scope))
     {
@@ -155,7 +155,7 @@ dump_template_argument_list (tree args, int flags)
   for (i = 0; i< n; ++i)
     {
       if (need_comma)
-        pp_separate_with_comma (cxx_pp);
+	pp_separate_with_comma (cxx_pp);
       dump_template_argument (TREE_VEC_ELT (args, i), flags);
       need_comma = 1;
     }
@@ -172,15 +172,15 @@ dump_template_parameter (tree parm, int flags)
   if (TREE_CODE (p) == TYPE_DECL)
     {
       if (flags & TFF_DECL_SPECIFIERS)
-        {
-          pp_cxx_identifier (cxx_pp, "class");
-          if (DECL_NAME (p))
-            pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
-        }
+	{
+	  pp_cxx_identifier (cxx_pp, "class");
+	  if (DECL_NAME (p))
+	    pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
+	}
       else if (DECL_NAME (p))
-        pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
+	pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
       else
-        pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
+	pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
     }
   else
     dump_decl (p, flags | TFF_DECL_SPECIFIERS);
@@ -191,9 +191,9 @@ dump_template_parameter (tree parm, int flags)
       pp_equal (cxx_pp);
       pp_cxx_whitespace (cxx_pp);
       if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
-        dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
+	dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
       else
-        dump_expr (a, flags | TFF_EXPR_IN_PARENS);
+	dump_expr (a, flags | TFF_EXPR_IN_PARENS);
     }
 }
 
@@ -228,9 +228,9 @@ dump_template_bindings (tree parms, tree args)
 	  if (need_comma)
 	    pp_separate_with_comma (cxx_pp);
 	  dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
-          pp_cxx_whitespace (cxx_pp);
-          pp_equal (cxx_pp);
-          pp_cxx_whitespace (cxx_pp);
+	  pp_cxx_whitespace (cxx_pp);
+	  pp_equal (cxx_pp);
+	  pp_cxx_whitespace (cxx_pp);
 	  if (arg)
 	    dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
 	  else
@@ -259,7 +259,7 @@ dump_type (tree t, int flags)
   switch (TREE_CODE (t))
     {
     case UNKNOWN_TYPE:
-      pp_identifier (cxx_pp, "<unknown type>");
+      pp_identifier (cxx_pp, "<unresolved overloaded function type>");
       break;
 
     case TREE_LIST:
@@ -283,11 +283,11 @@ dump_type (tree t, int flags)
 
     case TYPE_DECL:
       if (flags & TFF_CHASE_TYPEDEF)
-        {
-          dump_type (DECL_ORIGINAL_TYPE (t)
-                     ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
-          break;
-        }
+	{
+	  dump_type (DECL_ORIGINAL_TYPE (t)
+		     ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
+	  break;
+	}
       /* Else fall through.  */
 
     case TEMPLATE_DECL:
@@ -309,7 +309,7 @@ dump_type (tree t, int flags)
       if (TYPE_IDENTIFIER (t))
 	pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
       else
-        pp_cxx_canonical_template_parameter (cxx_pp, t);
+	pp_cxx_canonical_template_parameter (cxx_pp, t);
       break;
 
     case BOUND_TEMPLATE_TEMPLATE_PARM:
@@ -318,7 +318,7 @@ dump_type (tree t, int flags)
 	pp_cxx_cv_qualifier_seq (cxx_pp, t);
 	pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
 	pp_cxx_begin_template_argument_list (cxx_pp);
-        dump_template_argument_list (args, flags);
+	dump_template_argument_list (args, flags);
 	pp_cxx_end_template_argument_list (cxx_pp);
       }
       break;
@@ -328,8 +328,8 @@ dump_type (tree t, int flags)
       if (TYPE_IDENTIFIER (t))
 	pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
       else
-        pp_cxx_canonical_template_parameter
-          (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
+	pp_cxx_canonical_template_parameter
+	  (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
       break;
 
       /* This is not always necessary for pointers and such, but doing this
@@ -348,8 +348,8 @@ dump_type (tree t, int flags)
     }
     case TYPENAME_TYPE:
       pp_cxx_cv_qualifier_seq (cxx_pp, t);
-      pp_cxx_identifier (cxx_pp, 
-			 TYPENAME_IS_ENUM_P (t) ? "enum" 
+      pp_cxx_identifier (cxx_pp,
+			 TYPENAME_IS_ENUM_P (t) ? "enum"
 			 : TYPENAME_IS_CLASS_P (t) ? "class"
 			 : "typename");
       dump_typename (t, flags);
@@ -436,38 +436,36 @@ dump_aggr_type (tree t, int flags)
     {
       typdef = !DECL_ARTIFICIAL (name);
       tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
-                && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
-                && (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
-                    || TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
-                    || DECL_TEMPLATE_SPECIALIZATION (CLASSTYPE_TI_TEMPLATE (t))
-                    || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
+		&& TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
+		&& (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
+		    || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
       dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
       if (tmplate)
-        {
-          /* Because the template names are mangled, we have to locate
-             the most general template, and use that name.  */
-          tree tpl = CLASSTYPE_TI_TEMPLATE (t);
-
-          while (DECL_TEMPLATE_INFO (tpl))
-            tpl = DECL_TI_TEMPLATE (tpl);
-          name = tpl;
-        }
+	{
+	  /* Because the template names are mangled, we have to locate
+	     the most general template, and use that name.  */
+	  tree tpl = CLASSTYPE_TI_TEMPLATE (t);
+
+	  while (DECL_TEMPLATE_INFO (tpl))
+	    tpl = DECL_TI_TEMPLATE (tpl);
+	  name = tpl;
+	}
       name = DECL_NAME (name);
     }
 
   if (name == 0 || ANON_AGGRNAME_P (name))
     {
       if (flags & TFF_CLASS_KEY_OR_ENUM)
-        pp_identifier (cxx_pp, "<anonymous>");
+	pp_identifier (cxx_pp, "<anonymous>");
       else
-        pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety);
+	pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety);
     }
   else
     pp_cxx_tree_identifier (cxx_pp, name);
   if (tmplate)
     dump_template_parms (TYPE_TEMPLATE_INFO (t),
-                         !CLASSTYPE_USE_TEMPLATE (t),
-                         flags & ~TFF_TEMPLATE_HEADER);
+			 !CLASSTYPE_USE_TEMPLATE (t),
+			 flags & ~TFF_TEMPLATE_HEADER);
 }
 
 /* Dump into the obstack the initial part of the output for a given type.
@@ -481,7 +479,7 @@ dump_aggr_type (tree t, int flags)
    Arrays must also do this for DECL nodes, like int a[], and for things like
    int *[]&.  */
 
-static void 
+static void
 dump_type_prefix (tree t, int flags)
 {
   if (TYPE_PTRMEMFUNC_P (t))
@@ -504,8 +502,8 @@ dump_type_prefix (tree t, int flags)
 	    pp_cxx_left_paren (cxx_pp);
 	  }
 	pp_character (cxx_pp, "&*"[TREE_CODE (t) == POINTER_TYPE]);
-        pp_base (cxx_pp)->padding = pp_before;
-        pp_cxx_cv_qualifier_seq (cxx_pp, t);
+	pp_base (cxx_pp)->padding = pp_before;
+	pp_cxx_cv_qualifier_seq (cxx_pp, t);
       }
       break;
 
@@ -514,9 +512,9 @@ dump_type_prefix (tree t, int flags)
       dump_type_prefix (TREE_TYPE (t), flags);
       if (TREE_CODE (t) == OFFSET_TYPE)	/* pmfs deal with this in d_t_p */
 	{
-          pp_maybe_space (cxx_pp);
-          if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
-             pp_cxx_left_paren (cxx_pp);
+	  pp_maybe_space (cxx_pp);
+	  if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
+	     pp_cxx_left_paren (cxx_pp);
 	  dump_type (TYPE_OFFSET_BASETYPE (t), flags);
 	  pp_cxx_colon_colon (cxx_pp);
 	}
@@ -526,7 +524,7 @@ dump_type_prefix (tree t, int flags)
       break;
 
       /* Can only be reached through function pointer -- this would not be
-         correct if FUNCTION_DECLs used it.  */
+	 correct if FUNCTION_DECLs used it.  */
     case FUNCTION_TYPE:
       dump_type_prefix (TREE_TYPE (t), flags);
       pp_maybe_space (cxx_pp);
@@ -601,7 +599,7 @@ dump_type_suffix (tree t, int flags)
     case METHOD_TYPE:
       {
 	tree arg;
-        pp_cxx_right_paren (cxx_pp);
+	pp_cxx_right_paren (cxx_pp);
 	arg = TYPE_ARG_TYPES (t);
 	if (TREE_CODE (t) == METHOD_TYPE)
 	  arg = TREE_CHAIN (arg);
@@ -611,10 +609,10 @@ dump_type_suffix (tree t, int flags)
 	dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
 
 	if (TREE_CODE (t) == METHOD_TYPE)
-          pp_cxx_cv_qualifier_seq
-            (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
-        else
-          pp_cxx_cv_qualifier_seq(cxx_pp, t);
+	  pp_cxx_cv_qualifier_seq
+	    (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
+	else
+	  pp_cxx_cv_qualifier_seq(cxx_pp, t);
 	dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
 	dump_type_suffix (TREE_TYPE (t), flags);
 	break;
@@ -627,15 +625,15 @@ dump_type_suffix (tree t, int flags)
 	{
 	  if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0))
 	    pp_wide_integer
-              (cxx_pp, tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1);
+	      (cxx_pp, tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1);
 	  else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR)
 	    dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0),
-	               flags & ~TFF_EXPR_IN_PARENS);
+		       flags & ~TFF_EXPR_IN_PARENS);
 	  else
 	    dump_expr (fold (cp_build_binary_op
 			     (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)),
 			      integer_one_node)),
-	               flags & ~TFF_EXPR_IN_PARENS);
+		       flags & ~TFF_EXPR_IN_PARENS);
 	}
       pp_cxx_right_bracket (cxx_pp);
       dump_type_suffix (TREE_TYPE (t), flags);
@@ -666,7 +664,7 @@ dump_type_suffix (tree t, int flags)
       pp_unsupported_tree (cxx_pp, t);
     case ERROR_MARK:
       /* Don't mark it here, we should have already done in
-         dump_type_prefix.  */
+	 dump_type_prefix.  */
       break;
     }
 }
@@ -722,7 +720,7 @@ dump_decl (tree t, int flags)
 	      && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
 	    /* Say `class T' not just `T'.  */
 	    pp_cxx_identifier (cxx_pp, "class");
-	  
+
 	  dump_type (TREE_TYPE (t), flags);
 	  break;
 	}
@@ -730,7 +728,7 @@ dump_decl (tree t, int flags)
 	pp_cxx_identifier (cxx_pp, "typedef");
       dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
 			? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
-	                flags);
+			flags);
       break;
 
     case VAR_DECL:
@@ -744,7 +742,6 @@ dump_decl (tree t, int flags)
       /* Else fall through.  */
     case FIELD_DECL:
     case PARM_DECL:
-    case ALIAS_DECL:
       dump_simple_decl (t, TREE_TYPE (t), flags);
       break;
 
@@ -755,15 +752,15 @@ dump_decl (tree t, int flags)
 
     case NAMESPACE_DECL:
       if (flags & TFF_DECL_SPECIFIERS)
-        pp_cxx_declaration (cxx_pp, t);
+	pp_cxx_declaration (cxx_pp, t);
       else
-        {
-          dump_scope (CP_DECL_CONTEXT (t), flags);
-          if (DECL_NAME (t) == NULL_TREE)
-            pp_identifier (cxx_pp, "<unnamed>");
-          else
-            pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
-        }
+	{
+	  dump_scope (CP_DECL_CONTEXT (t), flags);
+	  if (DECL_NAME (t) == NULL_TREE)
+	    pp_identifier (cxx_pp, "<unnamed>");
+	  else
+	    pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
+	}
       break;
 
     case SCOPE_REF:
@@ -786,7 +783,7 @@ dump_decl (tree t, int flags)
 
     case BIT_NOT_EXPR:
       /* This is a pseudo destructor call which has not been folded into
-         a PSEUDO_DTOR_EXPR yet.  */
+	 a PSEUDO_DTOR_EXPR yet.  */
       pp_cxx_complement (cxx_pp);
       dump_type (TREE_OPERAND (t, 0), flags);
       break;
@@ -816,17 +813,17 @@ dump_decl (tree t, int flags)
 	  if (DECL_CLASS_SCOPE_P (t))
 	    {
 	      dump_type (DECL_CONTEXT (t), flags);
-              pp_cxx_colon_colon (cxx_pp);
+	      pp_cxx_colon_colon (cxx_pp);
 	    }
 	  else if (DECL_CONTEXT (t))
 	    {
 	      dump_decl (DECL_CONTEXT (t), flags);
-              pp_cxx_colon_colon (cxx_pp);
+	      pp_cxx_colon_colon (cxx_pp);
 	    }
 	  dump_decl (DECL_NAME (t), flags);
 	  break;
 	}
-      
+
       /* If there's only one function, just treat it like an ordinary
 	 FUNCTION_DECL.  */
       t = OVL_CURRENT (t);
@@ -838,7 +835,7 @@ dump_decl (tree t, int flags)
       else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
 	dump_global_iord (t);
       else
-        dump_function_decl (t, flags);
+	dump_function_decl (t, flags);
       break;
 
     case TEMPLATE_DECL:
@@ -848,7 +845,7 @@ dump_decl (tree t, int flags)
     case TEMPLATE_ID_EXPR:
       {
 	tree name = TREE_OPERAND (t, 0);
-	
+
 	if (is_overloaded_fn (name))
 	  name = DECL_NAME (get_first_fn (name));
 	dump_decl (name, flags);
@@ -878,7 +875,7 @@ dump_decl (tree t, int flags)
 
     case USING_DECL:
       pp_cxx_identifier (cxx_pp, "using");
-      dump_type (DECL_INITIAL (t), flags);
+      dump_type (USING_DECL_SCOPE (t), flags);
       pp_cxx_colon_colon (cxx_pp);
       dump_decl (DECL_NAME (t), flags);
       break;
@@ -893,9 +890,9 @@ dump_decl (tree t, int flags)
 
     case TEMPLATE_TYPE_PARM:
       if (flags & TFF_DECL_SPECIFIERS)
-        pp_cxx_declaration (cxx_pp, t);
+	pp_cxx_declaration (cxx_pp, t);
       else
-        pp_type_id (cxx_pp, t);
+	pp_type_id (cxx_pp, t);
       break;
 
     default:
@@ -921,28 +918,28 @@ dump_template_decl (tree t, int flags)
   if (flags & TFF_TEMPLATE_HEADER)
     {
       for (parms = orig_parms = nreverse (orig_parms);
-           parms;
-           parms = TREE_CHAIN (parms))
-        {
+	   parms;
+	   parms = TREE_CHAIN (parms))
+	{
 	  tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
-          int len = TREE_VEC_LENGTH (inner_parms);
+	  int len = TREE_VEC_LENGTH (inner_parms);
 
-          pp_cxx_identifier (cxx_pp, "template");
-          pp_cxx_begin_template_argument_list (cxx_pp);
+	  pp_cxx_identifier (cxx_pp, "template");
+	  pp_cxx_begin_template_argument_list (cxx_pp);
 
 	  /* If we've shown the template prefix, we'd better show the
 	     parameters' and decl's type too.  */
 	    flags |= TFF_DECL_SPECIFIERS;
 
-          for (i = 0; i < len; i++)
-            {
-              if (i)
-                pp_separate_with_comma (cxx_pp);
-              dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
-            }
-          pp_cxx_end_template_argument_list (cxx_pp);
-          pp_cxx_whitespace (cxx_pp);
-        }
+	  for (i = 0; i < len; i++)
+	    {
+	      if (i)
+		pp_separate_with_comma (cxx_pp);
+	      dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
+	    }
+	  pp_cxx_end_template_argument_list (cxx_pp);
+	  pp_cxx_whitespace (cxx_pp);
+	}
       nreverse(orig_parms);
 
       if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
@@ -952,8 +949,8 @@ dump_template_decl (tree t, int flags)
 
   if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
     dump_type (TREE_TYPE (t),
-               ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
-                | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
+	       ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
+		| (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
   else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
     dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
   else
@@ -1026,7 +1023,7 @@ dump_function_decl (tree t, int flags)
   /* Print the return type?  */
   if (show_return)
     show_return = !DECL_CONV_FN_P (t)  && !DECL_CONSTRUCTOR_P (t)
-                  && !DECL_DESTRUCTOR_P (t);
+		  && !DECL_DESTRUCTOR_P (t);
   if (show_return)
     dump_type_prefix (TREE_TYPE (fntype), flags);
 
@@ -1046,17 +1043,17 @@ dump_function_decl (tree t, int flags)
       dump_parameters (parmtypes, flags);
 
       if (TREE_CODE (fntype) == METHOD_TYPE)
-        {
-          pp_base (cxx_pp)->padding = pp_before;
-          pp_cxx_cv_qualifier_seq
-            (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
-        }
+	{
+	  pp_base (cxx_pp)->padding = pp_before;
+	  pp_cxx_cv_qualifier_seq
+	    (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
+	}
 
       if (flags & TFF_EXCEPTION_SPECIFICATION)
-        {
-          pp_base (cxx_pp)->padding = pp_before;
-          dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
-        }
+	{
+	  pp_base (cxx_pp)->padding = pp_before;
+	  dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
+	}
 
       if (show_return)
 	dump_type_suffix (TREE_TYPE (fntype), flags);
@@ -1089,22 +1086,22 @@ dump_parameters (tree parmtypes, int flags)
        parmtypes = TREE_CHAIN (parmtypes))
     {
       if (!first)
-        pp_separate_with_comma (cxx_pp);
+	pp_separate_with_comma (cxx_pp);
       first = 0;
       if (!parmtypes)
-        {
-          pp_cxx_identifier (cxx_pp, "...");
-          break;
-        }
+	{
+	  pp_cxx_identifier (cxx_pp, "...");
+	  break;
+	}
       dump_type (TREE_VALUE (parmtypes), flags);
 
       if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
-        {
-          pp_cxx_whitespace (cxx_pp);
-          pp_equal (cxx_pp);
-          pp_cxx_whitespace (cxx_pp);
-          dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
-        }
+	{
+	  pp_cxx_whitespace (cxx_pp);
+	  pp_equal (cxx_pp);
+	  pp_cxx_whitespace (cxx_pp);
+	  dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
+	}
     }
 
   pp_cxx_right_paren (cxx_pp);
@@ -1121,14 +1118,14 @@ dump_exception_spec (tree t, int flags)
       pp_cxx_whitespace (cxx_pp);
       pp_cxx_left_paren (cxx_pp);
       if (TREE_VALUE (t) != NULL_TREE)
-        while (1)
-          {
-            dump_type (TREE_VALUE (t), flags);
-            t = TREE_CHAIN (t);
-            if (!t)
-              break;
-            pp_separate_with_comma (cxx_pp);
-          }
+	while (1)
+	  {
+	    dump_type (TREE_VALUE (t), flags);
+	    t = TREE_CHAIN (t);
+	    if (!t)
+	      break;
+	    pp_separate_with_comma (cxx_pp);
+	  }
       pp_cxx_right_paren (cxx_pp);
     }
 }
@@ -1183,9 +1180,7 @@ dump_function_name (tree t, int flags)
 
   if (DECL_TEMPLATE_INFO (t)
       && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
-      && (DECL_TEMPLATE_SPECIALIZATION (t)
-	  || TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
-	  || DECL_TEMPLATE_SPECIALIZATION (DECL_TI_TEMPLATE (t))
+      && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
 	  || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
     dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
 }
@@ -1214,21 +1209,21 @@ dump_template_parms (tree info, int primary, int flags)
 
       if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
 	args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
-      
+
       len = TREE_VEC_LENGTH (args);
 
       for (ix = 0; ix != len; ix++)
-        {
-          tree arg = TREE_VEC_ELT (args, ix);
-
-          if (ix)
-            pp_separate_with_comma (cxx_pp);
-          
-          if (!arg)
-            pp_identifier (cxx_pp, "<template parameter error>");
-          else
-            dump_template_argument (arg, flags);
-        }
+	{
+	  tree arg = TREE_VEC_ELT (args, ix);
+
+	  if (ix)
+	    pp_separate_with_comma (cxx_pp);
+
+	  if (!arg)
+	    pp_identifier (cxx_pp, "<template parameter error>");
+	  else
+	    dump_template_argument (arg, flags);
+	}
     }
   else if (primary)
     {
@@ -1240,14 +1235,14 @@ dump_template_parms (tree info, int primary, int flags)
       len = parms ? TREE_VEC_LENGTH (parms) : 0;
 
       for (ix = 0; ix != len; ix++)
-        {
-          tree parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
+	{
+	  tree parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
 
-          if (ix)
-            pp_separate_with_comma (cxx_pp);
+	  if (ix)
+	    pp_separate_with_comma (cxx_pp);
 
-          dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
-        }
+	  dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
+	}
     }
   pp_cxx_end_template_argument_list (cxx_pp);
 }
@@ -1266,6 +1261,23 @@ dump_expr_list (tree l, int flags)
     }
 }
 
+/* Print out a vector of initializers (subr of dump_expr).  */
+
+static void
+dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
+{
+  unsigned HOST_WIDE_INT idx;
+  tree value;
+
+  FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
+    {
+      dump_expr (value, flags | TFF_EXPR_IN_PARENS);
+      if (idx != VEC_length (constructor_elt, v) - 1)
+	pp_separate_with_comma (cxx_pp);
+    }
+}
+
+
 /* Print out an expression E under control of FLAGS.  */
 
 static void
@@ -1273,7 +1285,7 @@ dump_expr (tree t, int flags)
 {
   if (t == 0)
     return;
-  
+
   switch (TREE_CODE (t))
     {
     case VAR_DECL:
@@ -1283,6 +1295,7 @@ dump_expr (tree t, int flags)
     case FUNCTION_DECL:
     case TEMPLATE_DECL:
     case NAMESPACE_DECL:
+    case LABEL_DECL:
     case OVERLOAD:
     case IDENTIFIER_NODE:
       dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
@@ -1295,7 +1308,7 @@ dump_expr (tree t, int flags)
       if (PAREN_STRING_LITERAL_P (t))
 	pp_cxx_right_paren (cxx_pp);
       break;
-      
+
     case INTEGER_CST:
     case REAL_CST:
        pp_c_constant (pp_c_base (cxx_pp), t);
@@ -1335,11 +1348,11 @@ dump_expr (tree t, int flags)
       if (TREE_HAS_CONSTRUCTOR (t))
 	{
 	  pp_cxx_identifier (cxx_pp, "new");
-          pp_cxx_whitespace (cxx_pp);
+	  pp_cxx_whitespace (cxx_pp);
 	  dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
 	}
       else
-        dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
+	dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
       break;
 
     case AGGR_INIT_EXPR:
@@ -1401,14 +1414,14 @@ dump_expr (tree t, int flags)
 	tree type = TREE_OPERAND (t, 1);
 	tree init = TREE_OPERAND (t, 2);
 	if (NEW_EXPR_USE_GLOBAL (t))
-          pp_cxx_colon_colon (cxx_pp);
+	  pp_cxx_colon_colon (cxx_pp);
 	pp_cxx_identifier (cxx_pp, "new");
 	if (TREE_OPERAND (t, 0))
 	  {
 	    pp_cxx_left_paren (cxx_pp);
 	    dump_expr_list (TREE_OPERAND (t, 0), flags);
-            pp_cxx_right_paren (cxx_pp);
-            pp_cxx_whitespace (cxx_pp);
+	    pp_cxx_right_paren (cxx_pp);
+	    pp_cxx_whitespace (cxx_pp);
 	  }
 	if (TREE_CODE (type) == ARRAY_REF)
 	  type = build_cplus_array_type
@@ -1489,7 +1502,8 @@ dump_expr (tree t, int flags)
 	  {
 	    ob = TREE_OPERAND (ob, 0);
 	    if (TREE_CODE (ob) != PARM_DECL
-		|| strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
+		|| (DECL_NAME (ob)
+		    && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
 	      {
 		dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
 		pp_cxx_arrow (cxx_pp);
@@ -1512,15 +1526,7 @@ dump_expr (tree t, int flags)
       break;
 
     case UNARY_PLUS_EXPR:
-      if (TREE_TYPE (t) && VOID_TYPE_P (TREE_TYPE (t)))
-	{
-	  pp_cxx_left_paren (cxx_pp);
-	  dump_type (TREE_TYPE (t), flags);
-	  pp_cxx_right_paren (cxx_pp);
-	  dump_expr (TREE_OPERAND (t, 0), flags);
-	}
-      else
-	dump_unary_op ("+", t, flags);
+      dump_unary_op ("+", t, flags);
       break;
 
     case ADDR_EXPR:
@@ -1532,6 +1538,8 @@ dump_expr (tree t, int flags)
 	  || (TREE_TYPE (t)
 	      && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
 	dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
+      else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
+	dump_unary_op ("&&", t, flags);
       else
 	dump_unary_op ("&", t, flags);
       break;
@@ -1587,11 +1595,11 @@ dump_expr (tree t, int flags)
 	  if (TREE_CODE (next) == FUNCTION_TYPE)
 	    {
 	      if (flags & TFF_EXPR_IN_PARENS)
-	        pp_cxx_left_paren (cxx_pp);
+		pp_cxx_left_paren (cxx_pp);
 	      pp_cxx_star (cxx_pp);
 	      dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
 	      if (flags & TFF_EXPR_IN_PARENS)
-	        pp_cxx_right_paren (cxx_pp);
+		pp_cxx_right_paren (cxx_pp);
 	      break;
 	    }
 	  /* Else fall through.  */
@@ -1600,9 +1608,10 @@ dump_expr (tree t, int flags)
       break;
 
     case NOP_EXPR:
+    case CONVERT_EXPR:
       {
 	tree op = TREE_OPERAND (t, 0);
-	
+
 	if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
 	  {
 	    /* It is a cast, but we cannot tell whether it is a
@@ -1620,7 +1629,7 @@ dump_expr (tree t, int flags)
 	  dump_expr (op, flags);
 	break;
       }
-      
+
     case CONSTRUCTOR:
       if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
 	{
@@ -1629,12 +1638,12 @@ dump_expr (tree t, int flags)
 	  if (integer_zerop (idx))
 	    {
 	      /* A NULL pointer-to-member constant.  */
-              pp_cxx_left_paren (cxx_pp);
-              pp_cxx_left_paren (cxx_pp);
+	      pp_cxx_left_paren (cxx_pp);
+	      pp_cxx_left_paren (cxx_pp);
 	      dump_type (TREE_TYPE (t), flags);
-              pp_cxx_right_paren (cxx_pp);
-              pp_character (cxx_pp, '0');
-              pp_cxx_right_paren (cxx_pp);
+	      pp_cxx_right_paren (cxx_pp);
+	      pp_character (cxx_pp, '0');
+	      pp_cxx_right_paren (cxx_pp);
 	      break;
 	    }
 	  else if (host_integerp (idx, 0))
@@ -1660,24 +1669,24 @@ dump_expr (tree t, int flags)
 	      if (virtuals)
 		{
 		  dump_expr (BV_FN (virtuals),
-	                     flags | TFF_EXPR_IN_PARENS);
+			     flags | TFF_EXPR_IN_PARENS);
 		  break;
 		}
 	    }
 	}
-      if (TREE_TYPE (t) && !CONSTRUCTOR_ELTS (t))
+      if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
 	{
 	  dump_type (TREE_TYPE (t), 0);
-          pp_cxx_left_paren (cxx_pp);
-          pp_cxx_right_paren (cxx_pp);
+	  pp_cxx_left_paren (cxx_pp);
+	  pp_cxx_right_paren (cxx_pp);
 	}
       else
 	{
-          pp_cxx_left_brace (cxx_pp);
-	  dump_expr_list (CONSTRUCTOR_ELTS (t), flags);
-          pp_cxx_right_brace (cxx_pp);
+	  pp_cxx_left_brace (cxx_pp);
+	  dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
+	  pp_cxx_right_brace (cxx_pp);
 	}
-      
+
       break;
 
     case OFFSET_REF:
@@ -1690,7 +1699,7 @@ dump_expr (tree t, int flags)
 	      /* A::f */
 	      dump_expr (t, flags | TFF_EXPR_IN_PARENS);
 	    else if (BASELINK_P (t))
-	      dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)), 
+	      dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
 			 flags | TFF_EXPR_IN_PARENS);
 	    else
 	      dump_decl (t, flags);
@@ -1700,14 +1709,14 @@ dump_expr (tree t, int flags)
 	    if (TREE_CODE (ob) == INDIRECT_REF)
 	      {
 		dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
-                pp_cxx_arrow (cxx_pp);
-                pp_cxx_star (cxx_pp);
+		pp_cxx_arrow (cxx_pp);
+		pp_cxx_star (cxx_pp);
 	      }
 	    else
 	      {
 		dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
-                pp_cxx_dot (cxx_pp);
-                pp_cxx_star (cxx_pp);
+		pp_cxx_dot (cxx_pp);
+		pp_cxx_star (cxx_pp);
 	      }
 	    dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
 	  }
@@ -1735,8 +1744,8 @@ dump_expr (tree t, int flags)
 	{
 	  pp_cxx_left_paren (cxx_pp);
 	  dump_type (TREE_TYPE (t), flags);
-          pp_cxx_right_paren (cxx_pp);
-          pp_cxx_left_paren (cxx_pp);
+	  pp_cxx_right_paren (cxx_pp);
+	  pp_cxx_left_paren (cxx_pp);
 	  dump_expr_list (TREE_OPERAND (t, 0), flags);
 	  pp_cxx_right_paren (cxx_pp);
 	}
@@ -1770,7 +1779,7 @@ dump_expr (tree t, int flags)
     case SIZEOF_EXPR:
     case ALIGNOF_EXPR:
       if (TREE_CODE (t) == SIZEOF_EXPR)
-        pp_cxx_identifier (cxx_pp, "sizeof");
+	pp_cxx_identifier (cxx_pp, "sizeof");
       else
 	{
 	  gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
@@ -1781,7 +1790,7 @@ dump_expr (tree t, int flags)
       if (TYPE_P (TREE_OPERAND (t, 0)))
 	dump_type (TREE_OPERAND (t, 0), flags);
       else
-        dump_expr (TREE_OPERAND (t, 0), flags);
+	dump_expr (TREE_OPERAND (t, 0), flags);
       pp_cxx_right_paren (cxx_pp);
       break;
 
@@ -1948,6 +1957,8 @@ lang_decl_name (tree decl, int v)
   return pp_formatted_text (cxx_pp);
 }
 
+/* Return the location of a tree passed to %+ formats.  */
+
 static location_t
 location_of (tree t)
 {
@@ -1957,7 +1968,7 @@ location_of (tree t)
     t = TYPE_MAIN_DECL (t);
   else if (TREE_CODE (t) == OVERLOAD)
     t = OVL_FUNCTION (t);
-  
+
   return DECL_SOURCE_LOCATION (t);
 }
 
@@ -2118,7 +2129,7 @@ cxx_print_error_function (diagnostic_context *context, const char *file)
 
 static void
 cp_diagnostic_starter (diagnostic_context *context,
-                       diagnostic_info *diagnostic)
+		       diagnostic_info *diagnostic)
 {
   diagnostic_report_current_module (context);
   cp_print_error_function (context, diagnostic);
@@ -2128,7 +2139,7 @@ cp_diagnostic_starter (diagnostic_context *context,
 
 static void
 cp_diagnostic_finalizer (diagnostic_context *context,
-                         diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
+			 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
 {
   pp_base_destroy_prefix (context->printer);
 }
@@ -2137,7 +2148,7 @@ cp_diagnostic_finalizer (diagnostic_context *context,
    a diagnostic message.  Called from cp_diagnostic_starter.  */
 static void
 cp_print_error_function (diagnostic_context *context,
-                         diagnostic_info *diagnostic)
+			 diagnostic_info *diagnostic)
 {
   if (diagnostic_last_function_changed (context))
     {
@@ -2148,11 +2159,11 @@ cp_print_error_function (diagnostic_context *context,
       pp_base_set_prefix (context->printer, new_prefix);
 
       if (current_function_decl == NULL)
-        pp_base_string (context->printer, "At global scope:");
+	pp_base_string (context->printer, "At global scope:");
       else
-        pp_printf (context->printer, "In %s %qs:",
-                   function_category (current_function_decl),
-                   cxx_printable_name (current_function_decl, 2));
+	pp_printf (context->printer, "In %s %qs:",
+		   function_category (current_function_decl),
+		   cxx_printable_name (current_function_decl, 2));
       pp_base_newline (context->printer);
 
       diagnostic_set_last_function (context);
@@ -2168,15 +2179,15 @@ function_category (tree fn)
   if (DECL_FUNCTION_MEMBER_P (fn))
     {
       if (DECL_STATIC_FUNCTION_P (fn))
-        return "static member function";
+	return "static member function";
       else if (DECL_COPY_CONSTRUCTOR_P (fn))
-        return "copy constructor";
+	return "copy constructor";
       else if (DECL_CONSTRUCTOR_P (fn))
-        return "constructor";
+	return "constructor";
       else if (DECL_DESTRUCTOR_P (fn))
-        return "destructor";
+	return "destructor";
       else
-        return "member function";
+	return "member function";
     }
   else
     return "function";
@@ -2189,7 +2200,7 @@ print_instantiation_full_context (diagnostic_context *context)
 {
   tree p = current_instantiation ();
   location_t location = input_location;
-  
+
   if (p)
     {
       if (current_function_decl != TINST_DECL (p)
@@ -2204,10 +2215,10 @@ print_instantiation_full_context (diagnostic_context *context)
 	    /* Avoid redundancy with the "In function" line.  */;
 	  else
 	    pp_verbatim (context->printer,
-                         "%s: In instantiation of %qs:\n",
+			 "%s: In instantiation of %qs:\n",
 			 LOCATION_FILE (location),
-                         decl_as_string (TINST_DECL (p),
-                                         TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
+			 decl_as_string (TINST_DECL (p),
+					 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
 
 	  location = TINST_LOCATION (p);
 	  p = TREE_CHAIN (p);
@@ -2220,7 +2231,7 @@ print_instantiation_full_context (diagnostic_context *context)
 /* Same as above but less verbose.  */
 static void
 print_instantiation_partial_context (diagnostic_context *context,
-                                     tree t, location_t loc)
+				     tree t, location_t loc)
 {
   expanded_location xloc;
   for (; ; t = TREE_CHAIN (t))
@@ -2229,13 +2240,14 @@ print_instantiation_partial_context (diagnostic_context *context,
       if (t == NULL_TREE)
 	break;
       pp_verbatim (context->printer, "%s:%d:   instantiated from %qs\n",
-                   xloc.file, xloc.line,
-                   decl_as_string (TINST_DECL (t),
-                                   TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
+		   xloc.file, xloc.line,
+		   decl_as_string (TINST_DECL (t),
+				   TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
       loc = TINST_LOCATION (t);
     }
-  pp_verbatim (context->printer, "%s:%d:   instantiated from here\n",
-               xloc.file, xloc.line);
+  pp_verbatim (context->printer, "%s:%d:   instantiated from here",
+	       xloc.file, xloc.line);
+  pp_base_newline (context->printer);
 }
 
 /* Called from cp_thing to print the template context for an error.  */
@@ -2272,167 +2284,79 @@ print_instantiation_context (void)
    %T   type.
    %V   cv-qualifier.  */
 static bool
-cp_printer (pretty_printer *pp, text_info *text)
+cp_printer (pretty_printer *pp, text_info *text, const char *spec,
+	    int precision, bool wide, bool set_locus, bool verbose)
 {
-  int verbose = 0;
   const char *result;
-#define next_tree    va_arg (*text->args_ptr, tree)
+  tree t = NULL;
+#define next_tree    (t = va_arg (*text->args_ptr, tree))
 #define next_tcode   va_arg (*text->args_ptr, enum tree_code)
 #define next_lang    va_arg (*text->args_ptr, enum languages)
 #define next_int     va_arg (*text->args_ptr, int)
 
-  if (*text->format_spec == '+')
-    ++text->format_spec;
-  if (*text->format_spec == '#')
-    {
-      verbose = 1;
-      ++text->format_spec;
-    }
+  if (precision != 0 || wide)
+    return false;
 
-  switch (*text->format_spec)
+  if (text->locus == NULL)
+    set_locus = false;
+
+  switch (*spec)
     {
     case 'A': result = args_to_string (next_tree, verbose);	break;
-    case 'C': result = code_to_string (next_tcode);	        break;
+    case 'C': result = code_to_string (next_tcode);		break;
     case 'D': result = decl_to_string (next_tree, verbose);	break;
-    case 'E': result = expr_to_string (next_tree);      	break;
+    case 'E': result = expr_to_string (next_tree);		break;
     case 'F': result = fndecl_to_string (next_tree, verbose);	break;
-    case 'L': result = language_to_string (next_lang);          break;
-    case 'O': result = op_to_string (next_tcode);       	break;
-    case 'P': result = parm_to_string (next_int);	        break;
-    case 'Q': result = assop_to_string (next_tcode);	        break;
+    case 'L': result = language_to_string (next_lang);		break;
+    case 'O': result = op_to_string (next_tcode);		break;
+    case 'P': result = parm_to_string (next_int);		break;
+    case 'Q': result = assop_to_string (next_tcode);		break;
     case 'T': result = type_to_string (next_tree, verbose);	break;
     case 'V': result = cv_to_string (next_tree, verbose);	break;
- 
+
     default:
       return false;
     }
 
   pp_base_string (pp, result);
+  if (set_locus && t != NULL)
+    *text->locus = location_of (t);
   return true;
 #undef next_tree
 #undef next_tcode
 #undef next_lang
 #undef next_int
 }
-
-/* These are temporary wrapper functions which handle the historic
-   behavior of cp_*_at.  */
-
-static tree
-locate_error (const char *msgid, va_list ap)
-{
-  tree here = 0, t;
-  int plus = 0;
-  const char *f;
-
-  for (f = msgid; *f; f++)
-    {
-      plus = 0;
-      if (*f == '%')
-	{
-          if (*++f == 'q')
-            ++f;                /* ignore quoting flag.  */
-
-	  if (*f == '+')
-            {
-              ++f;
-              plus = 1;
-            }
-	  if (*f == '#')
-	    f++;
-
-	  switch (*f)
-	    {
-	      /* Just ignore these possibilities.  */
-	    case '%':						break;
-	    case 'P':
-	    case 'd':	(void) va_arg (ap, int);		break;
-	    case 's':	(void) va_arg (ap, char *);		break;
-	    case 'L':	(void) va_arg (ap, enum languages);	break;
-	    case 'C':
-	    case 'O':
-	    case 'Q':	(void) va_arg (ap, enum tree_code);	break;
-
-	      /* These take a tree, which may be where the error is
-		 located.  */
-	    case 'A':
-	    case 'D':
-	    case 'E':
-	    case 'F':
-	    case 'T':
-	    case 'V':
-	      t = va_arg (ap, tree);
-	      if (!here || plus)
-		here = t;
-	      break;
-
-	    default:
-	      errorcount = 0;  /* damn ICE suppression */
-	      internal_error ("unexpected letter %qc in locate_error\n", *f);
-	    }
-	}
-    }
-
-  if (here == 0)
-    here = va_arg (ap, tree);
-
-  return here;
-}
-
-
-void
-cp_error_at (const char *msgid, ...)
-{
-  tree here;
-  diagnostic_info diagnostic;
-  va_list ap;
-
-  va_start (ap, msgid);
-  here = locate_error (msgid, ap);
-  va_end (ap);
-
-  va_start (ap, msgid);
-  diagnostic_set_info (&diagnostic, msgid, &ap,
-                       input_location, DK_ERROR);
-  cp_diagnostic_starter (global_dc, &diagnostic);
-  diagnostic_set_info (&diagnostic, msgid, &ap,
-                       location_of (here), DK_ERROR);
-  report_diagnostic (&diagnostic);
-  va_end (ap);
-}
-
-void
-cp_warning_at (const char *msgid, ...)
-{
-  tree here;
-  diagnostic_info diagnostic;
-  va_list ap;
-
-  va_start (ap, msgid);
-  here = locate_error (msgid, ap);
-  va_end (ap);
-
-  va_start (ap, msgid);
-  diagnostic_set_info (&diagnostic, msgid, &ap,
-                       location_of (here), DK_WARNING);
-  report_diagnostic (&diagnostic);
-  va_end (ap);
-}
+
+/* Callback from cpp_error for PFILE to print diagnostics arising from
+   interpreting strings.  The diagnostic is of type LEVEL; MSG is the
+   translated message and AP the arguments.  */
 
 void
-cp_pedwarn_at (const char *msgid, ...)
+cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
+	      const char *msg, va_list *ap)
 {
-  tree here;
   diagnostic_info diagnostic;
-  va_list ap;
-
-  va_start (ap, msgid);
-  here = locate_error (msgid, ap);
-  va_end (ap);
-
-  va_start (ap, msgid);
-  diagnostic_set_info (&diagnostic, msgid, &ap,
-                       location_of (here), pedantic_error_kind());
+  diagnostic_t dlevel;
+  switch (level)
+    {
+    case CPP_DL_WARNING:
+    case CPP_DL_WARNING_SYSHDR:
+      dlevel = DK_WARNING;
+      break;
+    case CPP_DL_PEDWARN:
+      dlevel = pedantic_error_kind ();
+      break;
+    case CPP_DL_ERROR:
+      dlevel = DK_ERROR;
+      break;
+    case CPP_DL_ICE:
+      dlevel = DK_ICE;
+      break;
+    default:
+      gcc_unreachable ();
+    }
+  diagnostic_set_info_translated (&diagnostic, msg, ap,
+				  input_location, dlevel);
   report_diagnostic (&diagnostic);
-  va_end (ap);
 }