cp-tree.h: Delete #defines for cp_error, cp_warning, cp_pedwarn, and cp_compiler_error.

	* cp-tree.h: Delete #defines for cp_error, cp_warning,
	cp_pedwarn, and cp_compiler_error.
	* call.c, class.c, cp-tree.h, cvt.c, decl.c, decl2.c, error.c,
	except.c, friend.c, init.c, lex.c, method.c, parse.y, pt.c,
	rtti.c, search.c, semantics.c, spew.c, tree.c, typeck.c,
	typeck2.c: Change calls to the above macros to use their
	language-independent equivalents: error, warning, pedwarn, and
	internal_error respectively.

From-SVN: r48140

22 files changed, 709 insertions, 707 deletions

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index d22f162..fc33867 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,14 @@
+2001-12-17  Zack Weinberg  <zack@codesourcery.com>
+
+	* cp-tree.h: Delete #defines for cp_error, cp_warning,
+	cp_pedwarn, and cp_compiler_error.
+	* call.c, class.c, cp-tree.h, cvt.c, decl.c, decl2.c, error.c,
+	except.c, friend.c, init.c, lex.c, method.c, parse.y, pt.c,
+	rtti.c, search.c, semantics.c, spew.c, tree.c, typeck.c,
+	typeck2.c: Change calls to the above macros to use their
+	language-independent equivalents: error, warning, pedwarn, and
+	internal_error respectively.
+
 2001-12-16  Neil Booth  <neil@daikokuya.demon.co.uk>
 
 	* decl2.c (finish_file): Remove back_end_hook.
@@ -50,7 +61,7 @@
 	(ctor_label): Remove.
 	* semantics.c (finish_return_stmt): Lose ctor_label support.
 	* decl.c (finish_constructor_body, mark_lang_function): Likewise.
-	* typeck.c (check_return_expr): Check DECL_DESTRUCTOR_P, not 
+	* typeck.c (check_return_expr): Check DECL_DESTRUCTOR_P, not
 	dtor_label.
 
 	* call.c (build_new_method_call): Let resolves_to_fixed_type_p
@@ -125,8 +136,8 @@
 
 2001-12-08  Aldy Hernandez  <aldyh@redhat.com>
 
-        * lex.c (rid_to_yy): Add RID_CHOOSE_EXPR and
-        RID_TYPES_COMPATIBLE_P.
+	* lex.c (rid_to_yy): Add RID_CHOOSE_EXPR and
+	RID_TYPES_COMPATIBLE_P.
 
 2001-12-08  John David Anglin  <dave@hiauly1.hia.nrc.ca>
 
@@ -225,7 +236,7 @@ Wed Dec  5 17:00:49 2001  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
 
 	PR c++/3048
 	* cp-tree.h (ovl_member): Remove.
-	* decl2.c (merge_functions): Handle extern "C" functions 
+	* decl2.c (merge_functions): Handle extern "C" functions
 	specially.
 	* tree.c (ovl_member): Remove.
 
@@ -303,7 +314,7 @@ Tue Nov 27 09:03:47 2001  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
 
 	* cp/search.c (lookup_base_r): Declare bk in variable declaration
 	space.
-	
+
 2001-11-25  Nathan Sidwell  <nathan@codesourcery.com>
 
 	PR g++/3145
@@ -351,9 +362,9 @@ Tue Nov 27 09:03:47 2001  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
 
 	* cp-tree.h (CP_TYPE_QUALS): Removed.
 	* decl.c (cxx_init_decl_processing): Don't set lang_dump_tree.
-	* cp-lang.c: Set LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN and 
+	* cp-lang.c: Set LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN and
 	LANG_HOOKS_TREE_DUMP_TYPE_QUALS_FN.
-	* dump.c (cp_dump_tree): Use void* dump_info argument to match 
+	* dump.c (cp_dump_tree): Use void* dump_info argument to match
 	lang-hooks prototype.
 	* call.c, cp-tree.h, cvt.c, decl.c, init.c, mangle.c, method.c, pt.c,
 	rtti.c, semantics.c, tree.c, typeck.c, typeck2.c: All references to
@@ -371,7 +382,7 @@ Tue Nov 27 09:03:47 2001  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
 2001-11-20  Mark Mitchell  <mark@codesourcery.com>
 
 	* call.c (non_reference): Add documentation.
-	(convert_class_to_reference): Do not strip reference types 
+	(convert_class_to_reference): Do not strip reference types
 	from conversion operators.
 	(maybe_handle_ref_bind): Simplify.
 	(compare_ics): Correct handling of references.
@@ -382,7 +393,7 @@ Tue Nov 27 09:03:47 2001  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
 	(cp_dump_tree): Dump CLASSTYPE_TEMPLATE_SPECIALIZATION.  Use
 	dump_op.  Dump DECL_MUTABLE, access and staticness for VAR_DECLs.
 	DECL_PURE_VIRTUAL_P, DECL_VIRTUAL_P,
-	
+
 2001-11-19  Mark Mitchell  <mark@codesourcery.com>
 
 	PR4629
@@ -494,7 +505,7 @@ Tue Nov 27 09:03:47 2001  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
 	(struct lang_hooks): Constify.
 	* lex.c (cxx_init_options): Update.
 	(lang_identify): Remove.
-	* parse.y (language_string): Remove.	
+	* parse.y (language_string): Remove.
 
 2001-11-08  Andreas Franck  <afranck@gmx.de>
 
diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index bd43a40..cbe4bc6 100644
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -265,7 +265,7 @@ build_scoped_method_call (exp, basetype, name, parms)
 	return build_method_call (exp, name, parms, NULL_TREE, LOOKUP_NORMAL);
 
       if (! check_dtor_name (basetype, name))
-	cp_error ("qualified type `%T' does not match destructor name `~%T'",
+	error ("qualified type `%T' does not match destructor name `~%T'",
 		  basetype, TREE_OPERAND (name, 0));
 
       /* Destructors can be "called" for simple types; see 5.2.4 and 12.4 Note
@@ -274,7 +274,7 @@ build_scoped_method_call (exp, basetype, name, parms)
       if (! IS_AGGR_TYPE (basetype))
 	{
 	  if (TYPE_MAIN_VARIANT (type) != TYPE_MAIN_VARIANT (basetype))
-	    cp_error ("type of `%E' does not match destructor type `%T' (type was `%T')",
+	    error ("type of `%E' does not match destructor type `%T' (type was `%T')",
 		      exp, basetype, type);
 
 	  return cp_convert (void_type_node, exp);
@@ -283,7 +283,7 @@ build_scoped_method_call (exp, basetype, name, parms)
 
   if (TREE_CODE (basetype) == NAMESPACE_DECL)
     {
-      cp_error ("`%D' is a namespace", basetype);
+      error ("`%D' is a namespace", basetype);
       return error_mark_node;
     }
   if (! is_aggr_type (basetype, 1))
@@ -291,7 +291,7 @@ build_scoped_method_call (exp, basetype, name, parms)
 
   if (! IS_AGGR_TYPE (type))
     {
-      cp_error ("base object `%E' of scoped method call is of non-aggregate type `%T'",
+      error ("base object `%E' of scoped method call is of non-aggregate type `%T'",
 		exp, type);
       return error_mark_node;
     }
@@ -525,7 +525,7 @@ build_method_call (instance, name, parms, basetype_path, flags)
 	basetype = TREE_TYPE (basetype);
 
       if (! check_dtor_name (basetype, name))
-	cp_error
+	error
 	  ("destructor name `~%T' does not match type `%T' of expression",
 	   TREE_OPERAND (name, 0), basetype);
 
@@ -2335,20 +2335,20 @@ print_z_candidates (candidates)
       if (TREE_CODE (candidates->fn) == IDENTIFIER_NODE)
 	{
 	  if (TREE_VEC_LENGTH (candidates->convs) == 3)
-	    cp_error ("%s %D(%T, %T, %T) <builtin>", str, candidates->fn,
+	    error ("%s %D(%T, %T, %T) <builtin>", str, candidates->fn,
 		      TREE_TYPE (TREE_VEC_ELT (candidates->convs, 0)),
 		      TREE_TYPE (TREE_VEC_ELT (candidates->convs, 1)),
 		      TREE_TYPE (TREE_VEC_ELT (candidates->convs, 2)));
 	  else if (TREE_VEC_LENGTH (candidates->convs) == 2)
-	    cp_error ("%s %D(%T, %T) <builtin>", str, candidates->fn,
+	    error ("%s %D(%T, %T) <builtin>", str, candidates->fn,
 		      TREE_TYPE (TREE_VEC_ELT (candidates->convs, 0)),
 		      TREE_TYPE (TREE_VEC_ELT (candidates->convs, 1)));
 	  else
-	    cp_error ("%s %D(%T) <builtin>", str, candidates->fn,
+	    error ("%s %D(%T) <builtin>", str, candidates->fn,
 		      TREE_TYPE (TREE_VEC_ELT (candidates->convs, 0)));
 	}
       else if (TYPE_P (candidates->fn))
-	cp_error ("%s %T <conversion>", str, candidates->fn);
+	error ("%s %T <conversion>", str, candidates->fn);
       else
 	cp_error_at ("%s %+#D%s", str, candidates->fn,
 		     candidates->viable == -1 ? " <near match>" : "");
@@ -2508,7 +2508,7 @@ build_user_type_conversion_1 (totype, expr, flags)
 	  if (candidates && ! candidates->next)
 	    /* say why this one won't work or try to be loose */;
 	  else
-	    cp_error ("no viable candidates");
+	    error ("no viable candidates");
 	}
 #endif
 
@@ -2522,7 +2522,7 @@ build_user_type_conversion_1 (totype, expr, flags)
     {
       if (flags & LOOKUP_COMPLAIN)
 	{
-	  cp_error ("conversion from `%T' to `%T' is ambiguous",
+	  error ("conversion from `%T' to `%T' is ambiguous",
 		    fromtype, totype);
 	  print_z_candidates (candidates);
 	}
@@ -2639,7 +2639,7 @@ build_new_function_call (fn, args)
 	{
 	  if (candidates && ! candidates->next)
 	    return build_function_call (candidates->fn, args);
-	  cp_error ("no matching function for call to `%D(%A)'",
+	  error ("no matching function for call to `%D(%A)'",
 		    DECL_NAME (OVL_FUNCTION (fn)), args);
 	  if (candidates)
 	    print_z_candidates (candidates);
@@ -2650,7 +2650,7 @@ build_new_function_call (fn, args)
 
       if (cand == 0)
 	{
-	  cp_error ("call of overloaded `%D(%A)' is ambiguous",
+	  error ("call of overloaded `%D(%A)' is ambiguous",
 		    DECL_NAME (OVL_FUNCTION (fn)), args);
 	  print_z_candidates (candidates);
 	  return error_mark_node;
@@ -2677,7 +2677,7 @@ build_object_call (obj, args)
     {
       /* It's no good looking for an overloaded operator() on a
 	 pointer-to-member-function.  */
-      cp_error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
+      error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
       return error_mark_node;
     }
 
@@ -2746,7 +2746,7 @@ build_object_call (obj, args)
 
   if (! any_viable (candidates))
     {
-      cp_error ("no match for call to `(%T) (%A)'", TREE_TYPE (obj), args);
+      error ("no match for call to `(%T) (%A)'", TREE_TYPE (obj), args);
       print_z_candidates (candidates);
       return error_mark_node;
     }
@@ -2756,7 +2756,7 @@ build_object_call (obj, args)
 
   if (cand == 0)
     {
-      cp_error ("call of `(%T) (%A)' is ambiguous", TREE_TYPE (obj), args);
+      error ("call of `(%T) (%A)' is ambiguous", TREE_TYPE (obj), args);
       print_z_candidates (candidates);
       return error_mark_node;
     }
@@ -2791,23 +2791,23 @@ op_error (code, code2, arg1, arg2, arg3, problem)
   switch (code)
     {
     case COND_EXPR:
-      cp_error ("%s for `%T ? %T : %T' operator", problem,
+      error ("%s for `%T ? %T : %T' operator", problem,
 		error_type (arg1), error_type (arg2), error_type (arg3));
       break;
     case POSTINCREMENT_EXPR:
     case POSTDECREMENT_EXPR:
-      cp_error ("%s for `%T %s' operator", problem, error_type (arg1), opname);
+      error ("%s for `%T %s' operator", problem, error_type (arg1), opname);
       break;
     case ARRAY_REF:
-      cp_error ("%s for `%T [%T]' operator", problem,
+      error ("%s for `%T [%T]' operator", problem,
 		error_type (arg1), error_type (arg2));
       break;
     default:
       if (arg2)
-	cp_error ("%s for `%T %s %T' operator", problem,
+	error ("%s for `%T %s %T' operator", problem,
 		  error_type (arg1), opname, error_type (arg2));
       else
-	cp_error ("%s for `%s %T' operator", problem, opname, error_type (arg1));
+	error ("%s for `%s %T' operator", problem, opname, error_type (arg1));
     }
 }
 
@@ -2958,7 +2958,7 @@ build_conditional_expr (arg1, arg2, arg3)
 	result_type = void_type_node;
       else
 	{
-	  cp_error ("`%E' has type `void' and is not a throw-expression",
+	  error ("`%E' has type `void' and is not a throw-expression",
 		    VOID_TYPE_P (arg2_type) ? arg2 : arg3);
 	  return error_mark_node;
 	}
@@ -2991,7 +2991,7 @@ build_conditional_expr (arg1, arg2, arg3)
 	  || (conv2 && TREE_CODE (conv2) == AMBIG_CONV)
 	  || (conv3 && TREE_CODE (conv3) == AMBIG_CONV))
 	{
-	  cp_error ("operands to ?: have different types");
+	  error ("operands to ?: have different types");
 	  return error_mark_node;
 	}
       else if (conv2 && !ICS_BAD_FLAG (conv2))
@@ -3144,14 +3144,14 @@ build_conditional_expr (arg1, arg2, arg3)
       
       if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
           && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
-         cp_warning ("enumeral mismatch in conditional expression: `%T' vs `%T'",
+         warning ("enumeral mismatch in conditional expression: `%T' vs `%T'",
                    arg2_type, arg3_type);
       else if (extra_warnings
                && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
                     && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
                    || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
                        && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
-        cp_warning ("enumeral and non-enumeral type in conditional expression");
+        warning ("enumeral and non-enumeral type in conditional expression");
       
       arg2 = perform_implicit_conversion (result_type, arg2);
       arg3 = perform_implicit_conversion (result_type, arg3);
@@ -3191,7 +3191,7 @@ build_conditional_expr (arg1, arg2, arg3)
 
   if (!result_type)
     {
-      cp_error ("operands to ?: have different types");
+      error ("operands to ?: have different types");
       return error_mark_node;
     }
 
@@ -3232,7 +3232,7 @@ build_new_op (code, flags, arg1, arg2, arg3)
      undeclared_template<1, 5, 72>a;  */
   if (code == LT_EXPR && TREE_CODE (arg1) == TEMPLATE_DECL)
     {
-      cp_error ("`%D' must be declared before use", arg1);
+      error ("`%D' must be declared before use", arg1);
       return error_mark_node;
     }
 
@@ -3396,7 +3396,7 @@ build_new_op (code, flags, arg1, arg2, arg3)
 	  /* Look for an `operator++ (int)'.  If they didn't have
 	     one, then we fall back to the old way of doing things.  */
 	  if (flags & LOOKUP_COMPLAIN)
-	    cp_pedwarn ("no `%D(int)' declared for postfix `%s', trying prefix operator instead",
+	    pedwarn ("no `%D(int)' declared for postfix `%s', trying prefix operator instead",
 			fnname, 
 			operator_name_info[code].name);
 	  if (code == POSTINCREMENT_EXPR)
@@ -3443,7 +3443,7 @@ build_new_op (code, flags, arg1, arg2, arg3)
 	  && candidates->next
 	  && ! candidates->next->next)
 	{
-	  cp_warning ("using synthesized `%#D' for copy assignment",
+	  warning ("using synthesized `%#D' for copy assignment",
 		      cand->fn);
 	  cp_warning_at ("  where cfront would use `%#D'",
 			 cand == candidates
@@ -3472,7 +3472,7 @@ build_new_op (code, flags, arg1, arg2, arg3)
 	  && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
 	      != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
 	{
-	  cp_warning ("comparison between `%#T' and `%#T'", 
+	  warning ("comparison between `%#T' and `%#T'", 
 		      TREE_TYPE (arg1), TREE_TYPE (arg2));
 	}
       break;
@@ -3705,7 +3705,7 @@ build_op_delete_call (code, addr, size, flags, placement)
   if (placement)
     return NULL_TREE;
 
-  cp_error ("no suitable `operator delete' for `%T'", type);
+  error ("no suitable `operator delete' for `%T'", type);
   return error_mark_node;
 }
 
@@ -3729,7 +3729,7 @@ enforce_access (basetype_path, decl)
 	cp_error_at ("`%+#D' is protected", decl);
       else
 	cp_error_at ("`%+#D' is inaccessible", decl);
-      cp_error ("within this context");
+      error ("within this context");
       return 0;
     }
 
@@ -3771,9 +3771,9 @@ convert_like_real (convs, expr, fn, argnum, inner)
 	  else if (TREE_CODE (t) == IDENTITY_CONV)
 	    break;
 	}
-      cp_pedwarn ("invalid conversion from `%T' to `%T'", TREE_TYPE (expr), totype);
+      pedwarn ("invalid conversion from `%T' to `%T'", TREE_TYPE (expr), totype);
       if (fn)
-	cp_pedwarn ("  initializing argument %P of `%D'", argnum, fn);
+	pedwarn ("  initializing argument %P of `%D'", argnum, fn);
       return cp_convert (totype, expr);
     }
   
@@ -3835,21 +3835,21 @@ convert_like_real (convs, expr, fn, argnum, inner)
 	    if (fn)
 	      {
 		if (warningcount > savew)
-		  cp_warning
+		  warning
 		    ("  initializing argument %P of `%D' from result of `%D'",
 		     argnum, fn, convfn);
 		else if (errorcount > savee)
-		  cp_error
+		  error
 		    ("  initializing argument %P of `%D' from result of `%D'",
 		     argnum, fn, convfn);
 	      }
 	    else
 	      {
 		if (warningcount > savew)
-		  cp_warning ("  initializing temporary from result of `%D'",
+		  warning ("  initializing temporary from result of `%D'",
 			      convfn);
 		else if (errorcount > savee)
-		  cp_error ("  initializing temporary from result of `%D'",
+		  error ("  initializing temporary from result of `%D'",
 			    convfn);
 	      }
 	    expr = build_cplus_new (totype, expr);
@@ -3912,9 +3912,9 @@ convert_like_real (convs, expr, fn, argnum, inner)
       if (fn)
 	{
 	  if (warningcount > savew)
-	    cp_warning ("  initializing argument %P of `%D'", argnum, fn);
+	    warning ("  initializing argument %P of `%D'", argnum, fn);
 	  else if (errorcount > savee)
-	    cp_error ("  initializing argument %P of `%D'", argnum, fn);
+	    error ("  initializing argument %P of `%D'", argnum, fn);
 	}
       return build_cplus_new (totype, expr);
 
@@ -3983,7 +3983,7 @@ convert_arg_to_ellipsis (arg)
   if (arg != error_mark_node && ! pod_type_p (TREE_TYPE (arg)))
     {
       /* Undefined behaviour [expr.call] 5.2.2/7.  */
-      cp_warning ("cannot pass objects of non-POD type `%#T' through `...'",
+      warning ("cannot pass objects of non-POD type `%#T' through `...'",
 		  TREE_TYPE (arg));
     }
 
@@ -4008,7 +4008,7 @@ build_x_va_arg (expr, type)
   if (! pod_type_p (type))
     {
       /* Undefined behaviour [expr.call] 5.2.2/7.  */
-      cp_warning ("cannot receive objects of non-POD type `%#T' through `...'",
+      warning ("cannot receive objects of non-POD type `%#T' through `...'",
 		  type);
     }
   
@@ -4150,7 +4150,7 @@ build_over_call (cand, args, flags)
       tree argtype = TREE_TYPE (TREE_VALUE (arg));
       tree t;
       if (ICS_BAD_FLAG (TREE_VEC_ELT (convs, i)))
-	cp_pedwarn ("passing `%T' as `this' argument of `%#D' discards qualifiers",
+	pedwarn ("passing `%T' as `this' argument of `%#D' discards qualifiers",
 		    TREE_TYPE (argtype), fn);
 
       /* [class.mfct.nonstatic]: If a nonstatic member function of a class
@@ -4398,7 +4398,7 @@ build_java_interface_fn_ref (fn, instance)
   if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
       || DECL_CONTEXT (iface_ref) != iface)
     {
-      cp_error ("could not find class$ field in java interface type `%T'", 
+      error ("could not find class$ field in java interface type `%T'", 
 		iface);
       return error_mark_node;
     }
@@ -4499,7 +4499,7 @@ build_new_method_call (instance, name, args, basetype_path, flags)
       if (! IS_AGGR_TYPE (basetype))
 	{
 	  if ((flags & LOOKUP_COMPLAIN) && basetype != error_mark_node)
-	    cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
+	    error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
 		      name, instance, basetype);
 
 	  return error_mark_node;
@@ -4625,7 +4625,7 @@ build_new_method_call (instance, name, args, basetype_path, flags)
       if (!COMPLETE_TYPE_P (basetype))
 	incomplete_type_error (instance_ptr, basetype);
       else
-	cp_error ("no matching function for call to `%T::%D(%A)%V'",
+	error ("no matching function for call to `%T::%D(%A)%V'",
 		  basetype, pretty_name, user_args,
 		  TREE_TYPE (TREE_TYPE (instance_ptr)));
       print_z_candidates (candidates);
@@ -4636,7 +4636,7 @@ build_new_method_call (instance, name, args, basetype_path, flags)
 
   if (cand == 0)
     {
-      cp_error ("call of overloaded `%D(%A)' is ambiguous", pretty_name,
+      error ("call of overloaded `%D(%A)' is ambiguous", pretty_name,
 		user_args);
       print_z_candidates (candidates);
       return error_mark_node;
@@ -4648,14 +4648,14 @@ build_new_method_call (instance, name, args, basetype_path, flags)
 	  || DECL_DESTRUCTOR_P (current_function_decl))
       && ! (flags & LOOKUP_NONVIRTUAL)
       && value_member (cand->fn, CLASSTYPE_PURE_VIRTUALS (basetype)))
-    cp_error ((DECL_CONSTRUCTOR_P (current_function_decl) ? 
+    error ((DECL_CONSTRUCTOR_P (current_function_decl) ? 
 	       "abstract virtual `%#D' called from constructor"
 	       : "abstract virtual `%#D' called from destructor"),
 	      cand->fn);
   if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE
       && is_dummy_object (instance_ptr))
     {
-      cp_error ("cannot call member function `%D' without object", cand->fn);
+      error ("cannot call member function `%D' without object", cand->fn);
       return error_mark_node;
     }
 
@@ -5268,9 +5268,9 @@ joust (cand1, cand2, warn)
 
 	      if (warn)
 		{
-		  cp_warning ("passing `%T' chooses `%T' over `%T'",
+		  warning ("passing `%T' chooses `%T' over `%T'",
 			      type, type1, type2);
-		  cp_warning ("  in call to `%D'", w->fn);
+		  warning ("  in call to `%D'", w->fn);
 		}
 	      else
 		add_warning (w, l);
@@ -5319,10 +5319,10 @@ joust (cand1, cand2, warn)
 	      tree source = source_type (TREE_VEC_ELT (w->convs, 0));
 	      if (! DECL_CONSTRUCTOR_P (w->fn))
 		source = TREE_TYPE (source);
-	      cp_warning ("choosing `%D' over `%D'", w->fn, l->fn);
-	      cp_warning ("  for conversion from `%T' to `%T'",
+	      warning ("choosing `%D' over `%D'", w->fn, l->fn);
+	      warning ("  for conversion from `%T' to `%T'",
 			  source, TREE_TYPE (w->second_conv));
-	      cp_warning ("  because conversion sequence for the argument is better");
+	      warning ("  because conversion sequence for the argument is better");
 	    }
 	  else
 	    add_warning (w, l);
@@ -5444,8 +5444,8 @@ tweak:
         {
 	  if (warn)
 	    {
-	      cp_pedwarn ("choosing `%D' over `%D'", w->fn, l->fn);
-	      cp_pedwarn (
+	      pedwarn ("choosing `%D' over `%D'", w->fn, l->fn);
+	      pedwarn (
 "  because worst conversion for the former is better than worst conversion for the latter");
 	    }
 	  else
@@ -5562,7 +5562,7 @@ perform_implicit_conversion (type, expr)
 			      LOOKUP_NORMAL);
   if (!conv)
     {
-      cp_error ("could not convert `%E' to `%T'", expr, type);
+      error ("could not convert `%E' to `%T'", expr, type);
       return error_mark_node;
     }
 
@@ -5583,7 +5583,7 @@ initialize_reference (type, expr)
   conv = reference_binding (type, TREE_TYPE (expr), expr, LOOKUP_NORMAL);
   if (!conv || ICS_BAD_FLAG (conv))
     {
-      cp_error ("could not convert `%E' to `%T'", expr, type);
+      error ("could not convert `%E' to `%T'", expr, type);
       return error_mark_node;
     }
 
diff --git a/gcc/cp/class.c b/gcc/cp/class.c
index b9ed718..02cb9db 100644
--- a/gcc/cp/class.c
+++ b/gcc/cp/class.c
@@ -281,7 +281,7 @@ build_base_path (code, expr, binfo, nonnull)
   
   if (code == MINUS_EXPR && v_binfo)
     {
-      cp_error ("cannot convert from base `%T' to derived type `%T' via virtual base `%T'",
+      error ("cannot convert from base `%T' to derived type `%T' via virtual base `%T'",
 		BINFO_TYPE (binfo), BINFO_TYPE (t), BINFO_TYPE (v_binfo));
       return error_mark_node;
     }
@@ -991,7 +991,7 @@ add_method (type, method, error_p)
 			/* Defer to the local function.  */
 			return;
 		      else
-			cp_error ("`%#D' and `%#D' cannot be overloaded",
+			error ("`%#D' and `%#D' cannot be overloaded",
 				  fn, method);
 		    }
 		}
@@ -1323,7 +1323,7 @@ check_bases (t, cant_have_default_ctor_p, cant_have_const_ctor_p,
 	 dtor is handled in finish_struct_1.  */
       if (warn_ecpp && ! TYPE_POLYMORPHIC_P (basetype)
 	  && TYPE_HAS_DESTRUCTOR (basetype))
-	cp_warning ("base class `%#T' has a non-virtual destructor",
+	warning ("base class `%#T' has a non-virtual destructor",
 		    basetype);
 
       /* If the base class doesn't have copy constructors or
@@ -1343,7 +1343,7 @@ check_bases (t, cant_have_default_ctor_p, cant_have_const_ctor_p,
 	{
 	  *cant_have_default_ctor_p = 1;
 	  if (! TYPE_HAS_CONSTRUCTOR (t))
-            cp_pedwarn ("base `%T' with only non-default constructor in class without a constructor",
+            pedwarn ("base `%T' with only non-default constructor in class without a constructor",
                         basetype);
 	}
 
@@ -1929,7 +1929,7 @@ maybe_warn_about_overly_private_class (t)
 	  }
       if (!has_nonprivate_method) 
 	{
-	  cp_warning ("all member functions in class `%T' are private", t);
+	  warning ("all member functions in class `%T' are private", t);
 	  return;
 	}
     }
@@ -1943,7 +1943,7 @@ maybe_warn_about_overly_private_class (t)
 
       if (TREE_PRIVATE (dtor))
 	{
-	  cp_warning ("`%#T' only defines a private destructor and has no friends",
+	  warning ("`%#T' only defines a private destructor and has no friends",
 		      t);
 	  return;
 	}
@@ -1986,7 +1986,7 @@ maybe_warn_about_overly_private_class (t)
 
       if (nonprivate_ctor == 0)
 	{
-	  cp_warning ("`%#T' only defines private constructors and has no friends",
+	  warning ("`%#T' only defines private constructors and has no friends",
 		      t);
 	  return;
 	}
@@ -2107,7 +2107,7 @@ void
 duplicate_tag_error (t)
      tree t;
 {
-  cp_error ("redefinition of `%#T'", t);
+  error ("redefinition of `%#T'", t);
   cp_error_at ("previous definition of `%#T'", t);
 
   /* Pretend we haven't defined this type.  */
@@ -2438,7 +2438,7 @@ find_final_overrider (t, binfo, fn)
   /* If there was no winner, issue an error message.  */
   if (!ffod.overriding_fn)
     {
-      cp_error ("no unique final overrider for `%D' in `%T'", fn, t);
+      error ("no unique final overrider for `%D' in `%T'", fn, t);
       return error_mark_node;
     }
 
@@ -3426,16 +3426,16 @@ check_field_decls (t, access_decls, empty_p,
   if (has_pointers && warn_ecpp && TYPE_HAS_CONSTRUCTOR (t)
       && ! (TYPE_HAS_INIT_REF (t) && TYPE_HAS_ASSIGN_REF (t)))
     {
-      cp_warning ("`%#T' has pointer data members", t);
+      warning ("`%#T' has pointer data members", t);
       
       if (! TYPE_HAS_INIT_REF (t))
 	{
-	  cp_warning ("  but does not override `%T(const %T&)'", t, t);
+	  warning ("  but does not override `%T(const %T&)'", t, t);
 	  if (! TYPE_HAS_ASSIGN_REF (t))
-	    cp_warning ("  or `operator=(const %T&)'", t);
+	    warning ("  or `operator=(const %T&)'", t);
 	}
       else if (! TYPE_HAS_ASSIGN_REF (t))
-	cp_warning ("  but does not override `operator=(const %T&)'", t);
+	warning ("  but does not override `operator=(const %T&)'", t);
     }
 
 
@@ -4687,7 +4687,7 @@ layout_virtual_bases (t, offsets)
 	tree basetype = BINFO_TYPE (TREE_VALUE (vbases));
 	
 	if (!lookup_base (t, basetype, ba_ignore | ba_quiet, NULL))
-	  cp_warning ("virtual base `%T' inaccessible in `%T' due to ambiguity",
+	  warning ("virtual base `%T' inaccessible in `%T' due to ambiguity",
 		      basetype, t);
       }
 }
@@ -4757,7 +4757,7 @@ warn_about_ambiguous_direct_bases (t)
       tree basetype = TYPE_BINFO_BASETYPE (t, i);
 
       if (!lookup_base (t, basetype, ba_ignore | ba_quiet, NULL))
-	cp_warning ("direct base `%T' inaccessible in `%T' due to ambiguity",
+	warning ("direct base `%T' inaccessible in `%T' due to ambiguity",
 		    basetype, t);
     }
 }
@@ -5011,7 +5011,7 @@ finish_struct_1 (t)
   if (COMPLETE_TYPE_P (t))
     {
       if (IS_AGGR_TYPE (t))
-	cp_error ("redefinition of `%#T'", t);
+	error ("redefinition of `%#T'", t);
       else
 	my_friendly_abort (172);
       popclass ();
@@ -5174,7 +5174,7 @@ finish_struct_1 (t)
 
   if (warn_nonvdtor && TYPE_POLYMORPHIC_P (t) && TYPE_HAS_DESTRUCTOR (t)
       && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t), 1)) == NULL_TREE)
-    cp_warning ("`%#T' has virtual functions but non-virtual destructor", t);
+    warning ("`%#T' has virtual functions but non-virtual destructor", t);
 
   hack_incomplete_structures (t);
 
@@ -5811,7 +5811,7 @@ resolve_address_of_overloaded_function (target_type,
   else 
     {
       if (complain)
-	cp_error ("\
+	error ("\
 cannot resolve overloaded function `%D' based on conversion to type `%T'", 
 		  DECL_NAME (OVL_FUNCTION (overload)), target_type);
       return error_mark_node;
@@ -5932,7 +5932,7 @@ cannot resolve overloaded function `%D' based on conversion to type `%T'",
       /* There were *no* matches.  */
       if (complain)
 	{
- 	  cp_error ("no matches converting function `%D' to type `%#T'", 
+ 	  error ("no matches converting function `%D' to type `%#T'", 
 		    DECL_NAME (OVL_FUNCTION (overload)),
 		    target_type);
 
@@ -5955,7 +5955,7 @@ cannot resolve overloaded function `%D' based on conversion to type `%T'",
 	{
 	  tree match;
 
- 	  cp_error ("converting overloaded function `%D' to type `%#T' is ambiguous", 
+ 	  error ("converting overloaded function `%D' to type `%#T' is ambiguous", 
 		    DECL_NAME (OVL_FUNCTION (overload)),
 		    target_type);
 
@@ -5981,10 +5981,10 @@ cannot resolve overloaded function `%D' based on conversion to type `%T'",
       if (!complain)
         return error_mark_node;
 
-      cp_pedwarn ("assuming pointer to member `%D'", fn);
+      pedwarn ("assuming pointer to member `%D'", fn);
       if (!explained)
         {
-          cp_pedwarn ("(a pointer to member can only be formed with `&%E')", fn);
+          pedwarn ("(a pointer to member can only be formed with `&%E')", fn);
           explained = 1;
         }
     }
@@ -6037,7 +6037,7 @@ instantiate_type (lhstype, rhs, flags)
       if (comptypes (lhstype, TREE_TYPE (rhs), strict))
 	return rhs;
       if (complain)
-	cp_error ("argument of type `%T' does not match `%T'",
+	error ("argument of type `%T' does not match `%T'",
 		  TREE_TYPE (rhs), lhstype);
       return error_mark_node;
     }
@@ -6431,7 +6431,7 @@ note_name_declared_in_class (name, decl)
 	 A name N used in a class S shall refer to the same declaration
 	 in its context and when re-evaluated in the completed scope of
 	 S.  */
-      cp_error ("declaration of `%#D'", decl);
+      error ("declaration of `%#D'", decl);
       cp_error_at ("changes meaning of `%D' from `%+#D'", 
 		   DECL_NAME (OVL_CURRENT (decl)),
 		   (tree) n->value);
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index d4fc1b6..5069648 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -3780,14 +3780,6 @@ extern tree set_guard                           PARAMS ((tree));
 /* in parse.y */
 extern void cp_parse_init			PARAMS ((void));
 
-/* Obsolete names, formerly found in errfn.c, which no longer exists.
-   These are all variadic functions and therefore cannot be defined
-   as function-like macros.  */
-#define cp_error		error
-#define cp_warning		warning
-#define cp_pedwarn		pedwarn
-#define cp_compiler_error	internal_error
-
 extern void cp_error_at		PARAMS ((const char *msgid, ...));
 extern void cp_warning_at	PARAMS ((const char *msgid, ...));
 extern void cp_pedwarn_at	PARAMS ((const char *msgid, ...));
@@ -3795,8 +3787,8 @@ extern void cp_pedwarn_at	PARAMS ((const char *msgid, ...));
 /* XXX Not i18n clean.  */
 #define cp_deprecated(str) \
  do { if (warn_deprecated) \
-      cp_warning("%s is deprecated, please see the documentation for details", \
-		 str); \
+        warning("%s is deprecated, please see the documentation for details", \
+		str); \
  } while (0)
 
 /* in error.c */
diff --git a/gcc/cp/cvt.c b/gcc/cp/cvt.c
index 6eb0a7a..3d02456 100644
--- a/gcc/cp/cvt.c
+++ b/gcc/cp/cvt.c
@@ -85,7 +85,7 @@ cp_convert_to_pointer (type, expr, force)
       intype = complete_type (intype);
       if (!COMPLETE_TYPE_P (intype))
 	{
-	  cp_error ("can't convert from incomplete type `%T' to `%T'",
+	  error ("can't convert from incomplete type `%T' to `%T'",
 		    intype, type);
 	  return error_mark_node;
 	}
@@ -94,7 +94,7 @@ cp_convert_to_pointer (type, expr, force)
       if (rval)
 	{
 	  if (rval == error_mark_node)
-	    cp_error ("conversion of `%E' from `%T' to `%T' is ambiguous",
+	    error ("conversion of `%E' from `%T' to `%T' is ambiguous",
 		      expr, intype, type);
 	  return rval;
 	}
@@ -123,7 +123,7 @@ cp_convert_to_pointer (type, expr, force)
 	{
 	  if (TREE_CODE (TREE_TYPE (TREE_TYPE (expr))) == METHOD_TYPE)
 	    if (pedantic || warn_pmf2ptr)
-	      cp_pedwarn ("converting from `%T' to `%T'", TREE_TYPE (expr),
+	      pedwarn ("converting from `%T' to `%T'", TREE_TYPE (expr),
 			  type);
 	  return build1 (NOP_EXPR, type, expr);
 	}
@@ -195,11 +195,11 @@ cp_convert_to_pointer (type, expr, force)
           if (bk == bk_via_virtual)
 	    {
 	      if (force)
-	        cp_warning ("pointer to member cast from `%T' to `%T' is via virtual base",
+	        warning ("pointer to member cast from `%T' to `%T' is via virtual base",
 	                    TREE_TYPE (intype), TREE_TYPE (type));
               else
                 {
-		  cp_error ("pointer to member cast from `%T' to `%T' is via virtual base",
+		  error ("pointer to member cast from `%T' to `%T' is via virtual base",
 			    TREE_TYPE (intype), TREE_TYPE (type));
 	          return error_mark_node;
 	        }
@@ -217,7 +217,7 @@ cp_convert_to_pointer (type, expr, force)
 	}
       else if (TYPE_PTRMEMFUNC_P (type))
 	{
-	  cp_error ("cannot convert `%E' from type `%T' to type `%T'",
+	  error ("cannot convert `%E' from type `%T' to type `%T'",
 		    expr, intype, type);
 	  return error_mark_node;
 	}
@@ -230,7 +230,7 @@ cp_convert_to_pointer (type, expr, force)
     return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0);
   else if (TYPE_PTRMEMFUNC_P (intype))
     {
-      cp_error ("cannot convert `%E' from type `%T' to type `%T'",
+      error ("cannot convert `%E' from type `%T' to type `%T'",
 		expr, intype, type);
       return error_mark_node;
     }
@@ -269,7 +269,7 @@ cp_convert_to_pointer (type, expr, force)
   if (type_unknown_p (expr))
     return instantiate_type (type, expr, itf_complain);
 
-  cp_error ("cannot convert `%E' from type `%T' to type `%T'",
+  error ("cannot convert `%E' from type `%T' to type `%T'",
 	    expr, intype, type);
   return error_mark_node;
 }
@@ -451,7 +451,7 @@ warn_ref_binding (reftype, intype, decl)
       else
 	  msg = "conversion to non-const reference type `%#T' from rvalue of type `%T'";
 
-      cp_pedwarn (msg, reftype, intype);
+      pedwarn (msg, reftype, intype);
     }
 }
 
@@ -523,7 +523,7 @@ convert_to_reference (reftype, expr, convtype, flags, decl)
 	  
 	  if (! (convtype & CONV_CONST)
 		   && !at_least_as_qualified_p (ttl, ttr))
-	    cp_pedwarn ("conversion from `%T' to `%T' discards qualifiers",
+	    pedwarn ("conversion from `%T' to `%T' discards qualifiers",
 			ttr, reftype);
 	}
 
@@ -541,7 +541,7 @@ convert_to_reference (reftype, expr, convtype, flags, decl)
       if (TREE_CODE (intype) == POINTER_TYPE
 	  && (comptypes (TREE_TYPE (intype), type, 
 			 COMPARE_BASE | COMPARE_RELAXED )))
-	cp_warning ("casting `%T' to `%T' does not dereference pointer",
+	warning ("casting `%T' to `%T' does not dereference pointer",
 		    intype, reftype);
 	  
       rval = build_unary_op (ADDR_EXPR, expr, 0);
@@ -570,7 +570,7 @@ convert_to_reference (reftype, expr, convtype, flags, decl)
   my_friendly_assert (TREE_CODE (intype) != OFFSET_TYPE, 189);
 
   if (flags & LOOKUP_COMPLAIN)
-    cp_error ("cannot convert type `%T' to type `%T'", intype, reftype);
+    error ("cannot convert type `%T' to type `%T'", intype, reftype);
 
   if (flags & LOOKUP_SPECULATIVELY)
     return NULL_TREE;
@@ -687,7 +687,7 @@ ocp_convert (type, expr, convtype, flags)
 	  && ((ARITHMETIC_TYPE_P (intype) && ! (convtype & CONV_STATIC))
 	      || (TREE_CODE (intype) == POINTER_TYPE)))
 	{
-	  cp_pedwarn ("conversion from `%#T' to `%#T'", intype, type);
+	  pedwarn ("conversion from `%#T' to `%#T'", intype, type);
 
 	  if (flag_pedantic_errors)
 	    return error_mark_node;
@@ -699,7 +699,7 @@ ocp_convert (type, expr, convtype, flags)
 	  if (rval)
 	    return rval;
 	  if (flags & LOOKUP_COMPLAIN)
-	    cp_error ("`%#T' used where a `%T' was expected", intype, type);
+	    error ("`%#T' used where a `%T' was expected", intype, type);
 	  if (flags & LOOKUP_SPECULATIVELY)
 	    return NULL_TREE;
 	  return error_mark_node;
@@ -716,7 +716,7 @@ ocp_convert (type, expr, convtype, flags)
 		   && TREE_CODE (TREE_OPERAND (expr, 0)) == FUNCTION_DECL)
 	    fn = TREE_OPERAND (expr, 0);
 	  if (fn && !DECL_WEAK (fn))
-	    cp_warning ("the address of `%D', will always be `true'", fn);
+	    warning ("the address of `%D', will always be `true'", fn);
 	  return cp_truthvalue_conversion (e);
 	}
       return fold (convert_to_integer (type, e));
@@ -736,7 +736,7 @@ ocp_convert (type, expr, convtype, flags)
 	    return rval;
 	  else
 	    if (flags & LOOKUP_COMPLAIN)
-	      cp_error ("`%#T' used where a floating point value was expected",
+	      error ("`%#T' used where a floating point value was expected",
 			TREE_TYPE (e));
 	}
       if (code == REAL_TYPE)
@@ -791,7 +791,7 @@ ocp_convert (type, expr, convtype, flags)
     return e;
 
   if (flags & LOOKUP_COMPLAIN)
-    cp_error ("conversion from `%T' to non-scalar type `%T' requested",
+    error ("conversion from `%T' to non-scalar type `%T' requested",
 	      TREE_TYPE (expr), type);
   if (flags & LOOKUP_SPECULATIVELY)
     return NULL_TREE;
@@ -876,10 +876,10 @@ convert_to_void (expr, implicit)
         int is_complete = COMPLETE_TYPE_P (complete_type (type));
         
         if (is_volatile && !is_complete)
-          cp_warning ("object of incomplete type `%T' will not be accessed in %s",
+          warning ("object of incomplete type `%T' will not be accessed in %s",
                       type, implicit ? implicit : "void context");
         else if (is_reference && is_volatile)
-          cp_warning ("object of type `%T' will not be accessed in %s",
+          warning ("object of type `%T' will not be accessed in %s",
                       TREE_TYPE (TREE_OPERAND (expr, 0)),
                       implicit ? implicit : "void context");
         if (is_reference || !is_volatile || !is_complete)
@@ -895,7 +895,7 @@ convert_to_void (expr, implicit)
         int is_complete = COMPLETE_TYPE_P (complete_type (type));
         
         if (TYPE_VOLATILE (type) && !is_complete)
-          cp_warning ("object `%E' of incomplete type `%T' will not be accessed in %s",
+          warning ("object `%E' of incomplete type `%T' will not be accessed in %s",
                       expr, type, implicit ? implicit : "void context");
         break;
       }
@@ -915,12 +915,12 @@ convert_to_void (expr, implicit)
       {
 	/* [over.over] enumerates the places where we can take the address
 	   of an overloaded function, and this is not one of them.  */
-	cp_pedwarn ("%s cannot resolve address of overloaded function",
+	pedwarn ("%s cannot resolve address of overloaded function",
 		    implicit ? implicit : "void cast");
       }
     else if (implicit && probe == expr && is_overloaded_fn (probe))
       /* Only warn when there is no &.  */
-      cp_warning ("%s is a reference, not call, to function `%E'",
+      warning ("%s is a reference, not call, to function `%E'",
 		  implicit, expr);
   }
   
@@ -1058,7 +1058,7 @@ build_expr_type_conversion (desires, expr, complain)
   if (expr == null_node 
       && (desires & WANT_INT) 
       && !(desires & WANT_NULL))
-    cp_warning ("converting NULL to non-pointer type");
+    warning ("converting NULL to non-pointer type");
     
   if (TREE_CODE (expr) == OFFSET_REF)
     expr = resolve_offset_ref (expr);
@@ -1134,9 +1134,9 @@ build_expr_type_conversion (desires, expr, complain)
 	    {
 	      if (complain)
 		{
-		  cp_error ("ambiguous default type conversion from `%T'",
+		  error ("ambiguous default type conversion from `%T'",
 			    basetype);
-		  cp_error ("  candidate conversions include `%D' and `%D'",
+		  error ("  candidate conversions include `%D' and `%D'",
 			    winner, cand);
 		}
 	      return error_mark_node;
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index f9aceaa..d535097 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -1008,7 +1008,7 @@ add_binding (id, decl)
     }
   else
     {
-      cp_error ("declaration of `%#D'", decl);
+      error ("declaration of `%#D'", decl);
       cp_error_at ("conflicts with previous declaration `%#D'",
 		   BINDING_VALUE (binding));
       ok = 0;
@@ -2283,7 +2283,7 @@ push_namespace (name)
           need_new = 0;
           if (DECL_NAMESPACE_ALIAS (d))
             {
-              cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
+              error ("namespace alias `%D' not allowed here, assuming `%D'",
                         d, DECL_NAMESPACE_ALIAS (d));
               d = DECL_NAMESPACE_ALIAS (d);
             }
@@ -3063,7 +3063,7 @@ warn_extern_redeclared_static (newdecl, olddecl)
     return;
 
   name = DECL_ASSEMBLER_NAME (newdecl);
-  cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
+  pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
 	      ? implicit_extern_static_warning
 	      : explicit_extern_static_warning, newdecl);
   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
@@ -3143,7 +3143,7 @@ duplicate_decls (newdecl, olddecl)
 	  if (! TREE_PUBLIC (newdecl))
 	    {
 	      if (warn_shadow)
-		cp_warning ("shadowing %s function `%#D'",
+		warning ("shadowing %s function `%#D'",
 			    DECL_BUILT_IN (olddecl) ? "built-in" : "library",
 			    olddecl);
 	      /* Discard the old built-in function.  */
@@ -3152,12 +3152,12 @@ duplicate_decls (newdecl, olddecl)
 	  /* If the built-in is not ansi, then programs can override
 	     it even globally without an error.  */
 	  else if (! DECL_BUILT_IN (olddecl))
-	    cp_warning ("library function `%#D' redeclared as non-function `%#D'",
+	    warning ("library function `%#D' redeclared as non-function `%#D'",
 			olddecl, newdecl);
 	  else
 	    {
-	      cp_error ("declaration of `%#D'", newdecl);
-	      cp_error ("conflicts with built-in declaration `%#D'",
+	      error ("declaration of `%#D'", newdecl);
+	      error ("conflicts with built-in declaration `%#D'",
 			olddecl);
 	    }
 	  return 0;
@@ -3173,12 +3173,12 @@ duplicate_decls (newdecl, olddecl)
 
 	      if (TREE_PUBLIC (newdecl))
 		{
-		  cp_warning ("new declaration `%#D'", newdecl);
-		  cp_warning ("ambiguates built-in declaration `%#D'",
+		  warning ("new declaration `%#D'", newdecl);
+		  warning ("ambiguates built-in declaration `%#D'",
 			      olddecl);
 		}
 	      else if (warn_shadow)
-		cp_warning ("shadowing %s function `%#D'",
+		warning ("shadowing %s function `%#D'",
 			    DECL_BUILT_IN (olddecl) ? "built-in" : "library",
 			    olddecl);
 	    }
@@ -3230,7 +3230,7 @@ duplicate_decls (newdecl, olddecl)
 	      && DECL_FUNCTION_TEMPLATE_P (newdecl)))
 	return 0;
 
-      cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
+      error ("`%#D' redeclared as different kind of symbol", newdecl);
       if (TREE_CODE (olddecl) == TREE_LIST)
 	olddecl = TREE_VALUE (olddecl);
       cp_error_at ("previous declaration of `%#D'", olddecl);
@@ -3255,7 +3255,7 @@ duplicate_decls (newdecl, olddecl)
 	  if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
 	      || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
 	    {
-	      cp_error ("declaration of template `%#D'", newdecl);
+	      error ("declaration of template `%#D'", newdecl);
 	      cp_error_at ("conflicts with previous declaration `%#D'",
 			   olddecl);
 	    }
@@ -3266,7 +3266,7 @@ duplicate_decls (newdecl, olddecl)
 		   && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
 					   DECL_TEMPLATE_PARMS (olddecl)))
 	    {
-	      cp_error ("new declaration `%#D'", newdecl);
+	      error ("new declaration `%#D'", newdecl);
 	      cp_error_at ("ambiguates old declaration `%#D'", olddecl);
 	    }
 	  return 0;
@@ -3275,14 +3275,14 @@ duplicate_decls (newdecl, olddecl)
 	{
 	  if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
 	    {
-	      cp_error ("declaration of C function `%#D' conflicts with",
+	      error ("declaration of C function `%#D' conflicts with",
 			newdecl);
 	      cp_error_at ("previous declaration `%#D' here", olddecl);
 	    }
 	  else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
 			      TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
 	    {
-	      cp_error ("new declaration `%#D'", newdecl);
+	      error ("new declaration `%#D'", newdecl);
 	      cp_error_at ("ambiguates old declaration `%#D'", olddecl);
 	    }
 	  else
@@ -3293,7 +3293,7 @@ duplicate_decls (newdecl, olddecl)
       else if (current_class_type == NULL_TREE
 	  || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
 	{
-	  cp_error ("conflicting types for `%#D'", newdecl);
+	  error ("conflicting types for `%#D'", newdecl);
 	  cp_error_at ("previous declaration as `%#D'", olddecl);
 	}
     }
@@ -3333,7 +3333,7 @@ duplicate_decls (newdecl, olddecl)
       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
       if (errmsg)
 	{
-	  cp_error (errmsg, newdecl);
+	  error (errmsg, newdecl);
 	  if (DECL_NAME (olddecl) != NULL_TREE)
 	    cp_error_at ((DECL_INITIAL (olddecl)
 			  && namespace_bindings_p ())
@@ -3361,7 +3361,7 @@ duplicate_decls (newdecl, olddecl)
 	    {
 	      cp_error_at ("previous declaration of `%#D' with %L linkage",
 			   olddecl, DECL_LANGUAGE (olddecl));
-	      cp_error ("conflicts with new declaration with %L linkage",
+	      error ("conflicts with new declaration with %L linkage",
 			DECL_LANGUAGE (newdecl));
 	    }
 	}
@@ -3386,7 +3386,7 @@ duplicate_decls (newdecl, olddecl)
 		  {
 		    if (pedantic)
 		      {
-			cp_pedwarn ("default argument given for parameter %d of `%#D'",
+			pedwarn ("default argument given for parameter %d of `%#D'",
 				    i, newdecl);
 			cp_pedwarn_at ("after previous specification in `%#D'",
 				       olddecl);
@@ -3394,7 +3394,7 @@ duplicate_decls (newdecl, olddecl)
 		  }
 		else
 		  {
-		    cp_error ("default argument given for parameter %d of `%#D'",
+		    error ("default argument given for parameter %d of `%#D'",
 			      i, newdecl);
 		    cp_error_at ("after previous specification in `%#D'",
 				 olddecl);
@@ -3405,7 +3405,7 @@ duplicate_decls (newdecl, olddecl)
 	      && ! DECL_DECLARED_INLINE_P (olddecl)
 	      && TREE_ADDRESSABLE (olddecl) && warn_inline)
 	    {
-	      cp_warning ("`%#D' was used before it was declared inline",
+	      warning ("`%#D' was used before it was declared inline",
 			  newdecl);
 	      cp_warning_at ("previous non-inline declaration here",
 			     olddecl);
@@ -3453,7 +3453,7 @@ duplicate_decls (newdecl, olddecl)
 	  /* Don't warn about friends, let add_friend take care of it. */
 	  && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
 	{
-	  cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
+	  warning ("redundant redeclaration of `%D' in same scope", newdecl);
 	  cp_warning_at ("previous declaration of `%D'", olddecl);
 	}
     }
@@ -3536,7 +3536,7 @@ duplicate_decls (newdecl, olddecl)
 	      && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
 	                             TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
 	    {
-	      cp_error ("declaration of `%F' throws different exceptions",
+	      error ("declaration of `%F' throws different exceptions",
 			newdecl);
 	      cp_error_at ("than previous declaration `%F'", olddecl);
 	    }
@@ -3663,7 +3663,7 @@ duplicate_decls (newdecl, olddecl)
 	       that specialization that would cause an implicit
 	       instantiation to take place, in every translation unit in
 	       which such a use occurs.  */
-	    cp_error ("explicit specialization of %D after first use",
+	    error ("explicit specialization of %D after first use",
 		      olddecl);
 
 	  SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
@@ -3939,7 +3939,7 @@ pushdecl (x)
 	  else if (t == wchar_decl_node)
 	    {
 	      if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
-		cp_pedwarn ("redeclaration of `wchar_t' as `%T'",
+		pedwarn ("redeclaration of `wchar_t' as `%T'",
 			    TREE_TYPE (x));
 
 	      /* Throw away the redeclaration.  */
@@ -3968,7 +3968,7 @@ pushdecl (x)
 
 	         This function shall not be overloaded.  */
 	      cp_error_at ("invalid redeclaration of `%D'", t);
-	      cp_error ("as `%D'", x);
+	      error ("as `%D'", x);
 	      /* We don't try to push this declaration since that
 		 causes a crash.  */
 	      return x;
@@ -4057,7 +4057,7 @@ pushdecl (x)
 	      && TREE_CODE (decl) == TREE_CODE (x)
 	      && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
 	    {
-	      cp_pedwarn ("type mismatch with previous external decl", x);
+	      pedwarn ("type mismatch with previous external decl", x);
 	      cp_pedwarn_at ("previous external decl of `%#D'", decl);
 	    }
 	}
@@ -4098,7 +4098,7 @@ pushdecl (x)
 	      /* If this real decl matches the implicit, don't complain.  */
 	      && ! (TREE_CODE (x) == FUNCTION_DECL
 		    && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
-	    cp_warning
+	    warning
 	      ("`%D' was previously implicitly declared to return `int'", x);
 
 	  /* If new decl is `static' and an `extern' was seen previously,
@@ -4159,7 +4159,7 @@ pushdecl (x)
 		/* OK */;
 	      else
 		{
-		  cp_warning ("extern declaration of `%#D' doesn't match", x);
+		  warning ("extern declaration of `%#D' doesn't match", x);
 		  cp_warning_at ("global declaration `%#D'", oldglobal);
 		}
 	    }
@@ -4194,7 +4194,7 @@ pushdecl (x)
 		  /* ARM $8.3 */
 		  if (b->parm_flag == 1)
 		    {
-		      cp_error ("declaration of `%#D' shadows a parameter",
+		      error ("declaration of `%#D' shadows a parameter",
 				name);
 		      err = true;
 		    }
@@ -4214,7 +4214,7 @@ pushdecl (x)
 	      if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
 		       && current_class_ptr
 		       && !TREE_STATIC (name))
-		cp_warning ("declaration of `%s' shadows a member of `this'",
+		warning ("declaration of `%s' shadows a member of `this'",
 			    IDENTIFIER_POINTER (name));
 	      else if (oldlocal != NULL_TREE
 		       && TREE_CODE (oldlocal) == VAR_DECL)
@@ -4579,7 +4579,7 @@ push_overloaded_decl (decl, flags)
 	  if (IS_AGGR_TYPE (t) && warn_shadow
 	      && (! DECL_IN_SYSTEM_HEADER (decl)
 		  || ! DECL_IN_SYSTEM_HEADER (old)))
-	    cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
+	    warning ("`%#D' hides constructor for `%#T'", decl, t);
 	  old = NULL_TREE;
 	}
       else if (is_overloaded_fn (old))
@@ -4594,7 +4594,7 @@ push_overloaded_decl (decl, flags)
 		  && !(flags & PUSH_USING)
 		  && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
 				TYPE_ARG_TYPES (TREE_TYPE (decl))))
-		cp_error ("`%#D' conflicts with previous using declaration `%#D'",
+		error ("`%#D' conflicts with previous using declaration `%#D'",
 			  decl, fn);
 
 	      if (duplicate_decls (decl, fn))
@@ -4607,7 +4607,7 @@ push_overloaded_decl (decl, flags)
       else
 	{
 	  cp_error_at ("previous non-function declaration `%#D'", old);
-	  cp_error ("conflicts with function declaration `%#D'", decl);
+	  error ("conflicts with function declaration `%#D'", decl);
 	  return decl;
 	}
     }
@@ -4697,7 +4697,7 @@ implicitly_declare (functionid)
       /* Only one warning per identifier.  */
       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
     {
-      cp_pedwarn ("implicit declaration of function `%#D'", decl);
+      pedwarn ("implicit declaration of function `%#D'", decl);
     }
 
   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
@@ -4958,7 +4958,7 @@ check_previous_goto_1 (decl, level, names, file, line)
 	  if (! identified)
 	    {
 	      if (decl)
-		cp_pedwarn ("jump to label `%D'", decl);
+		pedwarn ("jump to label `%D'", decl);
 	      else
 		pedwarn ("jump to case label");
 
@@ -4982,7 +4982,7 @@ check_previous_goto_1 (decl, level, names, file, line)
 	  if (! identified)
 	    {
 	      if (decl)
-		cp_pedwarn ("jump to label `%D'", decl);
+		pedwarn ("jump to label `%D'", decl);
 	      else
 		pedwarn ("jump to case label");
 
@@ -5124,11 +5124,11 @@ define_label (filename, line, name)
     p->more_cleanups_ok = 0;
 
   if (name == get_identifier ("wchar_t"))
-    cp_pedwarn ("label named wchar_t");
+    pedwarn ("label named wchar_t");
 
   if (DECL_INITIAL (decl) != NULL_TREE)
     {
-      cp_error ("duplicate label `%D'", decl);
+      error ("duplicate label `%D'", decl);
       return 0;
     }
   else
@@ -5213,7 +5213,7 @@ finish_case_label (low_value, high_value)
       if (high_value)
 	error ("case label not within a switch statement");
       else if (low_value)
-	cp_error ("case label `%E' not within a switch statement",
+	error ("case label `%E' not within a switch statement",
 		  low_value);
       else
 	error ("`default' label not within a switch statement");
@@ -5346,7 +5346,7 @@ lookup_tag (form, name, binding_level, thislevel_only)
 	    if (old && TREE_CODE (old) != form
 		&& !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
 	      {
-		cp_error ("`%#D' redeclared as %C", old, form);
+		error ("`%#D' redeclared as %C", old, form);
 		return NULL_TREE;
 	      }
 	    if (old)
@@ -5366,7 +5366,7 @@ lookup_tag (form, name, binding_level, thislevel_only)
 		    && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
 		  {
 		    /* Definition isn't the kind we were looking for.  */
-		    cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
+		    error ("`%#D' redeclared as %C", TREE_VALUE (tail),
 			      form);
 		    return NULL_TREE;
 		  }
@@ -5455,7 +5455,7 @@ lookup_namespace_name (namespace, name)
     {
       /* This happens for A::B where B is a template, and there are no
 	 template arguments.  */
-      cp_error ("invalid use of `%D'", name);
+      error ("invalid use of `%D'", name);
       return error_mark_node;
     }
 
@@ -5496,7 +5496,7 @@ lookup_namespace_name (namespace, name)
 					    TREE_OPERAND (template_id, 1));
 	  else
 	    {
-	      cp_error ("`%D::%D' is not a template",
+	      error ("`%D::%D' is not a template",
 			namespace, name);
 	      return error_mark_node;
 	    }
@@ -5508,7 +5508,7 @@ lookup_namespace_name (namespace, name)
       return val;
     }
 
-  cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
+  error ("`%D' undeclared in namespace `%D'", name, namespace);
   return error_mark_node;
 }
 
@@ -5642,7 +5642,7 @@ make_typename_type (context, name, complain)
     }
   if (TREE_CODE (name) == TEMPLATE_DECL)
     {
-      cp_error ("`%D' used without template parameters", name);
+      error ("`%D' used without template parameters", name);
       return error_mark_node;
     }
   if (TREE_CODE (name) != IDENTIFIER_NODE)
@@ -5653,7 +5653,7 @@ make_typename_type (context, name, complain)
       /* We can get here from typename_sub0 in the explicit_template_type
 	 expansion.  Just fail.  */
       if (complain)
-	cp_error ("no class template named `%#T' in `%#T'",
+	error ("no class template named `%#T' in `%#T'",
 		  name, context);
       return error_mark_node;
     }
@@ -5669,7 +5669,7 @@ make_typename_type (context, name, complain)
 	  if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
 	    {
 	      if (complain)
-		cp_error ("no class template named `%#T' in `%#T'",
+		error ("no class template named `%#T' in `%#T'",
 			  name, context);
 	      return error_mark_node;
 	    }
@@ -5687,7 +5687,7 @@ make_typename_type (context, name, complain)
 	  if (!IS_AGGR_TYPE (context))
 	    {
 	      if (complain)
-		cp_error ("no type named `%#T' in `%#T'", name, context);
+		error ("no type named `%#T' in `%#T'", name, context);
 	      return error_mark_node;
 	    }
 
@@ -5702,7 +5702,7 @@ make_typename_type (context, name, complain)
   if (!uses_template_parms (context))
     {
       if (complain)
-	cp_error ("no type named `%#T' in `%#T'", name, context);
+	error ("no type named `%#T' in `%#T'", name, context);
       return error_mark_node;
     }
 
@@ -5740,7 +5740,7 @@ make_unbound_class_template (context, name, complain)
       if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
 	{
 	  if (complain)
-	    cp_error ("no class template named `%#T' in `%#T'", name, context);
+	    error ("no class template named `%#T' in `%#T'", name, context);
 	  return error_mark_node;
 	}
       
@@ -5919,11 +5919,11 @@ warn_about_implicit_typename_lookup (typename, binding)
       && ! (TREE_CODE (binding) == TYPE_DECL
 	    && same_type_p (TREE_TYPE (binding), subtype)))
     {
-      cp_warning ("lookup of `%D' finds `%#D'",
+      warning ("lookup of `%D' finds `%#D'",
 		  name, binding);
-      cp_warning ("  instead of `%D' from dependent base class",
+      warning ("  instead of `%D' from dependent base class",
 		  typename);
-      cp_warning ("  (use `typename %T::%D' if that's what you meant)",
+      warning ("  (use `typename %T::%D' if that's what you meant)",
 		  constructor_name (current_class_type), name);
     }
 }
@@ -6096,7 +6096,7 @@ lookup_name_real (name, prefer_type, nonclass, namespaces_only)
 	  if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
 	      && TREE_CODE (val) == TYPE_DECL
 	      && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
-	    cp_pedwarn ("\
+	    pedwarn ("\
 lookup of `%D' in the scope of `%#T' (`%#D') \
 does not match lookup in the current scope (`%#D')",
 			name, got_object, from_obj, val);
@@ -6980,7 +6980,7 @@ check_tag_decl (declspecs)
 	  if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
 	    {
 	      if (! in_system_header)
-		cp_pedwarn ("redeclaration of C++ built-in type `%T'", value);
+		pedwarn ("redeclaration of C++ built-in type `%T'", value);
 	      return NULL_TREE;
 	    }
 
@@ -7056,14 +7056,14 @@ check_tag_decl (declspecs)
     {
       if (ob_modifier == ridpointers[(int) RID_INLINE]
 	  || ob_modifier == ridpointers[(int) RID_VIRTUAL])
-	cp_error ("`%D' can only be specified for functions", ob_modifier);
+	error ("`%D' can only be specified for functions", ob_modifier);
       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
-	cp_error ("`%D' can only be specified inside a class", ob_modifier);
+	error ("`%D' can only be specified inside a class", ob_modifier);
       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
-	cp_error ("`%D' can only be specified for constructors",
+	error ("`%D' can only be specified for constructors",
 		  ob_modifier);
       else
-	cp_error ("`%D' can only be specified for objects and functions",
+	error ("`%D' can only be specified for objects and functions",
 		  ob_modifier);
     }
 
@@ -7200,13 +7200,13 @@ start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
 	   Any other case of an initialization in a TYPE_DECL is an error.  */
 	if (pedantic || list_length (declspecs) > 1)
 	  {
-	    cp_error ("typedef `%D' is initialized", decl);
+	    error ("typedef `%D' is initialized", decl);
 	    initialized = 0;
 	  }
 	break;
 
       case FUNCTION_DECL:
-	cp_error ("function `%#D' is initialized like a variable", decl);
+	error ("function `%#D' is initialized like a variable", decl);
 	initialized = 0;
 	break;
 
@@ -7218,7 +7218,7 @@ start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
     {
       if (! toplevel_bindings_p ()
 	  && DECL_EXTERNAL (decl))
-	cp_warning ("declaration of `%#D' has `extern' and is initialized",
+	warning ("declaration of `%#D' has `extern' and is initialized",
 		    decl);
       DECL_EXTERNAL (decl) = 0;
       if (toplevel_bindings_p ())
@@ -7248,12 +7248,12 @@ start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
 	{
 	  tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
 	  if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
-	    cp_error ("`%#D' is not a static member of `%#T'", decl, context);
+	    error ("`%#D' is not a static member of `%#T'", decl, context);
 	  else
 	    {
 	      if (DECL_CONTEXT (field) != context)
 		{
-		  cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
+		  pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
 			      DECL_CONTEXT (field), DECL_NAME (decl),
 			      context, DECL_NAME (decl));
 		  DECL_CONTEXT (decl) = DECL_CONTEXT (field);
@@ -7264,7 +7264,7 @@ start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
 		 initialization.  Thus, duplicate_decls won't warn
 		 about this situation, and so we check here.  */
 	      if (DECL_INITIAL (decl) && DECL_INITIAL (field))
-		cp_error ("duplicate initialization of %D", decl);
+		error ("duplicate initialization of %D", decl);
 	      if (duplicate_decls (decl, field))
 		decl = field;
 	    }
@@ -7293,7 +7293,7 @@ start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
 	}
 
       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
-	cp_pedwarn ("declaration of `%#D' outside of class is not definition",
+	pedwarn ("declaration of `%#D' outside of class is not definition",
 		    decl);
     }
 
@@ -7341,7 +7341,7 @@ start_decl_1 (decl)
 	;			/* A complete type is ok.  */
       else if (TREE_CODE (type) != ARRAY_TYPE)
 	{
-	  cp_error ("variable `%#D' has initializer but incomplete type",
+	  error ("variable `%#D' has initializer but incomplete type",
 		    decl);
 	  initialized = 0;
 	  type = TREE_TYPE (decl) = error_mark_node;
@@ -7349,7 +7349,7 @@ start_decl_1 (decl)
       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
 	{
 	  if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
-	    cp_error ("elements of array `%#D' have incomplete type", decl);
+	    error ("elements of array `%#D' have incomplete type", decl);
 	  /* else we already gave an error in start_decl.  */
 	  initialized = 0;
 	}
@@ -7365,7 +7365,7 @@ start_decl_1 (decl)
       if ((! processing_template_decl || ! uses_template_parms (type))
 	  && !COMPLETE_TYPE_P (complete_type (type)))
 	{
-	  cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
+	  error ("aggregate `%#D' has incomplete type and cannot be initialized",
 		 decl);
 	  /* Change the type so that assemble_variable will give
 	     DECL an rtl we can live with: (mem (const_int 0)).  */
@@ -7404,7 +7404,7 @@ grok_reference_init (decl, type, init)
       if ((DECL_LANG_SPECIFIC (decl) == 0
 	   || DECL_IN_AGGR_P (decl) == 0)
 	  && ! DECL_THIS_EXTERN (decl))
-	cp_error ("`%D' declared as reference but not initialized", decl);
+	error ("`%D' declared as reference but not initialized", decl);
       return NULL_TREE;
     }
 
@@ -7413,7 +7413,7 @@ grok_reference_init (decl, type, init)
 
   if (TREE_CODE (init) == CONSTRUCTOR)
     {
-      cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
+      error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
       return NULL_TREE;
     }
 
@@ -7446,7 +7446,7 @@ grok_reference_init (decl, type, init)
     return NULL_TREE;
   else if (tmp == NULL_TREE)
     {
-      cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
+      error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
       return NULL_TREE;
     }
 
@@ -7507,12 +7507,12 @@ maybe_deduce_size_from_array_init (decl, init)
       int failure = complete_array_type (type, initializer, do_default);
 
       if (failure == 1)
-	cp_error ("initializer fails to determine size of `%D'", decl);
+	error ("initializer fails to determine size of `%D'", decl);
 
       if (failure == 2)
 	{
 	  if (do_default)
-	    cp_error ("array size missing in `%D'", decl);
+	    error ("array size missing in `%D'", decl);
 	  /* If a `static' var's size isn't known, make it extern as
 	     well as static, so it does not get allocated.  If it's not
 	     `static', then don't mark it extern; finish_incomplete_decl
@@ -7524,7 +7524,7 @@ maybe_deduce_size_from_array_init (decl, init)
       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
 	  && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
 			      integer_zero_node))
-	cp_error ("zero-size array `%D'", decl);
+	error ("zero-size array `%D'", decl);
 
       layout_decl (decl, 0);
     }
@@ -7557,7 +7557,7 @@ layout_var_decl (decl)
       /* An automatic variable with an incomplete type: that is an error.
 	 Don't talk about array types here, since we took care of that
 	 message in grokdeclarator.  */
-      cp_error ("storage size of `%D' isn't known", decl);
+      error ("storage size of `%D' isn't known", decl);
       TREE_TYPE (decl) = error_mark_node;
     }
 #if 0
@@ -7579,7 +7579,7 @@ layout_var_decl (decl)
       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
 	constant_expression_warning (DECL_SIZE (decl));
       else
-	cp_error ("storage size of `%D' isn't constant", decl);
+	error ("storage size of `%D' isn't constant", decl);
     }
 
   if (TREE_STATIC (decl)
@@ -7659,7 +7659,7 @@ check_for_uninitialized_const_var (decl)
       && CP_TYPE_CONST_P (type)
       && !TYPE_NEEDS_CONSTRUCTING (type)
       && !DECL_INITIAL (decl))
-    cp_error ("uninitialized const `%D'", decl);
+    error ("uninitialized const `%D'", decl);
 }
 
 /* Verify INIT (the initializer for DECL), and record the
@@ -7694,18 +7694,18 @@ check_initializer (decl, init)
 	init = NULL_TREE;
       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
 	{
-	  cp_error ("variable-sized object `%D' may not be initialized", decl);
+	  error ("variable-sized object `%D' may not be initialized", decl);
 	  init = NULL_TREE;
 	}
       else if (TREE_CODE (type) == ARRAY_TYPE
 	       && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
 	{
-	  cp_error ("elements of array `%#D' have incomplete type", decl);
+	  error ("elements of array `%#D' have incomplete type", decl);
 	  init = NULL_TREE;
 	}
       else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
 	{
-	  cp_error ("`%D' has incomplete type", decl);
+	  error ("`%D' has incomplete type", decl);
 	  TREE_TYPE (decl) = error_mark_node;
 	  init = NULL_TREE;
 	}
@@ -7737,7 +7737,7 @@ check_initializer (decl, init)
 	    {
 	      if (TYPE_NON_AGGREGATE_CLASS (type))
 		{
-		  cp_error ("`%D' must be initialized by constructor, not by `{...}'",
+		  error ("`%D' must be initialized by constructor, not by `{...}'",
 			    decl);
 		  init = error_mark_node;
 		}
@@ -7767,9 +7767,9 @@ check_initializer (decl, init)
       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
 	{
 	  if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
-	    cp_error ("structure `%D' with uninitialized const members", decl);
+	    error ("structure `%D' with uninitialized const members", decl);
 	  if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
-	    cp_error ("structure `%D' with uninitialized reference members",
+	    error ("structure `%D' with uninitialized reference members",
 		      decl);
 	}
 
@@ -8044,7 +8044,7 @@ cp_finish_decl (decl, init, asmspec_tree, flags)
 
   if (init && TREE_CODE (init) == NAMESPACE_DECL)
     {
-      cp_error ("cannot initialize `%D' to namespace `%D'",
+      error ("cannot initialize `%D' to namespace `%D'",
 		decl, init);
       init = NULL_TREE;
     }
@@ -8101,7 +8101,7 @@ cp_finish_decl (decl, init, asmspec_tree, flags)
 	  && IS_AGGR_TYPE (type) && DECL_NAME (decl))
 	{
 	  if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
-	    cp_warning ("shadowing previous type declaration of `%#D'", decl);
+	    warning ("shadowing previous type declaration of `%#D'", decl);
 	  set_identifier_type_value (DECL_NAME (decl), type);
 	  CLASSTYPE_GOT_SEMICOLON (type) = 1;
 	}
@@ -8500,7 +8500,7 @@ expand_static_init (decl, init)
   if (oldstatic)
     {
       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
-	cp_error ("multiple initializations given for `%D'", decl);
+	error ("multiple initializations given for `%D'", decl);
     }
   else if (! toplevel_bindings_p ())
     {
@@ -8718,10 +8718,10 @@ member_function_or_else (ctype, cur_type, flags)
   if (ctype && ctype != cur_type)
     {
       if (flags == DTOR_FLAG)
-	cp_error ("destructor for alien class `%T' cannot be a member",
+	error ("destructor for alien class `%T' cannot be a member",
 	          ctype);
       else
-	cp_error ("constructor for alien class `%T' cannot be a member",
+	error ("constructor for alien class `%T' cannot be a member",
 	          ctype);
       return 0;
     }
@@ -8740,11 +8740,11 @@ bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
      int virtualp, quals, friendp, raises, inlinep;
 {
   if (virtualp)
-    cp_error ("`%D' declared as a `virtual' %s", object, type);
+    error ("`%D' declared as a `virtual' %s", object, type);
   if (inlinep)
-    cp_error ("`%D' declared as an `inline' %s", object, type);
+    error ("`%D' declared as an `inline' %s", object, type);
   if (quals)
-    cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
+    error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
 	      object, type);
   if (friendp)
     cp_error_at ("`%D' declared as a friend", object);
@@ -8863,7 +8863,7 @@ grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
 		/* Allow this; it's pretty common in C.  */;
 	      else
 		{
-		  cp_pedwarn ("non-local function `%#D' uses anonymous type",
+		  pedwarn ("non-local function `%#D' uses anonymous type",
 			      decl);
 		  if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
 		    cp_pedwarn_at ("\
@@ -8872,7 +8872,7 @@ grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
 		}
 	    }
 	  else
-	    cp_pedwarn ("non-local function `%#D' uses local type `%T'",
+	    pedwarn ("non-local function `%#D' uses local type `%T'",
 			decl, t);
 	}
     }
@@ -8895,7 +8895,7 @@ grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
   DECL_EXTERNAL (decl) = 1;
   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
     {
-      cp_error ("%smember function `%D' cannot have `%T' method qualifier",
+      error ("%smember function `%D' cannot have `%T' method qualifier",
 		(ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
       quals = NULL_TREE;
     }
@@ -8918,7 +8918,7 @@ grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
     {
       if (funcdef_flag)
-	cp_error
+	error
 	  ("defining explicit specialization `%D' in friend declaration",
 	   orig_declarator);
       else
@@ -8929,7 +8929,7 @@ grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
 	  if (PROCESSING_REAL_TEMPLATE_DECL_P ())
 	    {
 	      /* Something like `template <class T> friend void f<T>()'.  */
-	      cp_error ("invalid use of template-id `%D' in declaration of primary template",
+	      error ("invalid use of template-id `%D' in declaration of primary template",
 			orig_declarator);
 	      return NULL_TREE;
 	    }
@@ -8957,14 +8957,14 @@ grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
 
 	  if (has_default_arg)
 	    {
-	      cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
+	      error ("default arguments are not allowed in declaration of friend template specialization `%D'",
 			decl);
 	      return NULL_TREE;
 	    }
 
 	  if (inlinep)
 	    {
-	      cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
+	      error ("`inline' is not allowed in declaration of friend template specialization `%D'",
 			decl);
 	      return NULL_TREE;
 	    }
@@ -9026,7 +9026,7 @@ grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
 	  last_function_parms = TREE_CHAIN (last_function_parms);
 	}
       if (old_decl && DECL_ARTIFICIAL (old_decl))
-	cp_error ("definition of implicitly-declared `%D'", old_decl);
+	error ("definition of implicitly-declared `%D'", old_decl);
 
       if (old_decl)
 	{
@@ -9038,7 +9038,7 @@ grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
 	  /* Attempt to merge the declarations.  This can fail, in
 	     the case of some illegal specialization declarations.  */
 	  if (!duplicate_decls (decl, old_decl))
-	    cp_error ("no `%#D' member function declared in class `%T'",
+	    error ("no `%#D' member function declared in class `%T'",
 		      decl, ctype);
 	  return old_decl;
 	}
@@ -9157,7 +9157,7 @@ grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
 	  if (TYPE_ANONYMOUS_P (t))
 	    /* Ignore for now; `enum { foo } e' is pretty common.  */;
 	  else
-	    cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
+	    pedwarn ("non-local variable `%#D' uses local type `%T'",
 			decl, t);
 	}
     }
@@ -9247,7 +9247,7 @@ check_static_variable_definition (decl, type)
      required.  */
   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
     {
-      cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
+      error ("invalid in-class initialization of static data member of non-integral type `%T'",
 		type);
       /* If we just return the declaration, crashes will sometimes
 	 occur.  We therefore return void_type_node, as if this was a
@@ -9256,10 +9256,10 @@ check_static_variable_definition (decl, type)
       return 1;
     }
   else if (!CP_TYPE_CONST_P (type))
-    cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
+    error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
 	      decl);
   else if (pedantic && !INTEGRAL_TYPE_P (type))
-    cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
+    pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
 
   return 0;
 }
@@ -9309,9 +9309,9 @@ compute_array_index_type (name, size)
       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
     {
       if (name)
-	cp_error ("size of array `%D' has non-integer type", name);
+	error ("size of array `%D' has non-integer type", name);
       else
-	cp_error ("size of array has non-integer type");
+	error ("size of array has non-integer type");
       size = integer_one_node;
     }
 
@@ -9331,9 +9331,9 @@ compute_array_index_type (name, size)
       if (INT_CST_LT (size, integer_zero_node))
 	{
 	  if (name)
-	    cp_error ("size of array `%D' is negative", name);
+	    error ("size of array `%D' is negative", name);
 	  else
-	    cp_error ("size of array is negative");
+	    error ("size of array is negative");
 	  size = integer_one_node;
 	}
       /* Except that an extension we allow zero-sized arrays.  We
@@ -9342,19 +9342,19 @@ compute_array_index_type (name, size)
       else if (integer_zerop (size) && pedantic && !in_system_header)
 	{
 	  if (name)
-	    cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
+	    pedwarn ("ISO C++ forbids zero-size array `%D'", name);
 	  else
-	    cp_pedwarn ("ISO C++ forbids zero-size array");
+	    pedwarn ("ISO C++ forbids zero-size array");
 	}
     }
   else if (TREE_CONSTANT (size))
     {
       /* `(int) &fn' is not a valid array bound.  */
       if (name)
-	cp_error ("size of array `%D' is not an integral constant-expression",
+	error ("size of array `%D' is not an integral constant-expression",
 		  name);
       else
-	cp_error ("size of array is not an integral constant-expression");
+	error ("size of array is not an integral constant-expression");
     }
 
   /* Compute the index of the largest element in the array.  It is
@@ -9372,10 +9372,10 @@ compute_array_index_type (name, size)
       if (pedantic)
 	{
 	  if (name)
-	    cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
+	    pedwarn ("ISO C++ forbids variable-size array `%D'",
 			name);
 	  else
-	    cp_pedwarn ("ISO C++ forbids variable-size array");
+	    pedwarn ("ISO C++ forbids variable-size array");
 	}
 
       /* Create a variable-sized array index type.  */
@@ -9445,9 +9445,9 @@ create_array_type_for_decl (name, type, size)
   if (error_msg)
     {
       if (name)
-	cp_error ("declaration of `%D' as %s", name, error_msg);
+	error ("declaration of `%D' as %s", name, error_msg);
       else
-	cp_error ("creating %s", error_msg);
+	error ("creating %s", error_msg);
 
       return error_mark_node;
     }
@@ -9459,10 +9459,10 @@ create_array_type_for_decl (name, type, size)
   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
     {
       if (name)
-	cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
+	error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
 		  name);
       else
-	cp_error ("multidimensional array must have bounds for all dimensions except the first");
+	error ("multidimensional array must have bounds for all dimensions except the first");
 
       return error_mark_node;
     }
@@ -9491,22 +9491,22 @@ check_special_function_return_type (sfk, type, optype)
     {
     case sfk_constructor:
       if (type)
-	cp_error ("return type specification for constructor invalid");
+	error ("return type specification for constructor invalid");
 
       type = void_type_node;
       break;
 
     case sfk_destructor:
       if (type)
-	cp_error ("return type specification for destructor invalid");
+	error ("return type specification for destructor invalid");
       type = void_type_node;
       break;
 
     case sfk_conversion:
       if (type && !same_type_p (type, optype))
-	cp_error ("operator `%T' declared to return `%T'", optype, type);
+	error ("operator `%T' declared to return `%T'", optype, type);
       else if (type)
-	cp_pedwarn ("return type specified for `operator %T'",  optype);
+	pedwarn ("return type specified for `operator %T'",  optype);
       type = optype;
       break;
 
@@ -9695,7 +9695,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 
 	      if (rename)
 		{
-		  cp_error ("destructor `%T' must match class name `%T'",
+		  error ("destructor `%T' must match class name `%T'",
 			    name, rename);
 		  TREE_OPERAND (decl, 0) = rename;
 		}
@@ -9745,7 +9745,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 		    finish_decl (decl, init, NULL_TREE);
 		  }
 		else
-		  cp_error ("invalid declarator");
+		  error ("invalid declarator");
 		return 0;
 	      }
 	    innermost_code = TREE_CODE (decl);
@@ -9798,7 +9798,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 
 	    if (C_IS_RESERVED_WORD (dname))
 	      {
-		cp_error ("declarator-id missing; using reserved word `%D'",
+		error ("declarator-id missing; using reserved word `%D'",
 			  dname);
 		name = IDENTIFIER_POINTER (dname);
 	      }
@@ -9842,9 +9842,9 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 	      else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
 		       || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
 		{
-		  cp_error ("`%T::%D' is not a valid declarator", cname,
+		  error ("`%T::%D' is not a valid declarator", cname,
 			    TREE_OPERAND (decl, 1));
-		  cp_error ("  perhaps you want `typename %T::%D' to make it a type",
+		  error ("  perhaps you want `typename %T::%D' to make it a type",
 			    cname, TREE_OPERAND (decl, 1));
 		  return void_type_node;
 		}
@@ -9856,7 +9856,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 		{
 		  if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
 		    {
-		      cp_error ("type `%T' is not derived from type `%T'",
+		      error ("type `%T' is not derived from type `%T'",
 				cname, ctype);
 		      TREE_OPERAND (decl, 0) = NULL_TREE;
 		    }
@@ -9902,9 +9902,9 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 	  case TYPE_DECL:
 	    /* Parse error puts this typespec where
 	       a declarator should go.  */
-	    cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
+	    error ("`%T' specified as declarator-id", DECL_NAME (decl));
 	    if (TREE_TYPE (decl) == current_class_type)
-	      cp_error ("  perhaps you want `%T' for a constructor",
+	      error ("  perhaps you want `%T' for a constructor",
 			current_class_name);
 	    dname = DECL_NAME (decl);
 	    name = IDENTIFIER_POINTER (dname);
@@ -9918,8 +9918,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 	    break;
 
 	  default:
-	    cp_compiler_error ("`%D' as declarator", decl);
-	    return 0; /* We used to do a 155 abort here.  */
+	    internal_error ("`%D' as declarator", decl);
 	  }
       }
   }
@@ -9934,7 +9933,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
       && innermost_code != CALL_EXPR
       && ! (ctype && declspecs == NULL_TREE))
     {
-      cp_error ("declaration of `%D' as non-function", dname);
+      error ("declaration of `%D' as non-function", dname);
       return void_type_node;
     }
 
@@ -10005,7 +10004,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 		  if (id == ridpointers[(int) RID_BOOL])
 		    error ("`bool' is now a keyword");
 		  else
-		    cp_error ("extraneous `%T' ignored", id);
+		    error ("extraneous `%T' ignored", id);
 		}
 	      else
 		{
@@ -10021,7 +10020,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 	  if (IDENTIFIER_HAS_TYPE_VALUE (id))
 	    {
 	      if (type)
-		cp_error ("multiple declarations `%T' and `%T'", type, id);
+		error ("multiple declarations `%T' and `%T'", type, id);
 	      else
 		type = IDENTIFIER_TYPE_VALUE (id);
 	      goto found;
@@ -10055,7 +10054,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
       else if (TREE_CODE (id) == TYPE_DECL)
 	{
 	  if (type)
-	    cp_error ("multiple declarations `%T' and `%T'", type,
+	    error ("multiple declarations `%T' and `%T'", type,
 		      TREE_TYPE (id));
 	  else
 	    {
@@ -10126,10 +10125,10 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
       if (in_system_header || flag_ms_extensions)
 	/* Allow it, sigh.  */;
       else if (pedantic || ! is_main)
-	cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
+	pedwarn ("ISO C++ forbids declaration of `%s' with no type",
 		    name);
       else if (warn_return_type)
-	cp_warning ("ISO C++ forbids declaration of `%s' with no type",
+	warning ("ISO C++ forbids declaration of `%s' with no type",
 		    name);
 
       type = integer_type_node;
@@ -10139,7 +10138,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
     {
       /* The implicit typename extension is deprecated and will be
 	 removed.  Warn about its use now.  */
-      cp_warning ("`%T' is implicitly a typename", type);
+      warning ("`%T' is implicitly a typename", type);
       cp_deprecated ("implicit typename");
 
       /* Now remove its implicitness, so that we don't warn again.
@@ -10296,7 +10295,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
       && (RIDBIT_SETP (RID_CONST, specbits)
 	  || RIDBIT_SETP (RID_VOLATILE, specbits)
 	  || RIDBIT_SETP (RID_RESTRICT, specbits)))
-    cp_error ("qualifiers are not allowed on declaration of `operator %T'",
+    error ("qualifiers are not allowed on declaration of `operator %T'",
 	      ctor_return_type);
 
   /* Set CONSTP if this declaration is `const', whether by
@@ -10324,7 +10323,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 
   if (virtualp && staticp == 2)
     {
-      cp_error ("member `%D' cannot be declared both virtual and static",
+      error ("member `%D' cannot be declared both virtual and static",
 		dname);
       staticp = 0;
     }
@@ -10551,7 +10550,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 		&& TYPE_DOMAIN (type) != NULL_TREE
 		&& !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
 	      {
-		cp_error ("size of member `%D' is not constant", dname);
+		error ("size of member `%D' is not constant", dname);
 		/* Proceed with arbitrary constant size, so that offset
 		   computations don't get confused. */
 		type = create_array_type_for_decl (dname, TREE_TYPE (type),
@@ -10633,7 +10632,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 		      error ("destructor cannot be static member function");
 		    if (quals)
 		      {
-			cp_error ("destructors may not be `%s'",
+			error ("destructors may not be `%s'",
 				  IDENTIFIER_POINTER (TREE_VALUE (quals)));
 			quals = NULL_TREE;
 		      }
@@ -10662,7 +10661,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 		      }
 		    if (quals)
 		      {
-			cp_error ("constructors may not be `%s'",
+			error ("constructors may not be `%s'",
 				  IDENTIFIER_POINTER (TREE_VALUE (quals)));
 			quals = NULL_TREE;
 		      }
@@ -10702,7 +10701,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 		if (decl_context == NORMAL)
 		  error ("friend declaration not in class definition");
 		if (current_function_decl && funcdef_flag)
-		  cp_error ("can't define friend function `%s' in a local class definition",
+		  error ("can't define friend function `%s' in a local class definition",
 			    name);
 	      }
 
@@ -10726,7 +10725,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 
                 if (arg_types != void_list_node)
 		  {
-		    cp_error ("destructors may not have parameters");
+		    error ("destructors may not have parameters");
 		    arg_types = void_list_node;
 		    last_function_parms = NULL_TREE;
 		  }
@@ -10767,7 +10766,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 	      && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
 		  || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
 	    {
-	      cp_error ("cannot declare pointer to `%#T' member",
+	      error ("cannot declare pointer to `%#T' member",
 			TREE_TYPE (type));
 	      type = TREE_TYPE (type);
 	    }
@@ -10946,7 +10945,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 		       Is this ill-formed?  */
 
 		    if (pedantic)
-		      cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
+		      pedwarn ("extra qualification `%T::' on member `%s' ignored",
 				  ctype, name);
 		  }
 		else if (TREE_CODE (type) == FUNCTION_TYPE)
@@ -10956,7 +10955,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 						      TYPE_ARG_TYPES (type));
 		    else
 		      {
-			cp_error ("cannot declare member function `%T::%s' within `%T'",
+			error ("cannot declare member function `%T::%s' within `%T'",
 				  ctype, name, current_class_type);
 			return void_type_node;
 		      }
@@ -10971,7 +10970,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 
 		    if (current_class_type)
 		      {
-			cp_error ("cannot declare member `%T::%s' within `%T'",
+			error ("cannot declare member `%T::%s' within `%T'",
 				  ctype, name, current_class_type);
 			return void_type_node;
 		      }
@@ -11093,7 +11092,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
     /* OK */;
   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
     {
-      cp_error ("template-id `%D' used as a declarator", declarator);
+      error ("template-id `%D' used as a declarator", declarator);
       declarator = dname;
     }
   else
@@ -11114,7 +11113,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
       if (decl_context == FIELD)
 	{
 	  if (declarator == constructor_name (current_class_type))
-	    cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
+	    pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
 			declarator);
 	  decl = build_lang_decl (TYPE_DECL, declarator, type);
 	}
@@ -11238,12 +11237,12 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 	{
 	  if (type_quals != TYPE_UNQUALIFIED)
 	    {
-	      cp_error ("type qualifiers specified for friend class declaration");
+	      error ("type qualifiers specified for friend class declaration");
 	      type_quals = TYPE_UNQUALIFIED;
 	    }
 	  if (inlinep)
 	    {
-	      cp_error ("`inline' specified for friend class declaration");
+	      error ("`inline' specified for friend class declaration");
 	      inlinep = 0;
 	    }
 
@@ -11253,14 +11252,14 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 				|| IMPLICIT_TYPENAME_P (type)))
 	    {
 	      if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
-	        cp_pedwarn ("template parameters cannot be friends");
+	        pedwarn ("template parameters cannot be friends");
 	      else if (TREE_CODE (type) == TYPENAME_TYPE)
-	        cp_pedwarn ("\
+	        pedwarn ("\
 friend declaration requires class-key, i.e. `friend class %T::%T'",
 			    constructor_name (current_class_type),
 			    TYPE_IDENTIFIER (type));
 	      else
-	        cp_pedwarn ("\
+	        pedwarn ("\
 friend declaration requires class-key, i.e. `friend %#T'",
 			    type);
 	    }
@@ -11276,7 +11275,7 @@ friend declaration requires class-key, i.e. `friend %#T'",
 	      if (current_class_type)
 		make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
 	      else
-		cp_error ("trying to make class `%T' a friend of global scope",
+		error ("trying to make class `%T' a friend of global scope",
 		          type);
 
 	      type = void_type_node;
@@ -11287,7 +11286,7 @@ friend declaration requires class-key, i.e. `friend %#T'",
 	  if (ctype == NULL_TREE)
 	    {
 	      if (TREE_CODE (type) != METHOD_TYPE)
-	        cp_error ("invalid qualifiers on non-member function type");
+	        error ("invalid qualifiers on non-member function type");
 	      else
 	        ctype = TYPE_METHOD_BASETYPE (type);
 	    }
@@ -11306,7 +11305,7 @@ friend declaration requires class-key, i.e. `friend %#T'",
 	   && TREE_CODE (type) != UNION_TYPE
 	   && ! bitfield)
     {
-      cp_error ("abstract declarator `%T' used as declaration", type);
+      error ("abstract declarator `%T' used as declaration", type);
       declarator = make_anon_name ();
     }
 
@@ -11383,7 +11382,7 @@ friend declaration requires class-key, i.e. `friend %#T'",
 	else if (in_namespace && !friendp)
 	  {
 	    /* Something like struct S { int N::j; };  */
-	    cp_error ("invalid use of `::'");
+	    error ("invalid use of `::'");
 	    decl = NULL_TREE;
 	  }
 	else if (TREE_CODE (type) == FUNCTION_TYPE)
@@ -11395,7 +11394,7 @@ friend declaration requires class-key, i.e. `friend %#T'",
 	       typedefs.  */
 	    if (friendp && declarator == ridpointers[(int) RID_SIGNED])
 	      {
-		cp_error ("function `%D' cannot be declared friend",
+		error ("function `%D' cannot be declared friend",
 			  declarator);
 		friendp = 0;
 	      }
@@ -11407,7 +11406,7 @@ friend declaration requires class-key, i.e. `friend %#T'",
 
 		if (ctype == NULL_TREE)
 		  {
-		    cp_error ("can't make `%D' into a method -- not in a class",
+		    error ("can't make `%D' into a method -- not in a class",
 			      declarator);
 		    return void_type_node;
 		  }
@@ -11416,7 +11415,7 @@ friend declaration requires class-key, i.e. `friend %#T'",
 		   ARM 9.5 */
 		if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
 		  {
-		    cp_error ("function `%D' declared virtual inside a union",
+		    error ("function `%D' declared virtual inside a union",
 			      declarator);
 		    return void_type_node;
 		  }
@@ -11428,7 +11427,7 @@ friend declaration requires class-key, i.e. `friend %#T'",
 		  {
 		    if (virtualp)
 		      {
-			cp_error ("`%D' cannot be declared virtual, since it is always static",
+			error ("`%D' cannot be declared virtual, since it is always static",
 				  declarator);
 			virtualp = 0;
 		      }
@@ -11501,9 +11500,9 @@ friend declaration requires class-key, i.e. `friend %#T'",
 		 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
 	  {
 	    if (declarator)
-	      cp_error ("field `%D' has incomplete type", declarator);
+	      error ("field `%D' has incomplete type", declarator);
 	    else
-	      cp_error ("name `%T' has incomplete type", type);
+	      error ("name `%T' has incomplete type", type);
 
 	    /* If we're instantiating a template, tell them which
 	       instantiation made the field's type be incomplete.  */
@@ -11512,7 +11511,7 @@ friend declaration requires class-key, i.e. `friend %#T'",
 		&& IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
 		&& declspecs && TREE_VALUE (declspecs)
 		&& TREE_TYPE (TREE_VALUE (declspecs)) == type)
-	      cp_error ("  in instantiation of template `%T'",
+	      error ("  in instantiation of template `%T'",
 			current_class_type);
 
 	    type = error_mark_node;
@@ -11581,9 +11580,9 @@ friend declaration requires class-key, i.e. `friend %#T'",
 		       the rest of the compiler does not correctly
 		       handle the initialization unless the member is
 		       static so we make it static below.  */
-		    cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
+		    pedwarn ("ISO C++ forbids initialization of member `%D'",
 				declarator);
-		    cp_pedwarn ("making `%D' static", declarator);
+		    pedwarn ("making `%D' static", declarator);
 		    staticp = 1;
 		  }
 
@@ -11607,7 +11606,7 @@ friend declaration requires class-key, i.e. `friend %#T'",
 		   to change that in TC 1 so that they are allowed in
 		   classes with no user-defined constructors.  */
 		&& staticp)
-	      cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
+	      pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
 			  declarator);
 
 	    if (staticp)
@@ -11699,7 +11698,7 @@ friend declaration requires class-key, i.e. `friend %#T'",
 	       declaring main to be static.  */
 	    if (TREE_CODE (type) == METHOD_TYPE)
 	      {
-		cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
+		pedwarn ("cannot declare member function `%D' to have static linkage", decl);
 		illegal_static = 1;
 	      }
 	    else if (current_function_decl)
@@ -11733,18 +11732,18 @@ friend declaration requires class-key, i.e. `friend %#T'",
 	    DECL_CONTEXT (decl) = ctype;
 	    if (staticp == 1)
 	      {
-                cp_pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
+                pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
 	        staticp = 0;
 		RIDBIT_RESET (RID_STATIC, specbits);
 	      }
 	    if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
 	      {
-		cp_error ("static member `%D' declared `register'", decl);
+		error ("static member `%D' declared `register'", decl);
 		RIDBIT_RESET (RID_REGISTER, specbits);
 	      }
 	    if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
 	      {
-	        cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
+	        pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
 			    decl);
 		RIDBIT_RESET (RID_EXTERN, specbits);
 	      }
@@ -11916,10 +11915,10 @@ check_default_argument (decl, arg)
       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
     {
       if (decl)
-	cp_error ("default argument for `%#D' has type `%T'",
+	error ("default argument for `%#D' has type `%T'",
 		  decl, TREE_TYPE (arg));
       else
-	cp_error ("default argument for parameter of type `%T' has type `%T'",
+	error ("default argument for parameter of type `%T' has type `%T'",
 		  decl_type, TREE_TYPE (arg));
 
       return error_mark_node;
@@ -11936,7 +11935,7 @@ check_default_argument (decl, arg)
 				      NULL);
   if (var)
     {
-      cp_error ("default argument `%E' uses local variable `%D'",
+      error ("default argument `%E' uses local variable `%D'",
 		arg, var);
       return error_mark_node;
     }
@@ -11980,7 +11979,7 @@ grokparms (first_parm)
 	{
 	  /* Give various messages as the need arises.  */
 	  if (TREE_CODE (decl) == STRING_CST)
-	    cp_error ("invalid string constant `%E'", decl);
+	    error ("invalid string constant `%E'", decl);
 	  else if (TREE_CODE (decl) == INTEGER_CST)
 	    error ("invalid integer constant in parameter list, did you forget to give parameter name?");
 	  continue;
@@ -12016,13 +12015,13 @@ grokparms (first_parm)
 	  type = TYPE_MAIN_VARIANT (type);
 	  if (TREE_CODE (type) == METHOD_TYPE)
 	    {
-	      cp_error ("parameter `%D' invalidly declared method type", decl);
+	      error ("parameter `%D' invalidly declared method type", decl);
 	      type = build_pointer_type (type);
 	      TREE_TYPE (decl) = type;
 	    }
 	  else if (TREE_CODE (type) == OFFSET_TYPE)
 	    {
-	      cp_error ("parameter `%D' invalidly declared offset type", decl);
+	      error ("parameter `%D' invalidly declared offset type", decl);
 	      type = build_pointer_type (type);
 	      TREE_TYPE (decl) = type;
 	    }
@@ -12046,7 +12045,7 @@ grokparms (first_parm)
 	          t = TREE_TYPE (t);
 	        }
 	      if (TREE_CODE (t) == ARRAY_TYPE)
-		cp_error ("parameter `%D' includes %s to array of unknown bound `%T'",
+		error ("parameter `%D' includes %s to array of unknown bound `%T'",
 			  decl, ptr ? "pointer" : "reference", t);
 	    }
 
@@ -12213,7 +12212,7 @@ grok_ctor_properties (ctype, decl)
      	 or implicitly defined), there's no need to worry about their
      	 existence.  Theoretically, they should never even be
      	 instantiated, but that's hard to forestall.  */
-      cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
+      error ("invalid constructor; you probably meant `%T (const %T&)'",
 		ctype, ctype);
       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
       return 0;
@@ -12364,13 +12363,13 @@ grok_op_properties (decl, friendp)
 	      || operator_code == COMPONENT_REF
 	      || operator_code == ARRAY_REF
 	      || operator_code == NOP_EXPR)
-	    cp_error ("`%D' must be a nonstatic member function", decl);
+	    error ("`%D' must be a nonstatic member function", decl);
 	  else
 	    {
 	      tree p = argtypes;
 
 	      if (DECL_STATIC_FUNCTION_P (decl))
-		cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
+		error ("`%D' must be either a non-static member function or a non-member function", decl);
 
 	      if (p)
 		for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
@@ -12386,7 +12385,7 @@ grok_op_properties (decl, friendp)
 			|| TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
 		      goto foundaggr;
 		  }
-	      cp_error
+	      error
 		("`%D' must have an argument of class or enumerated type",
 		 decl);
 	    foundaggr:
@@ -12426,7 +12425,7 @@ grok_op_properties (decl, friendp)
       if (operator_code == COND_EXPR)
 	{
 	  /* 13.4.0.3 */
-	  cp_error ("ISO C++ prohibits overloading operator ?:");
+	  error ("ISO C++ prohibits overloading operator ?:");
 	}
       else if (ambi_op_p (operator_code))
 	{
@@ -12476,10 +12475,10 @@ grok_op_properties (decl, friendp)
 		  && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
 		{
 		  if (methodp)
-		    cp_error ("postfix `%D' must take `int' as its argument",
+		    error ("postfix `%D' must take `int' as its argument",
 			      decl);
 		  else
-		    cp_error
+		    error
 		      ("postfix `%D' must take `int' as its second argument",
 		       decl);
 		}
@@ -12487,9 +12486,9 @@ grok_op_properties (decl, friendp)
 	  else
 	    {
 	      if (methodp)
-		cp_error ("`%D' must take either zero or one argument", decl);
+		error ("`%D' must take either zero or one argument", decl);
 	      else
-		cp_error ("`%D' must take either one or two arguments", decl);
+		error ("`%D' must take either one or two arguments", decl);
 	    }
 
 	  /* More Effective C++ rule 6.  */
@@ -12510,13 +12509,13 @@ grok_op_properties (decl, friendp)
 		  if (TREE_CODE (ret) != REFERENCE_TYPE
 		      || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
 				       arg))
-		    cp_warning ("prefix `%D' should return `%T'", decl,
+		    warning ("prefix `%D' should return `%T'", decl,
 				build_reference_type (arg));
 		}
 	      else
 		{
 		  if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
-		    cp_warning ("postfix `%D' should return `%T'", decl, arg);
+		    warning ("postfix `%D' should return `%T'", decl, arg);
 		}
 	    }
 	}
@@ -12525,9 +12524,9 @@ grok_op_properties (decl, friendp)
 	  if (arity != 1)
 	    {
 	      if (methodp)
-		cp_error ("`%D' must take `void'", decl);
+		error ("`%D' must take `void'", decl);
 	      else
-		cp_error ("`%D' must take exactly one argument", decl);
+		error ("`%D' must take exactly one argument", decl);
 	    }
 	}
       else /* if (binary_op_p (operator_code)) */
@@ -12535,9 +12534,9 @@ grok_op_properties (decl, friendp)
 	  if (arity != 2)
 	    {
 	      if (methodp)
-		cp_error ("`%D' must take exactly one argument", decl);
+		error ("`%D' must take exactly one argument", decl);
 	      else
-		cp_error ("`%D' must take exactly two arguments", decl);
+		error ("`%D' must take exactly two arguments", decl);
 	    }
 
 	  /* More Effective C++ rule 7.  */
@@ -12545,7 +12544,7 @@ grok_op_properties (decl, friendp)
 	      && (operator_code == TRUTH_ANDIF_EXPR
 		  || operator_code == TRUTH_ORIF_EXPR
 		  || operator_code == COMPOUND_EXPR))
-	    cp_warning ("user-defined `%D' always evaluates both arguments",
+	    warning ("user-defined `%D' always evaluates both arguments",
 			decl);
 	}
 
@@ -12557,7 +12556,7 @@ grok_op_properties (decl, friendp)
 	      || operator_code == TRUNC_DIV_EXPR
 	      || operator_code == MULT_EXPR)
 	  && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
-	cp_warning ("`%D' should return by value", decl);
+	warning ("`%D' should return by value", decl);
 
       /* [over.oper]/8 */
       for (; argtypes && argtypes != void_list_node;
@@ -12569,10 +12568,10 @@ grok_op_properties (decl, friendp)
 		|| operator_code == POSTDECREMENT_EXPR)
               {
                 if (pedantic)
-                  cp_pedwarn ("`%D' cannot have default arguments", decl);
+                  pedwarn ("`%D' cannot have default arguments", decl);
               }
             else
-              cp_error ("`%D' cannot have default arguments", decl);
+              error ("`%D' cannot have default arguments", decl);
           }
 
     }
@@ -12665,10 +12664,10 @@ xref_tag (code_type_node, name, globalize)
       static int explained;
       tree shadowed;
 
-      cp_warning ("`%s %T' declares a new type at namespace scope",
+      warning ("`%s %T' declares a new type at namespace scope",
 		  tag_name (tag_code), name);
       if (!explained++)
-	cp_warning ("  names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'",
+	warning ("  names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'",
 		    tag_name (tag_code),
 		    constructor_name (current_class_type),
 		    TYPE_IDENTIFIER (t));
@@ -12704,10 +12703,10 @@ xref_tag (code_type_node, name, globalize)
 	     elaborated-type-specifier is ill-formed.  */
 	  if (t != TYPE_MAIN_VARIANT (t)
 	      || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
-	    cp_pedwarn ("using typedef-name `%D' after `%s'",
+	    pedwarn ("using typedef-name `%D' after `%s'",
 			TYPE_NAME (t), tag_name (tag_code));
 	  else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
-	    cp_error ("using template type parameter `%T' after `%s'",
+	    error ("using template type parameter `%T' after `%s'",
 		      t, tag_name (tag_code));
 
 	  ref = t;
@@ -12789,7 +12788,7 @@ xref_tag (code_type_node, name, globalize)
 	 the forward-reference will be altered into a real type.  */
       if (code == ENUMERAL_TYPE)
 	{
-	  cp_error ("use of enum `%#D' without previous declaration", name);
+	  error ("use of enum `%#D' without previous declaration", name);
 
 	  ref = make_node (ENUMERAL_TYPE);
 
@@ -12899,7 +12898,7 @@ xref_basetypes (code_type_node, name, ref, binfo)
 
   if (tag_code == union_type)
     {
-      cp_error ("derived union `%T' invalid", ref);
+      error ("derived union `%T' invalid", ref);
       return;
     }
 
@@ -12943,7 +12942,7 @@ xref_basetypes (code_type_node, name, ref, binfo)
 	      && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
 	      && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
 	{
-	  cp_error ("base type `%T' fails to be a struct or class type",
+	  error ("base type `%T' fails to be a struct or class type",
 		    TREE_VALUE (binfo));
 	  continue;
 	}
@@ -12955,7 +12954,7 @@ xref_basetypes (code_type_node, name, ref, binfo)
       if (!COMPLETE_TYPE_P (basetype)
 	  && ! (current_template_parms && uses_template_parms (basetype)))
 	{
-	  cp_error ("base class `%T' has incomplete type", basetype);
+	  error ("base class `%T' has incomplete type", basetype);
 	  continue;
 	}
       else
@@ -12963,9 +12962,9 @@ xref_basetypes (code_type_node, name, ref, binfo)
 	  if (CLASSTYPE_MARKED (basetype))
 	    {
 	      if (basetype == ref)
-		cp_error ("recursive type `%T' undefined", basetype);
+		error ("recursive type `%T' undefined", basetype);
 	      else
-		cp_error ("duplicate base type `%T' invalid", basetype);
+		error ("duplicate base type `%T' invalid", basetype);
 	      continue;
 	    }
 
@@ -13076,7 +13075,7 @@ start_enum (name)
 
   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
     {
-      cp_error ("multiple definition of `%#T'", enumtype);
+      error ("multiple definition of `%#T'", enumtype);
       cp_error_at ("previous definition here", enumtype);
       /* Clear out TYPE_VALUES, and start again.  */
       TYPE_VALUES (enumtype) = NULL_TREE;
@@ -13252,7 +13251,7 @@ build_enumerator (name, value, enumtype)
 	    }
 	  else
 	    {
-	      cp_error ("enumerator value for `%D' not integer constant", name);
+	      error ("enumerator value for `%D' not integer constant", name);
 	      value = NULL_TREE;
 	    }
 	}
@@ -13272,7 +13271,7 @@ build_enumerator (name, value, enumtype)
 					  integer_one_node);
 
 	      if (tree_int_cst_lt (value, prev_value))
-		cp_error ("overflow in enumeration values at `%D'", name);
+		error ("overflow in enumeration values at `%D'", name);
 	    }
 	  else
 	    value = integer_zero_node;
@@ -13361,7 +13360,7 @@ check_function_type (decl, current_function_parms)
 
   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
     {
-      cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
+      error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
 
       /* Make it return void instead, but don't change the
 	 type of the DECL_RESULT, in case we have a named return value.  */
@@ -13470,7 +13469,7 @@ start_function (declspecs, declarator, attrs, flags)
       restype = TREE_TYPE (fntype);
       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
 	{
-	  cp_error ("semicolon missing after declaration of `%#T'", restype);
+	  error ("semicolon missing after declaration of `%#T'", restype);
 	  shadow_tag (build_tree_list (NULL_TREE, restype));
 	  CLASSTYPE_GOT_SEMICOLON (restype) = 1;
 	  if (TREE_CODE (fntype) == FUNCTION_TYPE)
@@ -13544,7 +13543,7 @@ start_function (declspecs, declarator, attrs, flags)
   if (warn_ecpp
       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
-    cp_warning ("`operator=' should return a reference to `*this'");
+    warning ("`operator=' should return a reference to `*this'");
 
   /* Make the init_value nonzero so pushdecl knows this is not tentative.
      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
@@ -13828,7 +13827,7 @@ store_parm_decls (current_function_parms)
 		  || TREE_CODE (parm) != VOID_TYPE)
 		pushdecl (parm);
 	      else
-		cp_error ("parameter `%D' declared void", parm);
+		error ("parameter `%D' declared void", parm);
 
 	      cleanup = (processing_template_decl
 			 ? NULL_TREE
@@ -14208,7 +14207,7 @@ start_method (declspecs, declarator, attrlist)
 	{
 	  if (DECL_CONTEXT (fndecl)
 	      && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
-	    cp_error ("`%D' is already defined in class `%T'", fndecl,
+	    error ("`%D' is already defined in class `%T'", fndecl,
 	              DECL_CONTEXT (fndecl));
 	}
       return void_type_node;
@@ -14359,7 +14358,7 @@ hack_incomplete_structures (type)
 		  cleanup = maybe_build_cleanup (decl);
 		  expand_decl_init (decl);
 		  if (! expand_decl_cleanup (decl, cleanup))
-		    cp_error ("parser lost in parsing declaration of `%D'",
+		    error ("parser lost in parsing declaration of `%D'",
 			      decl);
 		}
 	      *list = TREE_CHAIN (*list);
@@ -14444,7 +14443,7 @@ revert_static_member_fn (decl)
 
   if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
       != TYPE_UNQUALIFIED)
-    cp_error ("static member function `%#D' declared with type qualifiers",
+    error ("static member function `%#D' declared with type qualifiers",
 	      decl);
 
   args = TREE_CHAIN (args);
diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c
index 0383593..73c934e 100644
--- a/gcc/cp/decl2.c
+++ b/gcc/cp/decl2.c
@@ -758,7 +758,7 @@ grok_method_quals (ctype, function, quals)
   while (quals);
 
   if (dup_quals != TYPE_UNQUALIFIED)
-    cp_error ("duplicate type qualifiers in %s declaration",
+    error ("duplicate type qualifiers in %s declaration",
 	      TREE_CODE (function) == FUNCTION_DECL 
 	      ? "member function" : "type");
 
@@ -797,7 +797,7 @@ warn_if_unknown_interface (decl)
 	  lineno = TINST_LINE (til);
 	  input_filename = TINST_FILE (til);
 	}
-      cp_warning ("template `%#D' instantiated in file without #pragma interface",
+      warning ("template `%#D' instantiated in file without #pragma interface",
 		  decl);
       lineno = sl;
       input_filename = sf;
@@ -1066,7 +1066,7 @@ grok_array_decl (array_expr, index_exp)
     array_expr = p2, index_exp = i1;
   else
     {
-      cp_error ("invalid types `%T[%T]' for array subscript",
+      error ("invalid types `%T[%T]' for array subscript",
 		type, TREE_TYPE (index_exp));
       return error_mark_node;
     }
@@ -1114,7 +1114,7 @@ delete_sanity (exp, size, doing_vec, use_global_delete)
 
   if (t == NULL_TREE || t == error_mark_node)
     {
-      cp_error ("type `%#T' argument given to `delete', expected pointer",
+      error ("type `%#T' argument given to `delete', expected pointer",
 		TREE_TYPE (exp));
       return error_mark_node;
     }
@@ -1139,7 +1139,7 @@ delete_sanity (exp, size, doing_vec, use_global_delete)
   /* Deleting ptr to void is undefined behaviour [expr.delete/3].  */
   if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
     {
-      cp_warning ("deleting `%T' is undefined", type);
+      warning ("deleting `%T' is undefined", type);
       doing_vec = 0;
     }
 
@@ -1147,7 +1147,7 @@ delete_sanity (exp, size, doing_vec, use_global_delete)
   if (TREE_CODE (t) == ADDR_EXPR
       && TREE_CODE (TREE_OPERAND (t, 0)) == VAR_DECL
       && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == ARRAY_TYPE)
-    cp_warning ("deleting array `%#D'", TREE_OPERAND (t, 0));
+    warning ("deleting array `%#D'", TREE_OPERAND (t, 0));
 
   /* Deleting a pointer with the value zero is valid and has no effect.  */
   if (integer_zerop (t))
@@ -1194,7 +1194,7 @@ check_member_template (tmpl)
 	/* 14.5.2.2 [temp.mem]
 	   
 	   A local class shall not have member templates. */
-	cp_error ("invalid declaration of member template `%#D' in local class",
+	error ("invalid declaration of member template `%#D' in local class",
 		  decl);
       
       if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
@@ -1202,7 +1202,7 @@ check_member_template (tmpl)
 	  /* 14.5.2.3 [temp.mem]
 
 	     A member function template shall not be virtual.  */
-	  cp_error 
+	  error 
 	    ("invalid use of `virtual' in template declaration of `%#D'",
 	     decl);
 	  DECL_VIRTUAL_P (decl) = 0;
@@ -1213,7 +1213,7 @@ check_member_template (tmpl)
       DECL_IGNORED_P (tmpl) = 1;
     } 
   else
-    cp_error ("template declaration of `%#D'", decl);
+    error ("template declaration of `%#D'", decl);
 }
 
 /* Return true iff TYPE is a valid Java parameter or return type. */
@@ -1263,7 +1263,7 @@ check_java_method (method)
   tree ret_type = TREE_TYPE (TREE_TYPE (method));
   if (! acceptable_java_type (ret_type))
     {
-      cp_error ("Java method '%D' has non-Java return type `%T'",
+      error ("Java method '%D' has non-Java return type `%T'",
 		method, ret_type);
       jerr++;
     }
@@ -1272,7 +1272,7 @@ check_java_method (method)
       tree type = TREE_VALUE (arg_types);
       if (! acceptable_java_type (type))
 	{
-	  cp_error ("Java method '%D' has non-Java parameter type `%T'",
+	  error ("Java method '%D' has non-Java parameter type `%T'",
 		    method, type);
 	  jerr++;
 	}
@@ -1368,7 +1368,7 @@ check_classfn (ctype, function)
   if (methods != end && *methods)
     {
       tree fndecl = *methods;
-      cp_error ("prototype for `%#D' does not match any in class `%T'",
+      error ("prototype for `%#D' does not match any in class `%T'",
 		function, ctype);
       cp_error_at ("candidate%s: %+#D", OVL_NEXT (fndecl) ? "s are" : " is",
 		   OVL_CURRENT (fndecl));
@@ -1381,7 +1381,7 @@ check_classfn (ctype, function)
       if (!COMPLETE_TYPE_P (ctype))
         incomplete_type_error (function, ctype);
       else
-        cp_error ("no `%#D' member function declared in class `%T'",
+        error ("no `%#D' member function declared in class `%T'",
 		  function, ctype);
     }
 
@@ -1491,10 +1491,10 @@ grokfield (declarator, declspecs, init, asmspec_tree, attrlist)
 	 Explain that to the user.  */
       static int explained;
 
-      cp_error ("invalid data member initialization");
+      error ("invalid data member initialization");
       if (!explained)
 	{
-	  cp_error ("(use `=' to initialize static data members)");
+	  error ("(use `=' to initialize static data members)");
 	  explained = 1;
 	}
 
@@ -1534,7 +1534,7 @@ grokfield (declarator, declspecs, init, asmspec_tree, attrlist)
   if (DECL_NAME (value) != NULL_TREE
       && IDENTIFIER_POINTER (DECL_NAME (value))[0] == '_'
       && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (value)), "_vptr"))
-    cp_error ("member `%D' conflicts with virtual function table field name",
+    error ("member `%D' conflicts with virtual function table field name",
 	      value);
 
   /* Stash away type declarations.  */
@@ -1554,7 +1554,7 @@ grokfield (declarator, declspecs, init, asmspec_tree, attrlist)
 
   if (DECL_IN_AGGR_P (value))
     {
-      cp_error ("`%D' is already defined in `%T'", value,
+      error ("`%D' is already defined in `%T'", value,
 		DECL_CONTEXT (value));
       return void_type_node;
     }
@@ -1628,7 +1628,7 @@ grokfield (declarator, declspecs, init, asmspec_tree, attrlist)
   if (TREE_CODE (value) == FIELD_DECL)
     {
       if (asmspec)
-	cp_error ("`asm' specifiers are not permitted on non-static data members");
+	error ("`asm' specifiers are not permitted on non-static data members");
       if (DECL_INITIAL (value) == error_mark_node)
 	init = error_mark_node;
       cp_finish_decl (value, init, NULL_TREE, flags);
@@ -1680,24 +1680,24 @@ grokbitfield (declarator, declspecs, width)
 
   if (TREE_CODE (value) == TYPE_DECL)
     {
-      cp_error ("cannot declare `%D' to be a bitfield type", value);
+      error ("cannot declare `%D' to be a bitfield type", value);
       return NULL_TREE;
     }
 
-  /* Usually, finish_struct_1 catches bitifields with invalid types.
+  /* Usually, finish_struct_1 catches bitfields with invalid types.
      But, in the case of bitfields with function type, we confuse
      ourselves into thinking they are member functions, so we must
      check here.  */
   if (TREE_CODE (value) == FUNCTION_DECL)
     {
-      cp_error ("cannot declare bitfield `%D' with function type",
-		DECL_NAME (value));
+      error ("cannot declare bitfield `%D' with function type",
+	     DECL_NAME (value));
       return NULL_TREE;
     }
 
   if (DECL_IN_AGGR_P (value))
     {
-      cp_error ("`%D' is already defined in the class %T", value,
+      error ("`%D' is already defined in the class %T", value,
 		  DECL_CONTEXT (value));
       return void_type_node;
     }
@@ -1706,7 +1706,7 @@ grokbitfield (declarator, declspecs, width)
 
   if (TREE_STATIC (value))
     {
-      cp_error ("static member `%D' cannot be a bitfield", value);
+      error ("static member `%D' cannot be a bitfield", value);
       return NULL_TREE;
     }
   cp_finish_decl (value, NULL_TREE, NULL_TREE, 0);
@@ -1775,11 +1775,11 @@ grok_function_init (decl, init)
   tree type = TREE_TYPE (decl);
 
   if (TREE_CODE (type) == FUNCTION_TYPE)
-    cp_error ("initializer specified for non-member function `%D'", decl);
+    error ("initializer specified for non-member function `%D'", decl);
   else if (integer_zerop (init))
     DECL_PURE_VIRTUAL_P (decl) = 1;
   else
-    cp_error ("invalid initializer for virtual method `%D'", decl);
+    error ("invalid initializer for virtual method `%D'", decl);
 }
 
 void
@@ -2056,7 +2056,7 @@ coerce_new_type (type)
   my_friendly_assert (TREE_CODE (type) == FUNCTION_TYPE, 20001107);
   
   if (!same_type_p (TREE_TYPE (type), ptr_type_node))
-    e = 1, cp_error ("`operator new' must return type `%T'", ptr_type_node);
+    e = 1, error ("`operator new' must return type `%T'", ptr_type_node);
 
   if (!args || args == void_list_node
       || !same_type_p (TREE_VALUE (args), c_size_type_node))
@@ -2064,7 +2064,7 @@ coerce_new_type (type)
       e = 2;
       if (args && args != void_list_node)
         args = TREE_CHAIN (args);
-      cp_error ("`operator new' takes type `size_t' (`%T') as first parameter", c_size_type_node);
+      error ("`operator new' takes type `size_t' (`%T') as first parameter", c_size_type_node);
     }
   switch (e)
   {
@@ -2091,7 +2091,7 @@ coerce_delete_type (type)
   my_friendly_assert (TREE_CODE (type) == FUNCTION_TYPE, 20001107);
 
   if (!same_type_p (TREE_TYPE (type), void_type_node))
-    e = 1, cp_error ("`operator delete' must return type `%T'", void_type_node);
+    e = 1, error ("`operator delete' must return type `%T'", void_type_node);
 
   if (!args || args == void_list_node
       || !same_type_p (TREE_VALUE (args), ptr_type_node))
@@ -2099,7 +2099,7 @@ coerce_delete_type (type)
       e = 2;
       if (args && args != void_list_node)
         args = TREE_CHAIN (args);
-      cp_error ("`operator delete' takes type `%T' as first parameter", ptr_type_node);
+      error ("`operator delete' takes type `%T' as first parameter", ptr_type_node);
     }
   switch (e)
   {
@@ -4198,7 +4198,7 @@ ambiguous_decl (name, old, new, flags)
 		 repeat ourselves.  */
 	      if (BINDING_VALUE (old) != error_mark_node)
 		{
-		  cp_error ("use of `%D' is ambiguous", name);
+		  error ("use of `%D' is ambiguous", name);
 		  cp_error_at ("  first declared as `%#D' here",
 			       BINDING_VALUE (old));
 		}
@@ -4217,7 +4217,7 @@ ambiguous_decl (name, old, new, flags)
     {
       if (flags & LOOKUP_COMPLAIN)
         {
-          cp_error ("`%D' denotes an ambiguous type",name);
+          error ("`%D' denotes an ambiguous type",name);
           cp_error_at ("  first type here", BINDING_TYPE (old));
           cp_error_at ("  other type here", type);
         }
@@ -4316,7 +4316,7 @@ set_decl_namespace (decl, scope, friendp)
   
   /* It is ok for friends to be qualified in parallel space.  */
   if (!friendp && !is_namespace_ancestor (current_namespace, scope))
-    cp_error ("declaration of `%D' not in a namespace surrounding `%D'",
+    error ("declaration of `%D' not in a namespace surrounding `%D'",
 	      decl, scope);
   DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
   if (scope != current_namespace)
@@ -4350,7 +4350,7 @@ set_decl_namespace (decl, scope, friendp)
   else
     return;
  complain:
-  cp_error ("`%D' should have been declared inside `%D'",
+  error ("`%D' should have been declared inside `%D'",
 	    decl, scope);
 } 
 
@@ -4486,7 +4486,7 @@ add_function (k, fn)
 	}
       cp_error_at ("`%D' is not a function,", f1);
       cp_error_at ("  conflict with `%D'", f2);
-      cp_error ("  in call to `%D'", k->name);
+      error ("  in call to `%D'", k->name);
       return 1;
     }
 
@@ -4799,7 +4799,7 @@ do_namespace_alias (alias, namespace)
   if (TREE_CODE (namespace) != NAMESPACE_DECL)
     {
       /* The parser did not find it, so it's not there. */
-      cp_error ("unknown namespace `%D'", namespace);
+      error ("unknown namespace `%D'", namespace);
       return;
     }
 
@@ -4833,9 +4833,9 @@ validate_nonmember_using_decl (decl, scope, name)
           if(TREE_CODE (*scope) != NAMESPACE_DECL)
             {
               if (TYPE_P (*scope))
-                cp_error ("`%T' is not a namespace", *scope);
+                error ("`%T' is not a namespace", *scope);
               else
-                cp_error ("`%D' is not a namespace", *scope);
+                error ("`%D' is not a namespace", *scope);
               return NULL_TREE;
             }
           
@@ -4844,7 +4844,7 @@ validate_nonmember_using_decl (decl, scope, name)
           if (TREE_CODE (*name) == TEMPLATE_ID_EXPR)
             {
               *name = TREE_OPERAND (*name, 0);
-              cp_error ("a using-declaration cannot specify a template-id.  Try `using %D'", *name);
+              error ("a using-declaration cannot specify a template-id.  Try `using %D'", *name);
               return NULL_TREE;
             }
         }
@@ -4858,7 +4858,7 @@ validate_nonmember_using_decl (decl, scope, name)
     }
   else if (TREE_CODE (decl) == NAMESPACE_DECL)
     {
-      cp_error ("namespace `%D' not allowed in using-declaration", decl);
+      error ("namespace `%D' not allowed in using-declaration", decl);
       return NULL_TREE;
     }
   else
@@ -4887,7 +4887,7 @@ do_nonmember_using_decl (scope, name, oldval, oldtype, newval, newtype)
 
   if (!BINDING_VALUE (decls) && !BINDING_TYPE (decls))
     {
-      cp_error ("`%D' not declared", name);
+      error ("`%D' not declared", name);
       return;
     }
 
@@ -4929,7 +4929,7 @@ do_nonmember_using_decl (scope, name, oldval, oldtype, newval, newtype)
 		     this scope with the same parameter types. If both
 	             are the same extern "C" functions, that's ok.  */
                   if (!decls_match (new_fn, old_fn))
-    	            cp_error ("`%D' is already declared in this scope", name);
+    	            error ("`%D' is already declared in this scope", name);
 		  break;
 		}
 	    }
@@ -4956,7 +4956,7 @@ do_nonmember_using_decl (scope, name, oldval, oldtype, newval, newtype)
   *newtype = BINDING_TYPE (decls);
   if (oldtype && *newtype && oldtype != *newtype)
     {
-      cp_error ("using declaration `%D' introduced ambiguous type `%T'",
+      error ("using declaration `%D' introduced ambiguous type `%T'",
 		name, oldtype);
       return;
     }
@@ -5047,19 +5047,19 @@ do_class_using_decl (decl)
   if (TREE_CODE (decl) != SCOPE_REF
       || !TYPE_P (TREE_OPERAND (decl, 0)))
     {
-      cp_error ("using-declaration for non-member at class scope");
+      error ("using-declaration for non-member at class scope");
       return NULL_TREE;
     }
   name = TREE_OPERAND (decl, 1);
   if (TREE_CODE (name) == BIT_NOT_EXPR)
     {
-      cp_error ("using-declaration for destructor");
+      error ("using-declaration for destructor");
       return NULL_TREE;
     }
   else if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
     {
       name = TREE_OPERAND (name, 0);
-      cp_error ("a using-declaration cannot specify a template-id.  Try  `using %T::%D'", TREE_OPERAND (decl, 0), name);
+      error ("a using-declaration cannot specify a template-id.  Try  `using %T::%D'", TREE_OPERAND (decl, 0), name);
       return NULL_TREE;
     }
   if (TREE_CODE (name) == TYPE_DECL || TREE_CODE (name) == TEMPLATE_DECL)
@@ -5088,13 +5088,13 @@ do_using_directive (namespace)
     {
       /* Lookup in lexer did not find a namespace. */
       if (!processing_template_decl)
-	cp_error ("namespace `%T' undeclared", namespace);
+	error ("namespace `%T' undeclared", namespace);
       return;
     }
   if (TREE_CODE (namespace) != NAMESPACE_DECL)
     {
       if (!processing_template_decl)
-	cp_error ("`%T' is not a namespace", namespace);
+	error ("`%T' is not a namespace", namespace);
       return;
     }
   namespace = ORIGINAL_NAMESPACE (namespace);
@@ -5198,13 +5198,13 @@ handle_class_head (aggr, scope, id)
           /* We've been given AGGR SCOPE::ID, when we're already inside SCOPE.
              Be nice about it.  */
           if (pedantic)
-            cp_pedwarn ("extra qualification `%T::' on member `%D' ignored",
+            pedwarn ("extra qualification `%T::' on member `%D' ignored",
                         FROB_CONTEXT (scope), id);
         }
       else if (scope != global_namespace)
-	cp_error ("`%T' does not have a nested type named `%D'", scope, id);
+	error ("`%T' does not have a nested type named `%D'", scope, id);
       else
-	cp_error ("no file-scope type named `%D'", id);
+	error ("no file-scope type named `%D'", id);
       
       /* Inject it at the current scope.  */
       if (! decl)
diff --git a/gcc/cp/error.c b/gcc/cp/error.c
index 5b1e6f8..d113470 100644
--- a/gcc/cp/error.c
+++ b/gcc/cp/error.c
@@ -939,7 +939,7 @@ dump_decl (t, flags)
       break;
 
       /* These special cases are duplicated here so that other functions
-	 can feed identifiers to cp_error and get them demangled properly.  */
+	 can feed identifiers to error and get them demangled properly.  */
     case IDENTIFIER_NODE:
       if (IDENTIFIER_TYPENAME_P (t))
 	{
@@ -1093,7 +1093,7 @@ dump_template_decl (t, flags)
 
 /* Pretty print a function decl. There are several ways we want to print a
    function declaration. The TFF_ bits in FLAGS tells us how to behave.
-   As cp_error can only apply the '#' flag once to give 0 and 1 for V, there
+   As error can only apply the '#' flag once to give 0 and 1 for V, there
    is %D which doesn't print the throw specs, and %F which does. */
 
 static void
@@ -2215,7 +2215,7 @@ cp_line_of (t)
   return line;
 }
 
-/* Now the interfaces from cp_error et al to dump_type et al. Each takes an
+/* Now the interfaces from error et al to dump_type et al. Each takes an
    on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
    function.  */
 
diff --git a/gcc/cp/except.c b/gcc/cp/except.c
index 32f2458..3f3cdcf 100644
--- a/gcc/cp/except.c
+++ b/gcc/cp/except.c
@@ -242,7 +242,7 @@ decl_is_java_type (decl, err)
 	  && TYPE_FOR_JAVA (TREE_TYPE (decl)))
 	{
 	  /* Can't throw a reference.  */
-	  cp_error ("type `%T' is disallowed in Java `throw' or `catch'",
+	  error ("type `%T' is disallowed in Java `throw' or `catch'",
 		    decl);
 	}
 
@@ -260,7 +260,7 @@ decl_is_java_type (decl, err)
 	  if (! DERIVED_FROM_P (jthrow_node, TREE_TYPE (decl)))
 	    {
 	      /* Thrown object must be a Throwable.  */
-	      cp_error ("type `%T' is not derived from `java::lang::Throwable'",
+	      error ("type `%T' is not derived from `java::lang::Throwable'",
 			TREE_TYPE (decl));
 	    }
 	}
@@ -555,7 +555,7 @@ build_throw (exp)
     return build_min (THROW_EXPR, void_type_node, exp);
 
   if (exp == null_node)
-    cp_warning ("throwing NULL, which has integral, not pointer type");
+    warning ("throwing NULL, which has integral, not pointer type");
   
   if (exp != NULL_TREE)
     {
@@ -772,7 +772,7 @@ is_admissible_throw_operand (expr)
             conversion.  */
   else if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
     {
-      cp_error ("expression '%E' of abstract class type '%T' cannot be used in throw-expression", expr, type);
+      error ("expression '%E' of abstract class type '%T' cannot be used in throw-expression", expr, type);
       return false;
     }
 
@@ -860,10 +860,10 @@ check_handlers_1 (master, handlers)
 	&& can_convert_eh (type, TREE_TYPE (handler)))
       {
 	lineno = STMT_LINENO (handler);
-	cp_warning ("exception of type `%T' will be caught",
+	warning ("exception of type `%T' will be caught",
 		    TREE_TYPE (handler));
 	lineno = STMT_LINENO (master);
-	cp_warning ("   by earlier handler for `%T'", type);
+	warning ("   by earlier handler for `%T'", type);
 	break;
       }
 }
@@ -883,7 +883,7 @@ check_handlers (handlers)
       else if (TREE_TYPE (handler) == NULL_TREE)
 	{
 	  lineno = STMT_LINENO (handler);
-	  cp_pedwarn
+	  pedwarn
 	    ("`...' handler must be the last handler for its try block");
 	}
       else
diff --git a/gcc/cp/friend.c b/gcc/cp/friend.c
index 95373e8..c43e034 100644
--- a/gcc/cp/friend.c
+++ b/gcc/cp/friend.c
@@ -152,7 +152,7 @@ add_friend (type, decl)
 	    {
 	      if (decl == TREE_VALUE (friends))
 		{
-		  cp_warning ("`%D' is already a friend of class `%T'",
+		  warning ("`%D' is already a friend of class `%T'",
 			      decl, type);
 		  cp_warning_at ("previous friend declaration of `%D'",
 				 TREE_VALUE (friends));
@@ -194,7 +194,7 @@ make_friend_class (type, friend_type)
 
   if (! IS_AGGR_TYPE (friend_type))
     {
-      cp_error ("invalid type `%T' declared `friend'", friend_type);
+      error ("invalid type `%T' declared `friend'", friend_type);
       return;
     }
 
@@ -206,7 +206,7 @@ make_friend_class (type, friend_type)
 	 
 	 Friend declarations shall not declare partial
 	 specializations.  */
-      cp_error ("partial specialization `%T' declared `friend'",
+      error ("partial specialization `%T' declared `friend'",
 		friend_type);
       return;
     }
@@ -218,7 +218,7 @@ make_friend_class (type, friend_type)
     is_template_friend = 1;
   else if (same_type_p (type, friend_type))
     {
-      cp_pedwarn ("class `%T' is implicitly friends with itself",
+      pedwarn ("class `%T' is implicitly friends with itself",
 	          type);
       return;
     }
@@ -236,19 +236,19 @@ make_friend_class (type, friend_type)
   else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
     {
       /* template <class T> friend typename S<T>::X; */
-      cp_error ("typename type `%#T' declared `friend'", friend_type);
+      error ("typename type `%#T' declared `friend'", friend_type);
       return;
     }
   else if (TREE_CODE (friend_type) == TEMPLATE_TYPE_PARM)
     {
       /* template <class T> friend class T; */
-      cp_error ("template parameter type `%T' declared `friend'", friend_type);
+      error ("template parameter type `%T' declared `friend'", friend_type);
       return;
     }
   else if (!CLASSTYPE_TEMPLATE_INFO (friend_type))
     {
       /* template <class T> friend class A; where A is not a template */
-      cp_error ("`%#T' is not a template", friend_type);
+      error ("`%#T' is not a template", friend_type);
       return;
     }
 
@@ -265,7 +265,7 @@ make_friend_class (type, friend_type)
 	      same_type_p (TREE_VALUE (classes), friend_type)))
     classes = TREE_CHAIN (classes);
   if (classes) 
-    cp_warning ("`%T' is already a friend of `%T'",
+    warning ("`%T' is already a friend of `%T'",
 		TREE_VALUE (classes), type);
   else
     {
@@ -361,7 +361,7 @@ do_friend (ctype, declarator, decl, parmdecls, attrlist,
 	    add_friend (current_class_type, decl);
 	}
       else
-	cp_error ("member `%D' declared as friend before type `%T' defined",
+	error ("member `%D' declared as friend before type `%T' defined",
 		  decl, ctype);
     }
   /* A global friend.
@@ -416,7 +416,7 @@ do_friend (ctype, declarator, decl, parmdecls, attrlist,
 	  if (warn)
 	    {
 	      static int explained;
-	      cp_warning ("friend declaration `%#D' declares a non-template function", decl);
+	      warning ("friend declaration `%#D' declares a non-template function", decl);
 	      if (! explained)
 		{
 		  warning ("(if this is not what you intended, make sure the function template has already been declared and add <> after the function name here) -Wno-non-template-friend disables this warning");
diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index c0cc3f3..b97bbba 100644
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -281,13 +281,13 @@ perform_member_init (member, init, explicit)
 	    {
 	      init = build_default_init (type);
 	      if (TREE_CODE (type) == REFERENCE_TYPE)
-		cp_warning
+		warning
 		  ("default-initialization of `%#D', which has reference type",
 		   member);
 	    }
 	  /* member traversal: note it leaves init NULL */
 	  else if (TREE_CODE (type) == REFERENCE_TYPE)
-	    cp_pedwarn ("uninitialized reference member `%D'", member);
+	    pedwarn ("uninitialized reference member `%D'", member);
 	}
       else if (TREE_CODE (init) == TREE_LIST)
 	{
@@ -425,7 +425,7 @@ sort_member_init (t, member_init_list)
       /* If there was already an explicit initializer for this field,
 	 issue an error.  */
       if (TREE_TYPE (f))
-	cp_error ("multiple initializations given for member `%D'",
+	error ("multiple initializations given for member `%D'",
 		  initialized_field);
       else
 	{
@@ -497,7 +497,7 @@ sort_member_init (t, member_init_list)
 		  if (same_type_p (last_field_type, field_type))
 		    {
 		      if (TREE_CODE (field_type) == UNION_TYPE)
-			cp_error ("initializations for multiple members of `%T'",
+			error ("initializations for multiple members of `%T'",
 				  last_field_type);
 		      done = 1;
 		      break;
@@ -628,7 +628,7 @@ sort_base_init (t, base_init_list, rbase_ptr, vbase_ptr)
 	    }
 	  else if (binfo == base_binfo)
 	    {
-	      cp_error ("base class `%T' already initialized", 
+	      error ("base class `%T' already initialized", 
 			BINFO_TYPE (binfo));
 	      break;
 	    }
@@ -699,7 +699,7 @@ emit_base_init (mem_init_list, base_init_list)
 	  init = NULL_TREE;
 	  if (extra_warnings 
 	      && DECL_COPY_CONSTRUCTOR_P (current_function_decl))
-	    cp_warning ("base class `%#T' should be explicitly initialized in the copy constructor",
+	    warning ("base class `%#T' should be explicitly initialized in the copy constructor",
 			BINFO_TYPE (base_binfo));
 	}
 
@@ -742,7 +742,7 @@ emit_base_init (mem_init_list, base_init_list)
 	  if (warn_ecpp && init == NULL_TREE
 	      && !DECL_ARTIFICIAL (member)
 	      && TREE_CODE (TREE_TYPE (member)) != ARRAY_TYPE)
-	    cp_warning ("`%D' should be initialized in the member initialization list", member);	    
+	    warning ("`%D' should be initialized in the member initialization list", member);	    
 	}
 
       perform_member_init (member, init, from_init_list);
@@ -984,13 +984,13 @@ member_init_ok_or_else (field, type, member_name)
     return 0;
   if (field == NULL_TREE || initializing_context (field) != type)
     {
-      cp_error ("class `%T' does not have any field named `%D'", type,
+      error ("class `%T' does not have any field named `%D'", type,
 		member_name);
       return 0;
     }
   if (TREE_STATIC (field))
     {
-      cp_error ("field `%#D' is static; the only point of initialization is its definition",
+      error ("field `%#D' is static; the only point of initialization is its definition",
 		field);
       return 0;
     }
@@ -1029,14 +1029,14 @@ expand_member_init (exp, name, init)
       switch (CLASSTYPE_N_BASECLASSES (type))
 	{
 	case 0:
-	  cp_error ("unnamed initializer for `%T', which has no base classes",
+	  error ("unnamed initializer for `%T', which has no base classes",
 		    type);
 	  return NULL_TREE;
 	case 1:
 	  basetype = TYPE_BINFO_BASETYPE (type, 0);
 	  break;
 	default:
-	  cp_error ("unnamed initializer for `%T', which uses multiple inheritance",
+	  error ("unnamed initializer for `%T', which uses multiple inheritance",
 		    type);
 	  return NULL_TREE;
       }
@@ -1065,10 +1065,10 @@ expand_member_init (exp, name, init)
       else
 	{
 	  if (TYPE_USES_VIRTUAL_BASECLASSES (type))
-	    cp_error ("type `%D' is not a direct or virtual base of `%T'",
+	    error ("type `%D' is not a direct or virtual base of `%T'",
 		      name, type);
 	  else
-	    cp_error ("type `%D' is not a direct base of `%T'",
+	    error ("type `%D' is not a direct base of `%T'",
 		      name, type);
 	  return NULL_TREE;
 	}
@@ -1162,7 +1162,7 @@ build_aggr_init (exp, init, flags)
 	       COMPLEX zees(1.0, 0.0)[10];
 	     }
 	  */
-	  cp_error ("bad array initializer");
+	  error ("bad array initializer");
 	  return error_mark_node;
 	}
       if (cp_type_quals (type) != TYPE_UNQUALIFIED)
@@ -1354,7 +1354,7 @@ is_aggr_type (type, or_else)
       && TREE_CODE (type) != BOUND_TEMPLATE_TEMPLATE_PARM)
     {
       if (or_else)
-	cp_error ("`%T' is not an aggregate type", type);
+	error ("`%T' is not an aggregate type", type);
       return 0;
     }
   return 1;
@@ -1377,7 +1377,7 @@ get_aggr_from_typedef (name, or_else)
   else
     {
       if (or_else)
-	cp_error ("`%T' fails to be an aggregate typedef", name);
+	error ("`%T' fails to be an aggregate typedef", name);
       return NULL_TREE;
     }
 
@@ -1386,7 +1386,7 @@ get_aggr_from_typedef (name, or_else)
       && TREE_CODE (type) != BOUND_TEMPLATE_TEMPLATE_PARM)
     {
       if (or_else)
-	cp_error ("type `%T' is of non-aggregate type", type);
+	error ("type `%T' is of non-aggregate type", type);
       return NULL_TREE;
     }
   return type;
@@ -1488,7 +1488,7 @@ build_member_call (type, name, parmlist)
 
   if (dtor)
     {
-      cp_error ("cannot call destructor `%T::~%T' without object", type,
+      error ("cannot call destructor `%T::~%T' without object", type,
 		method_name);
       return error_mark_node;
     }
@@ -1530,7 +1530,7 @@ build_member_call (type, name, parmlist)
 	{
 	  if (is_dummy_object (decl))
 	    {
-	      cp_error ("invalid use of non-static field `%D'", t);
+	      error ("invalid use of non-static field `%D'", t);
 	      return error_mark_node;
 	    }
 	  decl = build (COMPONENT_REF, TREE_TYPE (t), decl, t);
@@ -1539,7 +1539,7 @@ build_member_call (type, name, parmlist)
 	decl = t;
       else
 	{
-	  cp_error ("invalid use of member `%D'", t);
+	  error ("invalid use of member `%D'", t);
 	  return error_mark_node;
 	}
       if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl)))
@@ -1549,7 +1549,7 @@ build_member_call (type, name, parmlist)
     }
   else
     {
-      cp_error ("no method `%T::%D'", type, name);
+      error ("no method `%T::%D'", type, name);
       return error_mark_node;
     }
 }
@@ -1634,7 +1634,7 @@ build_offset_ref (type, name)
   if (TREE_CODE (name) == BIT_NOT_EXPR)
     {
       if (! check_dtor_name (type, name))
-	cp_error ("qualified type `%T' does not match destructor name `~%T'",
+	error ("qualified type `%T' does not match destructor name `~%T'",
 		  type, TREE_OPERAND (name, 0));
       name = dtor_identifier;
     }
@@ -1642,7 +1642,7 @@ build_offset_ref (type, name)
   if (!COMPLETE_TYPE_P (complete_type (type))
       && !TYPE_BEING_DEFINED (type))
     {
-      cp_error ("incomplete type `%T' does not have member `%D'", type,
+      error ("incomplete type `%T' does not have member `%D'", type,
 		name);
       return error_mark_node;
     }
@@ -1711,7 +1711,7 @@ build_offset_ref (type, name)
 
   if (t == NULL_TREE)
     {
-      cp_error ("`%D' is not a member of type `%T'", name, type);
+      error ("`%D' is not a member of type `%T'", name, type);
       return error_mark_node;
     }
 
@@ -1730,7 +1730,7 @@ build_offset_ref (type, name)
 
   if (TREE_CODE (t) == FIELD_DECL && DECL_C_BIT_FIELD (t))
     {
-      cp_error ("illegal pointer to bit field `%D'", t);
+      error ("illegal pointer to bit field `%D'", t);
       return error_mark_node;
     }
 
@@ -1859,7 +1859,7 @@ resolve_offset_ref (exp)
     {
       if (addr == error_mark_node)
 	{
-	  cp_error ("object missing in `%E'", exp);
+	  error ("object missing in `%E'", exp);
 	  return error_mark_node;
 	}
 
@@ -2416,7 +2416,7 @@ build_new_1 (exp)
       if (init == void_zero_node)
 	init = build_default_init (full_type);
       else if (init && pedantic && has_array)
-	cp_pedwarn ("ISO C++ forbids initialization in array new");
+	pedwarn ("ISO C++ forbids initialization in array new");
 
       if (has_array)
 	init_expr = build_vec_init (init_expr, init, 0);
@@ -2515,7 +2515,7 @@ build_new_1 (exp)
 	}
     }
   else if (CP_TYPE_CONST_P (true_type))
-    cp_error ("uninitialized const in `new' of `%#T'", true_type);
+    error ("uninitialized const in `new' of `%#T'", true_type);
 
   /* Now build up the return value in reverse order.  */
 
diff --git a/gcc/cp/lex.c b/gcc/cp/lex.c
index 41a4db5..82b14ae 100644
--- a/gcc/cp/lex.c
+++ b/gcc/cp/lex.c
@@ -1000,7 +1000,7 @@ check_for_missing_semicolon (type)
 	error ("semicolon missing after %s declaration",
 	       TREE_CODE (type) == ENUMERAL_TYPE ? "enum" : "struct");
       else
-	cp_error ("semicolon missing after declaration of `%T'", type);
+	error ("semicolon missing after declaration of `%T'", type);
       shadow_tag (build_tree_list (0, type));
     }
   /* Could probably also hack cases where class { ... } f (); appears.  */
@@ -1248,12 +1248,12 @@ do_identifier (token, parsing, args)
       else if (IDENTIFIER_OPNAME_P (token))
 	{
 	  if (token != ansi_opname (ERROR_MARK))
-	    cp_error ("`%D' not defined", token);
+	    error ("`%D' not defined", token);
 	  id = error_mark_node;
 	}
       else if (current_function_decl == 0)
 	{
-	  cp_error ("`%D' was not declared in this scope", token);
+	  error ("`%D' was not declared in this scope", token);
 	  id = error_mark_node;
 	}
       else
@@ -1263,7 +1263,7 @@ do_identifier (token, parsing, args)
 	    {
 	      static int undeclared_variable_notice;
 
-	      cp_error ("`%D' undeclared (first use this function)", token);
+	      error ("`%D' undeclared (first use this function)", token);
 
 	      if (! undeclared_variable_notice)
 		{
@@ -1378,7 +1378,7 @@ do_scoped_id (token, parsing)
 	  return id;
 	}
       if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node)
-        cp_error ("`::%D' undeclared (first use here)", token);
+        error ("`::%D' undeclared (first use here)", token);
       id = error_mark_node;
       /* Prevent repeated error messages.  */
       SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
diff --git a/gcc/cp/method.c b/gcc/cp/method.c
index 9dbf1e3..759bfbe 100644
--- a/gcc/cp/method.c
+++ b/gcc/cp/method.c
@@ -185,13 +185,13 @@ hack_identifier (value, name)
 	{
 	  if (current_function_decl 
 	      && DECL_STATIC_FUNCTION_P (current_function_decl))
-	    cp_error ("invalid use of member `%D' in static member function",
+	    error ("invalid use of member `%D' in static member function",
 		      value);
 	  else
 	    /* We can get here when processing a bad default
 	       argument, like:
 	         struct S { int a; void f(int i = a); }  */
-	    cp_error ("invalid use of member `%D'", value);
+	    error ("invalid use of member `%D'", value);
 
 	  return error_mark_node;
 	}
@@ -233,12 +233,12 @@ hack_identifier (value, name)
     }
   else if (TREE_CODE (value) == NAMESPACE_DECL)
     {
-      cp_error ("use of namespace `%D' as expression", value);
+      error ("use of namespace `%D' as expression", value);
       return error_mark_node;
     }
   else if (DECL_CLASS_TEMPLATE_P (value))
     {
-      cp_error ("use of class template `%T' as expression", value);
+      error ("use of class template `%T' as expression", value);
       return error_mark_node;
     }
   else
@@ -251,7 +251,7 @@ hack_identifier (value, name)
       if (context != NULL_TREE && context != current_function_decl
 	  && ! TREE_STATIC (value))
 	{
-	  cp_error ("use of %s from containing function",
+	  error ("use of %s from containing function",
 		      (TREE_CODE (value) == VAR_DECL
 		       ? "`auto' variable" : "parameter"));
 	  cp_error_at ("  `%#D' declared here", value);
@@ -272,7 +272,7 @@ hack_identifier (value, name)
   else if (TREE_CODE (value) == TREE_LIST 
 	   && TREE_TYPE (value) == error_mark_node)
     {
-      cp_error ("\
+      error ("\
 request for member `%D' is ambiguous in multiple inheritance lattice",
 		name);
       print_candidates (value);
@@ -325,7 +325,7 @@ make_thunk (function, delta, vcall_index)
   thunk = IDENTIFIER_GLOBAL_VALUE (thunk_id);
   if (thunk && !DECL_THUNK_P (thunk))
     {
-      cp_error ("implementation-reserved name `%D' used", thunk_id);
+      error ("implementation-reserved name `%D' used", thunk_id);
       thunk = NULL_TREE;
       SET_IDENTIFIER_GLOBAL_VALUE (thunk_id, thunk);
     }
@@ -445,7 +445,7 @@ use_thunk (thunk_fndecl, emit_p)
     tree a, t;
 
     if (varargs_function_p (function))
-      cp_error ("generic thunk code fails for method `%#D' which uses `...'",
+      error ("generic thunk code fails for method `%#D' which uses `...'",
 		function);
 
     /* Set up clone argument trees for the thunk.  */
@@ -675,12 +675,12 @@ do_build_assign_ref (fndecl)
 
 	  if (CP_TYPE_CONST_P (TREE_TYPE (field)))
 	    {
-              cp_error ("non-static const member `%#D', can't use default assignment operator", field);
+              error ("non-static const member `%#D', can't use default assignment operator", field);
 	      continue;
 	    }
 	  else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
 	    {
-	      cp_error ("non-static reference member `%#D', can't use default assignment operator", field);
+	      error ("non-static reference member `%#D', can't use default assignment operator", field);
 	      continue;
 	    }
 
diff --git a/gcc/cp/parse.y b/gcc/cp/parse.y
index b49f6eb..ccc3ede 100644
--- a/gcc/cp/parse.y
+++ b/gcc/cp/parse.y
@@ -498,7 +498,7 @@ extdef:
 		{ do_pending_inlines (); }
 
 	| EXPORT
-		{ cp_warning ("keyword `export' not implemented, and will be ignored"); }
+		{ warning ("keyword `export' not implemented, and will be ignored"); }
 	  template_def
 		{ do_pending_inlines (); }
 	| template_def
@@ -602,7 +602,7 @@ extern_lang_string:
 		{ push_lang_context ($1); }
 	| extern_lang_string EXTERN_LANG_STRING
 		{ if (current_lang_name != $2)
-		    cp_error ("use of linkage spec `%D' is different from previous spec `%D'", $2, current_lang_name);
+		    error ("use of linkage spec `%D' is different from previous spec `%D'", $2, current_lang_name);
 		  pop_lang_context (); push_lang_context ($2); }
 	;
 
@@ -1108,7 +1108,7 @@ template_arg:
 		{
 		  if (!processing_template_decl)
 		    {
-		      cp_error ("use of template qualifier outside template");
+		      error ("use of template qualifier outside template");
 		      $$ = error_mark_node;
 		    }
 		  else
@@ -1169,9 +1169,9 @@ condition:
 		    if (TREE_CODE (d) == TYPE_DECL) {
 		      tree s = TREE_TYPE (d);
 		      if (TREE_CODE (s) == RECORD_TYPE)
-			cp_error ("definition of class `%T' in condition", s);
+			error ("definition of class `%T' in condition", s);
 		      else if (TREE_CODE (s) == ENUMERAL_TYPE)
-			cp_error ("definition of enum `%T' in condition", s);
+			error ("definition of enum `%T' in condition", s);
 		    }
 		  }
 		  current_declspecs = $1.t;
@@ -1182,7 +1182,7 @@ condition:
 		  parse_end_decl ($<ttype>6, $7, $4);
 		  $$ = convert_from_reference ($<ttype>6); 
 		  if (TREE_CODE (TREE_TYPE ($$)) == ARRAY_TYPE)
-		    cp_error ("definition of array `%#D' in condition", $$); 
+		    error ("definition of array `%#D' in condition", $$); 
 		}
 	| expr
 	;
@@ -1291,7 +1291,7 @@ new_placement:
 	  '(' nonnull_exprlist ')'
                 { $$ = $2; }
 	| '{' nonnull_exprlist '}'
-                { cp_pedwarn ("old style placement syntax, use () instead");
+                { pedwarn ("old style placement syntax, use () instead");
 		  $$ = $2; }
 	;
 
@@ -1302,7 +1302,7 @@ new_initializer:
 		{ $$ = void_zero_node; }
 	| '(' typespec ')'
 		{
-		  cp_error ("`%T' is not a valid expression", $2.t);
+		  error ("`%T' is not a valid expression", $2.t);
 		  $$ = error_mark_node;
 		}
 	/* GNU extension so people can use initializer lists.  Note that
@@ -2275,7 +2275,7 @@ structsp:
 		{ $$.t = $2;
 		  $$.new_type_flag = 0; 
 		  if (!processing_template_decl)
-		    cp_pedwarn ("using `typename' outside of template"); }
+		    pedwarn ("using `typename' outside of template"); }
 	/* C++ extensions, merged with C to avoid shift/reduce conflicts */
 	| class_head '{'
                 { $1.t = begin_class_definition ($1.t); 
@@ -2319,7 +2319,7 @@ structsp:
 		    $$.t = $1.t;
 		  else if (TYPE_BINFO ($1.t) == NULL_TREE)
 		    {
-		      cp_error ("%T is not a class type", $1.t);
+		      error ("%T is not a class type", $1.t);
 		      $$.t = error_mark_node;
 		    } 
 		  else
@@ -2330,7 +2330,7 @@ structsp:
 			  && TYPE_BINFO_BASETYPES ($$.t) 
 			  && !COMPLETE_TYPE_P ($$.t)
 			  && ! TYPE_BEING_DEFINED ($$.t))
-			cp_error ("base clause without member specification for `%#T'",
+			error ("base clause without member specification for `%#T'",
 				  $$.t);
 		    }
 		}
@@ -2448,7 +2448,7 @@ named_class_head:
 		      $$.new_type_flag = $1.new_type_flag;
 		      if ((current_aggr == union_type_node)
 			  != (TREE_CODE (type) == UNION_TYPE))
-			cp_pedwarn (current_aggr == union_type_node
+			pedwarn (current_aggr == union_type_node
 	                            ? "`union' tag used in declaring `%#T'"
 	                            : "non-`union' tag used in declaring `%#T'", 
 				    type);
@@ -2524,7 +2524,7 @@ base_class_access_list:
 	  VISSPEC see_typename
 	| SCSPEC see_typename
 		{ if ($1 != ridpointers[(int)RID_VIRTUAL])
-		    cp_error ("`%D' access", $1);
+		    error ("`%D' access", $1);
 		  $$ = access_default_virtual_node; }
 	| base_class_access_list VISSPEC see_typename
 		{
@@ -2539,7 +2539,7 @@ base_class_access_list:
 		}
 	| base_class_access_list SCSPEC see_typename
 		{ if ($2 != ridpointers[(int)RID_VIRTUAL])
-		    cp_error ("`%D' access", $2);
+		    error ("`%D' access", $2);
 		  else if ($$ == access_public_node)
 		    $$ = access_public_virtual_node;
 		  else if ($$ == access_protected_node)
@@ -3085,7 +3085,7 @@ typename_sub0:
 		  if (TYPE_P ($1))
 		    $$ = make_typename_type ($1, $2, /*complain=*/1);
 		  else if (TREE_CODE ($2) == IDENTIFIER_NODE)
-		    cp_error ("`%T' is not a class or namespace", $2);
+		    error ("`%T' is not a class or namespace", $2);
 		  else
 		    {
 		      $$ = $2;
@@ -3105,7 +3105,7 @@ typename_sub1:
 	  typename_sub2
 		{
 		  if (TREE_CODE ($1) == IDENTIFIER_NODE)
-		    cp_error ("`%T' is not a class or namespace", $1);
+		    error ("`%T' is not a class or namespace", $1);
 		  else if (TREE_CODE ($1) == TYPE_DECL)
 		    $$ = TREE_TYPE ($1);
 		}
@@ -3114,7 +3114,7 @@ typename_sub1:
 		  if (TYPE_P ($1))
 		    $$ = make_typename_type ($1, $2, /*complain=*/1);
 		  else if (TREE_CODE ($2) == IDENTIFIER_NODE)
-		    cp_error ("`%T' is not a class or namespace", $2);
+		    error ("`%T' is not a class or namespace", $2);
 		  else
 		    {
 		      $$ = $2;
@@ -3143,7 +3143,7 @@ typename_sub2:
 		  got_scope = complete_type (TREE_TYPE ($$));
 
 		  if ($$ == error_mark_node)
-		    cp_error ("`%T' is not a class or namespace", $1);
+		    error ("`%T' is not a class or namespace", $1);
 		}
 	| SELFNAME SCOPE
 		{
@@ -3770,7 +3770,7 @@ bad_parm:
 		  if (TREE_CODE ($$) == SCOPE_REF
 		      && (TREE_CODE (TREE_OPERAND ($$, 0)) == TEMPLATE_TYPE_PARM
 			  || TREE_CODE (TREE_OPERAND ($$, 0)) == BOUND_TEMPLATE_TEMPLATE_PARM))
-		    cp_error ("  perhaps you want `typename %E' to make it a type", $$);
+		    error ("  perhaps you want `typename %E' to make it a type", $$);
 		  $$ = build_tree_list (integer_type_node, $$);
 		}
 	;
@@ -3778,7 +3778,7 @@ bad_parm:
 bad_decl:
           IDENTIFIER template_arg_list_ignore IDENTIFIER arg_list_ignore ';'
 		{
-                  cp_error("'%D' is used as a type, but is not defined as a type.", $1);
+                  error("'%D' is used as a type, but is not defined as a type.", $1);
                   $3 = error_mark_node;
 		}
         ;
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 7775fcf..61e7186 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -206,7 +206,7 @@ finish_member_template_decl (decl)
       return NULL_TREE;
     }
   else if (TREE_CODE (decl) == FIELD_DECL)
-    cp_error ("data member `%D' cannot be a member template", decl);
+    error ("data member `%D' cannot be a member template", decl);
   else if (DECL_TEMPLATE_INFO (decl))
     {
       if (!DECL_TEMPLATE_SPECIALIZATION (decl))
@@ -218,7 +218,7 @@ finish_member_template_decl (decl)
 	return decl;
     } 
   else
-    cp_error ("invalid member template declaration `%D'", decl);
+    error ("invalid member template declaration `%D'", decl);
 
   return error_mark_node;
 }
@@ -613,7 +613,7 @@ check_specialization_scope ()
      shall be declared in the namespace of which the class template
      is a member.  */
   if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
-    cp_error ("explicit specialization in non-namespace scope `%D'",
+    error ("explicit specialization in non-namespace scope `%D'",
 	      scope);
 
   /* [temp.expl.spec] 
@@ -625,7 +625,7 @@ check_specialization_scope ()
      explicitly specialize a class member template if its enclosing
      class templates are not explicitly specialized as well.  */
   if (current_template_parms) 
-    cp_error ("enclosing class templates are not explicitly specialized");
+    error ("enclosing class templates are not explicitly specialized");
 }
 
 /* We've just seen template <>. */
@@ -700,7 +700,7 @@ maybe_process_partial_specialization (type)
 	  if (current_namespace
 	      != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type)))
 	    {
-	      cp_pedwarn ("specializing `%#T' in different namespace", type);
+	      pedwarn ("specializing `%#T' in different namespace", type);
 	      cp_pedwarn_at ("  from definition of `%#D'",
 			     CLASSTYPE_TI_TEMPLATE (type));
 	    }
@@ -709,10 +709,10 @@ maybe_process_partial_specialization (type)
 	    push_template_decl (TYPE_MAIN_DECL (type));
 	}
       else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
-	cp_error ("specialization of `%T' after instantiation", type);
+	error ("specialization of `%T' after instantiation", type);
     }
   else if (processing_specialization)
-    cp_error ("explicit specialization of non-template `%T'", type);
+    error ("explicit specialization of non-template `%T'", type);
 }
 
 /* Retrieve the specialization (in the sense of [temp.spec] - a
@@ -844,7 +844,7 @@ register_specialization (spec, tmpl, args)
 		  if (TREE_USED (fn) 
 		      || DECL_EXPLICIT_INSTANTIATION (fn))
 		    {
-		      cp_error ("specialization of %D after instantiation",
+		      error ("specialization of %D after instantiation",
 				fn);
 		      return spec;
 		    }
@@ -998,7 +998,7 @@ determine_specialization (template_id, decl, targs_out,
 
   if (!is_overloaded_fn (fns))
     {
-      cp_error ("`%D' is not a function template", fns);
+      error ("`%D' is not a function template", fns);
       return error_mark_node;
     }
 
@@ -1356,7 +1356,7 @@ check_explicit_specialization (declarator, decl, template_count, flags)
 	      /* This case handles bogus declarations like template <>
 		 template <class T> void f<int>(); */
 
-	      cp_error ("template-id `%D' in declaration of primary template",
+	      error ("template-id `%D' in declaration of primary template",
 			declarator);
 	      return decl;
 	    }
@@ -1369,19 +1369,19 @@ check_explicit_specialization (declarator, decl, template_count, flags)
       return error_mark_node;
 
     case tsk_invalid_expl_inst:
-      cp_error ("template parameter list used in explicit instantiation");
+      error ("template parameter list used in explicit instantiation");
 
       /* Fall through.  */
 
     case tsk_expl_inst:
       if (have_def)
-	cp_error ("definition provided for explicit instantiation");
+	error ("definition provided for explicit instantiation");
       
       explicit_instantiation = 1;
       break;
 
     case tsk_excessive_parms:
-      cp_error ("too many template parameter lists in declaration of `%D'", 
+      error ("too many template parameter lists in declaration of `%D'", 
 		decl);
       return error_mark_node;
 
@@ -1397,7 +1397,7 @@ check_explicit_specialization (declarator, decl, template_count, flags)
     case tsk_insufficient_parms:
       if (template_header_count)
 	{
-	  cp_error("too few template parameter lists in declaration of `%D'", 
+	  error("too few template parameter lists in declaration of `%D'", 
 		   decl);
 	  return decl;
 	}
@@ -1413,7 +1413,7 @@ check_explicit_specialization (declarator, decl, template_count, flags)
 
 	     That used to be legal C++.  */
 	  if (pedantic)
-	    cp_pedwarn
+	    pedwarn
 	      ("explicit specialization not preceded by `template <>'");
 	  specialization = 1;
 	  SET_DECL_TEMPLATE_SPECIALIZATION (decl);
@@ -1427,10 +1427,10 @@ check_explicit_specialization (declarator, decl, template_count, flags)
 	     template <class T> void f<int>(); */
 
 	  if (uses_template_parms (declarator))
-	    cp_error ("partial specialization `%D' of function template",
+	    error ("partial specialization `%D' of function template",
 		      declarator);
 	  else
-	    cp_error ("template-id `%D' in declaration of primary template",
+	    error ("template-id `%D' in declaration of primary template",
 		      declarator);
 	  return decl;
 	}
@@ -1458,12 +1458,12 @@ check_explicit_specialization (declarator, decl, template_count, flags)
       for (; t; t = TREE_CHAIN (t))
 	if (TREE_PURPOSE (t))
 	  {
-	    cp_pedwarn
+	    pedwarn
 	      ("default argument specified in explicit specialization");
 	    break;
 	  }
       if (current_lang_name == lang_name_c)
-	cp_error ("template specialization with C linkage");
+	error ("template specialization with C linkage");
     }
 
   if (specialization || member_specialization || explicit_instantiation)
@@ -1551,7 +1551,7 @@ check_explicit_specialization (declarator, decl, template_count, flags)
 		     program is ill-formed.  
 
 		     Similar language is found in [temp.explicit].  */
-		  cp_error ("specialization of implicitly-declared special member function");
+		  error ("specialization of implicitly-declared special member function");
 		  return error_mark_node;
 		}
 
@@ -1594,7 +1594,7 @@ check_explicit_specialization (declarator, decl, template_count, flags)
 	      
 	  if (fns == NULL_TREE) 
 	    {
-	      cp_error ("no member function `%D' declared in `%T'",
+	      error ("no member function `%D' declared in `%T'",
 			name, ctype);
 	      return error_mark_node;
 	    }
@@ -1742,7 +1742,7 @@ maybe_check_template_type (type)
 	; 
       else if (template_header_count > context_depth + 1)
 	/* There are two many template parameter lists.  */
-	cp_error ("too many template parameter lists in declaration of `%T'", type); 
+	error ("too many template parameter lists in declaration of `%T'", type); 
     }
 }
 
@@ -2241,11 +2241,11 @@ process_partial_specialization (decl)
 	   specialization.  */
 	if (!did_error_intro)
 	  {
-	    cp_error ("template parameters not used in partial specialization:");
+	    error ("template parameters not used in partial specialization:");
 	    did_error_intro = 1;
 	  }
 
-	cp_error ("        `%D'", 
+	error ("        `%D'", 
 		  TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
       }
 
@@ -2257,7 +2257,7 @@ process_partial_specialization (decl)
       (inner_args, 
        INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
 						   (maintmpl)))))
-    cp_error ("partial specialization `%T' does not specialize any template arguments", type);
+    error ("partial specialization `%T' does not specialize any template arguments", type);
 
   /* [temp.class.spec]
 
@@ -2282,7 +2282,7 @@ process_partial_specialization (decl)
 	  && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
 	{
 	  if (tpd.arg_uses_template_parms[i])
-	    cp_error ("template argument `%E' involves template parameter(s)", arg);
+	    error ("template argument `%E' involves template parameter(s)", arg);
 	  else 
 	    {
 	      /* Look at the corresponding template parameter,
@@ -2325,7 +2325,7 @@ process_partial_specialization (decl)
 		    if (tpd2.parms[j] != 0
 			&& tpd.arg_uses_template_parms [j])
 		      {
-			cp_error ("type `%T' of template argument `%E' depends on template parameter(s)", 
+			error ("type `%T' of template argument `%E' depends on template parameter(s)", 
 				  type,
 				  arg);
 			break;
@@ -2413,7 +2413,7 @@ check_default_tmpl_args (decl, parms, is_primary, is_partial)
 	    seen_def_arg_p = 1;
 	  else if (seen_def_arg_p)
 	    {
-	      cp_error ("no default argument for `%D'", TREE_VALUE (parm));
+	      error ("no default argument for `%D'", TREE_VALUE (parm));
 	      /* For better subsequent error-recovery, we indicate that
 		 there should have been a default argument.  */
 	      TREE_PURPOSE (parm) = error_mark_node;
@@ -2477,7 +2477,7 @@ check_default_tmpl_args (decl, parms, is_primary, is_partial)
 	  {
 	    if (msg)
 	      {
-		cp_error (msg, decl);
+		error (msg, decl);
 		msg = 0;
 	      }
 
@@ -2546,17 +2546,17 @@ push_template_decl_real (decl, is_friend)
   if (primary)
     {
       if (current_lang_name == lang_name_c)
-	cp_error ("template with C linkage");
+	error ("template with C linkage");
       else if (TREE_CODE (decl) == TYPE_DECL 
 	       && ANON_AGGRNAME_P (DECL_NAME (decl))) 
-	cp_error ("template class without a name");
+	error ("template class without a name");
       else if ((DECL_IMPLICIT_TYPEDEF_P (decl)
 		&& CLASS_TYPE_P (TREE_TYPE (decl)))
 	       || (TREE_CODE (decl) == VAR_DECL && ctx && CLASS_TYPE_P (ctx))
 	       || TREE_CODE (decl) == FUNCTION_DECL)
 	/* OK */;
       else
-	cp_error ("template declaration of `%#D'", decl);
+	error ("template declaration of `%#D'", decl);
     }
 
   /* Check to see that the rules regarding the use of default
@@ -2624,13 +2624,13 @@ push_template_decl_real (decl, is_friend)
 	    tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
 	  else
 	    {
-	      cp_error ("`%D' does not declare a template type", decl);
+	      error ("`%D' does not declare a template type", decl);
 	      return decl;
 	    }
 	}
       else if (! DECL_TEMPLATE_INFO (decl))
 	{
-	  cp_error ("template definition of non-template `%#D'", decl);
+	  error ("template definition of non-template `%#D'", decl);
 	  return decl;
 	}
       else
@@ -2671,7 +2671,7 @@ push_template_decl_real (decl, is_friend)
       i = TMPL_PARMS_DEPTH (parms);
       if (TMPL_ARGS_DEPTH (args) != i)
 	{
-	  cp_error ("expected %d levels of template parms for `%#D', got %d",
+	  error ("expected %d levels of template parms for `%#D', got %d",
 		    i, decl, TMPL_ARGS_DEPTH (args));
 	}
       else
@@ -2683,12 +2683,12 @@ push_template_decl_real (decl, is_friend)
 	    if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
 	      {
 		if (current == decl)
-		  cp_error ("got %d template parameters for `%#D'",
+		  error ("got %d template parameters for `%#D'",
 			    TREE_VEC_LENGTH (a), decl);
 		else
-		  cp_error ("got %d template parameters for `%#T'",
+		  error ("got %d template parameters for `%#T'",
 			    TREE_VEC_LENGTH (a), current);
-		cp_error ("  but %d required", TREE_VEC_LENGTH (t));
+		error ("  but %d required", TREE_VEC_LENGTH (t));
 	      }
 
 	    /* Perhaps we should also check that the parms are used in the
@@ -2756,7 +2756,7 @@ redeclare_class_template (type, parms)
 
   if (!TYPE_TEMPLATE_INFO (type))
     {
-      cp_error ("`%T' is not a template type", type);
+      error ("`%T' is not a template type", type);
       return;
     }
 
@@ -2773,7 +2773,7 @@ redeclare_class_template (type, parms)
   if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
     {
       cp_error_at ("previous declaration `%D'", tmpl);
-      cp_error ("used %d template parameter%s instead of %d",
+      error ("used %d template parameter%s instead of %d",
 		TREE_VEC_LENGTH (tmpl_parms), 
 		TREE_VEC_LENGTH (tmpl_parms) == 1 ? "" : "s",
 		TREE_VEC_LENGTH (parms));
@@ -2790,7 +2790,7 @@ redeclare_class_template (type, parms)
       if (TREE_CODE (tmpl_parm) != TREE_CODE (parm))
 	{
 	  cp_error_at ("template parameter `%#D'", tmpl_parm);
-	  cp_error ("redeclared here as `%#D'", parm);
+	  error ("redeclared here as `%#D'", parm);
 	  return;
 	}
 
@@ -2800,7 +2800,7 @@ redeclare_class_template (type, parms)
 
 	     A template-parameter may not be given default arguments
 	     by two different declarations in the same scope.  */
-	  cp_error ("redefinition of default argument for `%#D'", parm);
+	  error ("redefinition of default argument for `%#D'", parm);
 	  cp_error_at ("  original definition appeared here", tmpl_parm);
 	  return;
 	}
@@ -2894,17 +2894,17 @@ convert_nontype_argument (type, expr)
 	  if (TREE_CODE (e) != ADDR_EXPR)
 	    {
 	    bad_argument:
-	      cp_error ("`%E' is not a valid template argument", expr);
+	      error ("`%E' is not a valid template argument", expr);
 	      if (TYPE_PTR_P (expr_type))
 		{
 		  if (TREE_CODE (TREE_TYPE (expr_type)) == FUNCTION_TYPE)
-		    cp_error ("it must be the address of a function with external linkage");
+		    error ("it must be the address of a function with external linkage");
 		  else
-		    cp_error ("it must be the address of an object with external linkage");
+		    error ("it must be the address of an object with external linkage");
 		}
 	      else if (TYPE_PTRMEM_P (expr_type)
 		       || TYPE_PTRMEMFUNC_P (expr_type))
-		cp_error ("it must be a pointer-to-member of the form `&X::Y'");
+		error ("it must be a pointer-to-member of the form `&X::Y'");
 
 	      return NULL_TREE;
 	    }
@@ -2915,7 +2915,7 @@ convert_nontype_argument (type, expr)
 
       if (TREE_CODE (referent) == STRING_CST)
 	{
-	  cp_error ("string literal %E is not a valid template argument because it is the address of an object with static linkage", 
+	  error ("string literal %E is not a valid template argument because it is the address of an object with static linkage", 
 		    referent);
 	  return NULL_TREE;
 	}
@@ -2927,7 +2927,7 @@ convert_nontype_argument (type, expr)
 	goto bad_argument;
       else if (!DECL_EXTERNAL_LINKAGE_P (referent))
 	{
-	  cp_error ("address of non-extern `%E' cannot be used as template argument", referent); 
+	  error ("address of non-extern `%E' cannot be used as template argument", referent); 
 	  return error_mark_node;
 	}
     }
@@ -2938,14 +2938,14 @@ convert_nontype_argument (type, expr)
       if (! TREE_CONSTANT (expr))
 	{
 	non_constant:
-	  cp_error ("non-constant `%E' cannot be used as template argument",
+	  error ("non-constant `%E' cannot be used as template argument",
 		    expr);
 	  return NULL_TREE;
 	}
     }
   else 
     {
-      cp_error ("object `%E' cannot be used as template argument", expr);
+      error ("object `%E' cannot be used as template argument", expr);
       return NULL_TREE;
     }
 
@@ -3321,7 +3321,7 @@ convert_template_argument (parm, arg, args, complain, i, in_decl)
   if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
       && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
     {
-      cp_pedwarn ("to refer to a type member of a template parameter, use `typename %E'", arg);
+      pedwarn ("to refer to a type member of a template parameter, use `typename %E'", arg);
       
       arg = make_typename_type (TREE_OPERAND (arg, 0),
 				TREE_OPERAND (arg, 1),
@@ -3334,14 +3334,14 @@ convert_template_argument (parm, arg, args, complain, i, in_decl)
 	{
 	  if (complain)
 	    {
-	      cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
+	      error ("type/value mismatch at argument %d in template parameter list for `%D'",
 			i + 1, in_decl);
 	      if (is_type)
-		cp_error ("  expected a constant of type `%T', got `%T'",
+		error ("  expected a constant of type `%T', got `%T'",
 			  TREE_TYPE (parm),
 			  (is_tmpl_type ? DECL_NAME (arg) : arg));
 	      else
-		cp_error ("  expected a type, got `%E'", arg);
+		error ("  expected a type, got `%E'", arg);
 	    }
 	}
       return error_mark_node;
@@ -3350,12 +3350,12 @@ convert_template_argument (parm, arg, args, complain, i, in_decl)
     {
       if (in_decl && complain)
 	{
-	  cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
+	  error ("type/value mismatch at argument %d in template parameter list for `%D'",
 		    i + 1, in_decl);
 	  if (is_tmpl_type)
-	    cp_error ("  expected a type, got `%T'", DECL_NAME (arg));
+	    error ("  expected a type, got `%T'", DECL_NAME (arg));
 	  else
-	    cp_error ("  expected a class template, got `%T'", arg);
+	    error ("  expected a class template, got `%T'", arg);
 	}
       return error_mark_node;
     }
@@ -3389,9 +3389,9 @@ convert_template_argument (parm, arg, args, complain, i, in_decl)
 		{
 		  if (in_decl && complain)
 		    {
-		      cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
+		      error ("type/value mismatch at argument %d in template parameter list for `%D'",
 				i + 1, in_decl);
-		      cp_error ("  expected a template of type `%D', got `%D'", parm, arg);
+		      error ("  expected a template of type `%D', got `%D'", parm, arg);
 		    }
 		  
 		  val = error_mark_node;
@@ -3412,10 +3412,10 @@ convert_template_argument (parm, arg, args, complain, i, in_decl)
 	      if (t)
 		{
 		  if (TYPE_ANONYMOUS_P (t))
-		    cp_pedwarn
+		    pedwarn
 		      ("template-argument `%T' uses anonymous type", val);
 		  else
-		    cp_error
+		    error
 		      ("template-argument `%T' uses local type `%T'",
 		       val, t);
 		  return error_mark_node;
@@ -3451,7 +3451,7 @@ convert_template_argument (parm, arg, args, complain, i, in_decl)
       if (val == NULL_TREE)
 	val = error_mark_node;
       else if (val == error_mark_node && complain)
-	cp_error ("could not convert template argument `%E' to `%T'", 
+	error ("could not convert template argument `%E' to `%T'", 
 		  arg, t);
     }
 
@@ -3495,7 +3495,7 @@ coerce_template_parms (parms, args, in_decl,
     {
       if (complain) 
 	{
-	  cp_error ("wrong number of template arguments (%d, should be %d)",
+	  error ("wrong number of template arguments (%d, should be %d)",
 		    nargs, nparms);
 	  
 	  if (in_decl)
@@ -3546,7 +3546,7 @@ coerce_template_parms (parms, args, in_decl,
 	}
       else if (arg == error_mark_node)
 	{
-	  cp_error ("template argument %d is invalid", i + 1);
+	  error ("template argument %d is invalid", i + 1);
 	  arg = error_mark_node;
 	}
       else 
@@ -3778,7 +3778,7 @@ lookup_template_function (fns, arglist)
 
   if (fns == NULL_TREE)
     {
-      cp_error ("non-template used as template");
+      error ("non-template used as template");
       return error_mark_node;
     }
 
@@ -3896,7 +3896,7 @@ lookup_template_class (d1, arglist, in_decl, context, entering_scope, complain)
   if (! template)
     {
       if (complain)
-        cp_error ("`%T' is not a template", d1);
+        error ("`%T' is not a template", d1);
       return error_mark_node;
     }
 
@@ -3909,7 +3909,7 @@ lookup_template_class (d1, arglist, in_decl, context, entering_scope, complain)
     {
       if (complain)
         {
-          cp_error ("non-template type `%T' used as a template", d1);
+          error ("non-template type `%T' used as a template", d1);
           if (in_decl)
 	    cp_error_at ("for template declaration `%D'", in_decl);
 	}
@@ -4474,7 +4474,7 @@ push_tinst_level (d)
 	return 0;
 
       last_template_error_tick = tinst_level_tick;
-      cp_error ("template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating `%D'",
+      error ("template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating `%D'",
 	     max_tinst_depth, d);
 
       print_instantiation_context ();
@@ -4909,7 +4909,7 @@ instantiate_class_template (type)
       if (t == error_mark_node)
 	{
 	  const char *str = "candidates are:";
-	  cp_error ("ambiguous class template instantiation for `%#T'", type);
+	  error ("ambiguous class template instantiation for `%#T'", type);
 	  for (t = DECL_TEMPLATE_SPECIALIZATIONS (template); t; 
 	       t = TREE_CHAIN (t))
 	    {
@@ -6094,7 +6094,7 @@ tsubst_arg_types (arg_types, args, complain, in_decl)
     {
       if (complain)
         {
-          cp_error ("invalid parameter type `%T'", type);
+          error ("invalid parameter type `%T'", type);
           if (in_decl)
             cp_error_at ("in declaration `%D'", in_decl);
         }
@@ -6171,7 +6171,7 @@ tsubst_function_type (t, args, complain, in_decl)
 	     -- Attempting to create "pointer to member of T" when T
 	     is not a class type.  */
 	  if (complain)
-	    cp_error ("creating pointer to member function of non-class type `%T'",
+	    error ("creating pointer to member function of non-class type `%T'",
 		      r);
 	  return error_mark_node;
 	}
@@ -6348,7 +6348,7 @@ tsubst (t, args, complain, in_decl)
 		 Attempting to create an array with a size that is
 		 zero or negative.  */
 	    if (complain)
-	      cp_error ("creating array with size zero (`%E')", max);
+	      error ("creating array with size zero (`%E')", max);
 
 	    return error_mark_node;
 	  }
@@ -6586,9 +6586,9 @@ tsubst (t, args, complain, in_decl)
 			     last_file != input_filename))
 	      {
 		if (TREE_CODE (type) == VOID_TYPE)
-		  cp_error ("forming reference to void");
+		  error ("forming reference to void");
 		else
-		  cp_error ("forming %s to reference type `%T'",
+		  error ("forming %s to reference type `%T'",
 			    (code == POINTER_TYPE) ? "pointer" : "reference",
 			    type);
 		last_line = lineno;
@@ -6622,7 +6622,7 @@ tsubst (t, args, complain, in_decl)
 	       -- Attempting to create "pointer to member of T" when T
 	          is not a class type.  */
 	    if (complain)
-	      cp_error ("creating pointer to member of non-class type `%T'", 
+	      error ("creating pointer to member of non-class type `%T'", 
 			r);
 	    return error_mark_node;
 	  }
@@ -6684,7 +6684,7 @@ tsubst (t, args, complain, in_decl)
 	    || TREE_CODE (type) == REFERENCE_TYPE)
 	  {
 	    if (complain)
-	      cp_error ("creating array of `%T'", type);
+	      error ("creating array of `%T'", type);
 	    return error_mark_node;
 	  }
 
@@ -6730,7 +6730,7 @@ tsubst (t, args, complain, in_decl)
 	if (!IS_AGGR_TYPE (ctx))
 	  {
 	    if (complain)
-	      cp_error ("`%T' is not a class, struct, or union type",
+	      error ("`%T' is not a class, struct, or union type",
 			ctx);
 	    return error_mark_node;
 	  }
@@ -7624,8 +7624,8 @@ instantiate_template (tmpl, targ_ptr)
 	  tree nt = target_type (t);
 	  if (IS_AGGR_TYPE (nt) && decl_function_context (TYPE_MAIN_DECL (nt)))
 	    {
-	      cp_error ("type `%T' composed from a local class is not a valid template-argument", t);
-	      cp_error ("  trying to instantiate `%D'", gen_tmpl);
+	      error ("type `%T' composed from a local class is not a valid template-argument", t);
+	      error ("  trying to instantiate `%D'", gen_tmpl);
 	      return error_mark_node;
 	    }
 	}
@@ -9432,7 +9432,7 @@ do_decl_instantiation (declspecs, declarator, storage)
     return;
   else if (! DECL_LANG_SPECIFIC (decl))
     {
-      cp_error ("explicit instantiation of non-template `%#D'", decl);
+      error ("explicit instantiation of non-template `%#D'", decl);
       return;
     }
   else if (TREE_CODE (decl) == VAR_DECL)
@@ -9448,13 +9448,13 @@ do_decl_instantiation (declspecs, declarator, storage)
       result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, 0);
       if (result && TREE_CODE (result) != VAR_DECL)
 	{
-	  cp_error ("no matching template for `%D' found", result);
+	  error ("no matching template for `%D' found", result);
 	  return;
 	}
     }
   else if (TREE_CODE (decl) != FUNCTION_DECL)
     {
-      cp_error ("explicit instantiation of `%#D'", decl);
+      error ("explicit instantiation of `%#D'", decl);
       return;
     }
   else
@@ -9471,7 +9471,7 @@ do_decl_instantiation (declspecs, declarator, storage)
 
 	 No program shall both explicitly instantiate and explicitly
 	 specialize a template.  */
-      cp_pedwarn ("explicit instantiation of `%#D' after", result);
+      pedwarn ("explicit instantiation of `%#D' after", result);
       cp_pedwarn_at ("explicit specialization here", result);
       return;
     }
@@ -9487,7 +9487,7 @@ do_decl_instantiation (declspecs, declarator, storage)
 	 the opposite case.  If -frepo, chances are we already got marked
 	 as an explicit instantiation because of the repo file.  */
       if (DECL_INTERFACE_KNOWN (result) && !extern_p && !flag_use_repository)
-	cp_pedwarn ("duplicate explicit instantiation of `%#D'", result);
+	pedwarn ("duplicate explicit instantiation of `%#D'", result);
 
       /* If we've already instantiated the template, just return now.  */
       if (DECL_INTERFACE_KNOWN (result))
@@ -9495,12 +9495,12 @@ do_decl_instantiation (declspecs, declarator, storage)
     }
   else if (!DECL_IMPLICIT_INSTANTIATION (result))
     {
-      cp_error ("no matching template for `%D' found", result);
+      error ("no matching template for `%D' found", result);
       return;
     }
   else if (!DECL_TEMPLATE_INFO (result))
     {
-      cp_pedwarn ("explicit instantiation of non-template `%#D'", result);
+      pedwarn ("explicit instantiation of non-template `%#D'", result);
       return;
     }
 
@@ -9512,11 +9512,11 @@ do_decl_instantiation (declspecs, declarator, storage)
   else if (storage == ridpointers[(int) RID_EXTERN])
     {
       if (pedantic)
-	cp_pedwarn ("ISO C++ forbids the use of `extern' on explicit instantiations");
+	pedwarn ("ISO C++ forbids the use of `extern' on explicit instantiations");
       extern_p = 1;
     }
   else
-    cp_error ("storage class `%D' applied to template instantiation",
+    error ("storage class `%D' applied to template instantiation",
 	      storage);
 
   SET_DECL_EXPLICIT_INSTANTIATION (result);
@@ -9561,7 +9561,7 @@ do_type_instantiation (t, storage, complain)
 
   if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
     {
-      cp_error ("explicit instantiation of non-template type `%T'", t);
+      error ("explicit instantiation of non-template type `%T'", t);
       return;
     }
 
@@ -9575,7 +9575,7 @@ do_type_instantiation (t, storage, complain)
   if (!COMPLETE_TYPE_P (t))
     {
       if (complain)
-	cp_error ("explicit instantiation of `%#T' before definition of template",
+	error ("explicit instantiation of `%#T' before definition of template",
 		  t);
       return;
     }
@@ -9583,7 +9583,7 @@ do_type_instantiation (t, storage, complain)
   if (storage != NULL_TREE)
     {
       if (pedantic)
-	cp_pedwarn("ISO C++ forbids the use of `%s' on explicit instantiations", 
+	pedwarn("ISO C++ forbids the use of `%s' on explicit instantiations", 
 		   IDENTIFIER_POINTER (storage));
 
       if (storage == ridpointers[(int) RID_INLINE])
@@ -9594,7 +9594,7 @@ do_type_instantiation (t, storage, complain)
 	static_p = 1;
       else
 	{
-	  cp_error ("storage class `%D' applied to template instantiation",
+	  error ("storage class `%D' applied to template instantiation",
 		    storage);
 	  extern_p = 0;
 	}
@@ -9608,7 +9608,7 @@ do_type_instantiation (t, storage, complain)
 	 specialize a template.  */
       if (complain)
 	{
-	  cp_error ("explicit instantiation of `%#T' after", t);
+	  error ("explicit instantiation of `%#T' after", t);
 	  cp_error_at ("explicit specialization here", t);
 	}
       return;
@@ -9626,7 +9626,7 @@ do_type_instantiation (t, storage, complain)
 	 repo file.  All these cases are OK.  */
       if (!CLASSTYPE_INTERFACE_ONLY (t) && !extern_p && !flag_use_repository
 	  && complain)
-	cp_pedwarn ("duplicate explicit instantiation of `%#T'", t);
+	pedwarn ("duplicate explicit instantiation of `%#T'", t);
       
       /* If we've already instantiated the template, just return now.  */
       if (!CLASSTYPE_INTERFACE_ONLY (t))
@@ -9966,7 +9966,7 @@ instantiate_decl (d, defer_ok)
 	   member function or static data member of a class template
 	   shall be present in every translation unit in which it is
 	   explicitly instantiated.  */
-	cp_pedwarn
+	pedwarn
 	  ("explicit instantiation of `%D' but no definition available", d);
 
       add_pending_template (d);
@@ -10339,7 +10339,7 @@ invalid_nontype_parm_type_p (type, complain)
     return 0;
            
   if (complain)
-    cp_error ("`%#T' is not a valid type for a template constant parameter",
+    error ("`%#T' is not a valid type for a template constant parameter",
               type);
   return 1;
 }
diff --git a/gcc/cp/rtti.c b/gcc/cp/rtti.c
index f99f1cc..af40129 100644
--- a/gcc/cp/rtti.c
+++ b/gcc/cp/rtti.c
@@ -277,7 +277,7 @@ get_tinfo_decl (type)
   if (COMPLETE_TYPE_P (type) 
       && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
     {
-      cp_error ("cannot create type information for type `%T' because its size is variable", 
+      error ("cannot create type information for type `%T' because its size is variable", 
 		type);
       return error_mark_node;
     }
@@ -522,7 +522,7 @@ build_dynamic_cast_1 (type, expr)
 		  && TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE)
 		{
 	          tree expr = throw_bad_cast ();
-		  cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
+		  warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
 			      old_expr, type);
 	          /* Bash it to the expected type.  */
 	          TREE_TYPE (expr) = type;
@@ -536,7 +536,7 @@ build_dynamic_cast_1 (type, expr)
 	      if (TREE_CODE (op) == VAR_DECL
 		  && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
 		{
-		  cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
+		  warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
 			      op, type);
 		  retval = build_int_2 (0, 0); 
 		  TREE_TYPE (retval) = type; 
@@ -611,7 +611,7 @@ build_dynamic_cast_1 (type, expr)
     errstr = "source type is not polymorphic";
 
  fail:
-  cp_error ("cannot dynamic_cast `%E' (of type `%#T') to type `%#T' (%s)",
+  error ("cannot dynamic_cast `%E' (of type `%#T') to type `%#T' (%s)",
 	    expr, exprtype, type, errstr);
   return error_mark_node;
 }
diff --git a/gcc/cp/search.c b/gcc/cp/search.c
index 6e5e2e5..a6a9a6d 100644
--- a/gcc/cp/search.c
+++ b/gcc/cp/search.c
@@ -337,7 +337,7 @@ lookup_base (t, base, access, kind_ptr)
       binfo = NULL_TREE;
       if (!(access & ba_quiet))
 	{
-	  cp_error ("`%T' is an inaccessible base of `%T'", base, t);
+	  error ("`%T' is an inaccessible base of `%T'", base, t);
 	  binfo = error_mark_node;
 	}
       break;
@@ -347,7 +347,7 @@ lookup_base (t, base, access, kind_ptr)
 	  binfo = NULL_TREE;
 	  if (!(access & ba_quiet))
 	    {
-	      cp_error ("`%T' is an ambiguous base of `%T'", base, t);
+	      error ("`%T' is an ambiguous base of `%T'", base, t);
 	      binfo = error_mark_node;
 	    }
 	}
@@ -1456,7 +1456,7 @@ lookup_member (xbasetype, name, protect, want_type)
 
   if (errstr && protect)
     {
-      cp_error (errstr, name, type);
+      error (errstr, name, type);
       if (lfi.ambiguous)
         print_candidates (lfi.ambiguous);
       rval = error_mark_node;
@@ -2127,7 +2127,7 @@ get_pure_virtuals (type)
 	{
 	  tree base_fndecl = BV_FN (virtuals);
 	  if (DECL_NEEDS_FINAL_OVERRIDER_P (base_fndecl))
-	    cp_error ("`%#D' needs a final overrider", base_fndecl);
+	    error ("`%#D' needs a final overrider", base_fndecl);
 	}
     }
 }
diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index 632e9132..e2081b5 100644
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -878,7 +878,7 @@ finish_asm_stmt (cv_qualifier, string, output_operands,
   if (cv_qualifier != NULL_TREE
       && cv_qualifier != ridpointers[(int) RID_VOLATILE])
     {
-      cp_warning ("%s qualifier ignored on asm",
+      warning ("%s qualifier ignored on asm",
 		  IDENTIFIER_POINTER (cv_qualifier));
       cv_qualifier = NULL_TREE;
     }
@@ -900,7 +900,7 @@ finish_asm_stmt (cv_qualifier, string, output_operands,
 	     resolve the overloading.  */
 	  if (TREE_TYPE (converted_operand) == unknown_type_node)
 	    {
-	      cp_error ("type of asm operand `%E' could not be determined", 
+	      error ("type of asm operand `%E' could not be determined", 
 			TREE_VALUE (t));
 	      converted_operand = error_mark_node;
 	    }
@@ -1051,7 +1051,7 @@ finish_named_return_value (return_id, init)
 	DECL_NAME (decl) = return_id;
       else
 	{
-	  cp_error ("return identifier `%D' already in place", return_id);
+	  error ("return identifier `%D' already in place", return_id);
 	  return;
 	}
     }
@@ -1126,7 +1126,7 @@ finish_mem_initializers (init_list)
 		   base != last_base_warned_about; 
 		   base = TREE_CHAIN (base))
 		{
-		  cp_warning ("base initializer for `%T'",
+		  warning ("base initializer for `%T'",
 			      TREE_PURPOSE (base));
 		  warning ("   will be re-ordered to precede member initializations");
 		}
@@ -1444,7 +1444,7 @@ finish_object_call_expr (fn, object, args)
 	fn = DECL_NAME (fn);
       else
 	{
-	  cp_error ("calling type `%T' like a method", fn);
+	  error ("calling type `%T' like a method", fn);
 	  return error_mark_node;
 	}
     }
@@ -1480,13 +1480,13 @@ finish_pseudo_destructor_call_expr (object, scope, destructor)
     return build_min_nt (PSEUDO_DTOR_EXPR, object, scope, destructor);
 
   if (scope && scope != destructor)
-    cp_error ("destructor specifier `%T::~%T()' must have matching names", 
+    error ("destructor specifier `%T::~%T()' must have matching names", 
 	      scope, destructor);
 
   if ((scope == NULL_TREE || IDENTIFIER_GLOBAL_VALUE (destructor))
       && (TREE_CODE (TREE_TYPE (object)) !=
 	  TREE_CODE (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (destructor)))))
-    cp_error ("`%E' is not of type `%T'", object, destructor);
+    error ("`%E' is not of type `%T'", object, destructor);
 
   return cp_convert (void_type_node, object);
 }
@@ -1757,7 +1757,7 @@ begin_class_definition (t)
   
   if (processing_template_parmlist)
     {
-      cp_error ("definition of `%#T' inside template parameter list", t);
+      error ("definition of `%#T' inside template parameter list", t);
       return error_mark_node;
     }
 
@@ -1773,7 +1773,7 @@ begin_class_definition (t)
      This is erroneous.  */
   else if (TREE_CODE (t) == TYPENAME_TYPE)
     {
-      cp_error ("invalid definition of qualified type `%T'", t);
+      error ("invalid definition of qualified type `%T'", t);
       t = error_mark_node;
     }
 
@@ -2125,7 +2125,7 @@ finish_base_specifier (access_specifier, base_class)
     {
       if (cp_type_quals (base_class) != 0)
         {
-          cp_error ("base class `%T' has cv qualifiers", base_class);
+          error ("base class `%T' has cv qualifiers", base_class);
           base_class = TYPE_MAIN_VARIANT (base_class);
         }
       result = build_tree_list (access_specifier, base_class);
@@ -2158,7 +2158,7 @@ check_multiple_declarators ()
   if (PROCESSING_REAL_TEMPLATE_DECL_P () 
       || processing_explicit_instantiation
       || processing_specialization)
-    cp_error ("multiple declarators in template declaration");
+    error ("multiple declarators in template declaration");
 }
 
 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
diff --git a/gcc/cp/spew.c b/gcc/cp/spew.c
index 6422225..138e23e 100644
--- a/gcc/cp/spew.c
+++ b/gcc/cp/spew.c
@@ -1432,7 +1432,7 @@ replace_defarg (arg, init)
     {
       if (! processing_template_decl
           && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
-        cp_pedwarn ("invalid type `%T' for default argument to `%T'",
+        pedwarn ("invalid type `%T' for default argument to `%T'",
   	    	    TREE_TYPE (init), TREE_VALUE (arg));
       if (!defarg_depfns)
         TREE_PURPOSE (arg) = init;
diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
index 1d0c324..b127144 100644
--- a/gcc/cp/tree.c
+++ b/gcc/cp/tree.c
@@ -533,7 +533,7 @@ cp_build_qualified_type_real (type, type_quals, complain)
 	  || TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE))
     {
       if (complain)
-	cp_error ("`%T' cannot be `restrict'-qualified", type);
+	error ("`%T' cannot be `restrict'-qualified", type);
       else
 	return error_mark_node;
 
@@ -544,7 +544,7 @@ cp_build_qualified_type_real (type, type_quals, complain)
       && TREE_CODE (type) == FUNCTION_TYPE)
     {
       if (complain)
-	cp_error ("`%T' cannot be `const'-, `volatile'-, or `restrict'-qualified", type);
+	error ("`%T' cannot be `const'-, `volatile'-, or `restrict'-qualified", type);
       else
 	return error_mark_node;
       type_quals = TYPE_UNQUALIFIED;
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index b721fae..d5ba084 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -506,7 +506,7 @@ composite_pointer_type (t1, t2, arg1, arg2, location)
 	result_type = full2;
       else
 	{
-	  cp_pedwarn ("%s between distinct pointer types `%T' and `%T' lacks a cast",
+	  pedwarn ("%s between distinct pointer types `%T' and `%T' lacks a cast",
 		      location, t1, t2);
 	  result_type = ptr_type_node;
 	}
@@ -1490,7 +1490,7 @@ comp_target_parms (parms1, parms2)
 
   if (t1 == 0 && t2 != 0)
     {
-      cp_pedwarn ("ISO C++ prohibits conversion from `%#T' to `(...)'",
+      pedwarn ("ISO C++ prohibits conversion from `%#T' to `(...)'",
 		  parms2);
       return self_promoting_args_p (t2);
     }
@@ -1586,12 +1586,12 @@ c_sizeof (type)
 
       if (code == OFFSET_TYPE)
 	{
-	  cp_error ("`sizeof' applied to non-static member");
+	  error ("`sizeof' applied to non-static member");
 	  size = size_zero_node;
 	}
       else if (!COMPLETE_TYPE_P (complete_type (type)))
 	{
-	  cp_error ("`sizeof' applied to incomplete type `%T'", type);
+	  error ("`sizeof' applied to incomplete type `%T'", type);
 	  size = size_zero_node;
 	}
       else
@@ -1877,7 +1877,7 @@ string_conv_p (totype, exp, warn)
 
   /* This warning is not very useful, as it complains about printf.  */
   if (warn && warn_write_strings)
-    cp_warning ("deprecated conversion from string constant to `%T'", totype);
+    warning ("deprecated conversion from string constant to `%T'", totype);
 
   return 1;
 }
@@ -1895,7 +1895,7 @@ build_object_ref (datum, basetype, field)
     dtype = TREE_TYPE (dtype);
   if (! IS_AGGR_TYPE_CODE (TREE_CODE (dtype)))
     {
-      cp_error ("request for member `%T::%D' in expression of non-aggregate type `%T'",
+      error ("request for member `%T::%D' in expression of non-aggregate type `%T'",
 		basetype, field, dtype);
       return error_mark_node;
     }
@@ -2038,7 +2038,7 @@ build_component_ref (datum, component, basetype_path, protect)
 			      basetype_path, protect));
 
     case TEMPLATE_DECL:
-      cp_error ("invalid use of %D", datum);
+      error ("invalid use of %D", datum);
       datum = error_mark_node;
       break;
 
@@ -2076,7 +2076,7 @@ build_component_ref (datum, component, basetype_path, protect)
   if (! IS_AGGR_TYPE_CODE (code))
     {
       if (code != ERROR_MARK)
-	cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
+	error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
 		  component, datum, basetype);
       return error_mark_node;
     }
@@ -2088,13 +2088,13 @@ build_component_ref (datum, component, basetype_path, protect)
     {
       if (TYPE_IDENTIFIER (basetype) != TREE_OPERAND (component, 0))
 	{
-	  cp_error ("destructor specifier `%T::~%T' must have matching names",
+	  error ("destructor specifier `%T::~%T' must have matching names",
 		    basetype, TREE_OPERAND (component, 0));
 	  return error_mark_node;
 	}
       if (! TYPE_HAS_DESTRUCTOR (basetype))
 	{
-	  cp_error ("type `%T' has no destructor", basetype);
+	  error ("type `%T' has no destructor", basetype);
 	  return error_mark_node;
 	}
       return TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 1);
@@ -2111,12 +2111,12 @@ build_component_ref (datum, component, basetype_path, protect)
     field = component;
   else if (TREE_CODE (component) == TYPE_DECL)
     {
-      cp_error ("invalid use of type decl `%#D' as expression", component);
+      error ("invalid use of type decl `%#D' as expression", component);
       return error_mark_node;
     }
   else if (TREE_CODE (component) == TEMPLATE_DECL)
     {
-      cp_error ("invalid use of template `%#D' as expression", component);
+      error ("invalid use of template `%#D' as expression", component);
       return error_mark_node;
     }
   else
@@ -2175,7 +2175,7 @@ build_component_ref (datum, component, basetype_path, protect)
 	      return ref;
 	    }
 
-	  cp_error ("`%#T' has no member named `%D'", basetype, name);
+	  error ("`%#T' has no member named `%D'", basetype, name);
 	  return error_mark_node;
 	}
       else if (TREE_TYPE (field) == error_mark_node)
@@ -2184,7 +2184,7 @@ build_component_ref (datum, component, basetype_path, protect)
       if (TREE_CODE (field) != FIELD_DECL)
 	{
 	  if (TREE_CODE (field) == TYPE_DECL)
-	    cp_pedwarn ("invalid use of type decl `%#D' as expression", field);
+	    pedwarn ("invalid use of type decl `%#D' as expression", field);
 	  else if (DECL_RTL (field) != 0)
 	    mark_used (field);
 	  else
@@ -2342,7 +2342,7 @@ build_indirect_ref (ptr, errorstring)
         {
           /* A pointer to incomplete type (other than cv void) can be
              dereferenced [expr.unary.op]/1  */
-          cp_error ("`%T' is not a pointer-to-object type", type);
+          error ("`%T' is not a pointer-to-object type", type);
           return error_mark_node;
         }
       else if (TREE_CODE (pointer) == ADDR_EXPR
@@ -2688,7 +2688,7 @@ build_x_function_call (function, params, decl)
 	{
 	  if (current_class_type == NULL_TREE)
 	    {
-	      cp_error ("object missing in call to method `%D'", function);
+	      error ("object missing in call to method `%D'", function);
 	      return error_mark_node;
 	    }
 	  /* Yow: call from a static member function.  */
@@ -2722,7 +2722,7 @@ build_x_function_call (function, params, decl)
     {
       if (OVL_FUNCTION (function) == NULL_TREE)
 	{
-	  cp_error ("function `%D' declared overloaded, but no definitions appear with which to resolve it?!?",
+	  error ("function `%D' declared overloaded, but no definitions appear with which to resolve it?!?",
 		    TREE_PURPOSE (function));
 	  return error_mark_node;
 	}
@@ -2946,7 +2946,7 @@ get_member_function_from_ptrfunc (instance_ptrptr, function)
       if (instance_ptr == error_mark_node
 	  && TREE_CODE (e1) != ADDR_EXPR
 	  && TREE_CODE (TREE_OPERAND (e1, 0)) != FUNCTION_DECL)
-	cp_error ("object missing in `%E'", function);
+	error ("object missing in `%E'", function);
 
       function = e1;
     }
@@ -3010,7 +3010,7 @@ build_function_call_real (function, params, require_complete, flags)
 
   if (TYPE_PTRMEMFUNC_P (fntype))
     {
-      cp_error ("must use .* or ->* to call pointer-to-member function in `%E (...)'",
+      error ("must use .* or ->* to call pointer-to-member function in `%E (...)'",
 		function);
       return error_mark_node;
     }
@@ -3023,7 +3023,7 @@ build_function_call_real (function, params, require_complete, flags)
 	|| is_method
 	|| TREE_CODE (function) == TEMPLATE_ID_EXPR))
     {
-      cp_error ("`%E' cannot be used as a function", function);
+      error ("`%E' cannot be used as a function", function);
       return error_mark_node;
     }
 
@@ -3384,7 +3384,7 @@ build_binary_op (code, orig_op0, orig_op1, convert_p)
       tree t = instantiate_type (TREE_TYPE (op1), op0, itf_none);
       if (t != error_mark_node)
 	{
-	  cp_pedwarn ("assuming cast to type `%T' from overloaded function",
+	  pedwarn ("assuming cast to type `%T' from overloaded function",
 		      TREE_TYPE (t));
 	  op0 = t;
 	}
@@ -3394,7 +3394,7 @@ build_binary_op (code, orig_op0, orig_op1, convert_p)
       tree t = instantiate_type (TREE_TYPE (op0), op1, itf_none);
       if (t != error_mark_node)
 	{
-	  cp_pedwarn ("assuming cast to type `%T' from overloaded function",
+	  pedwarn ("assuming cast to type `%T' from overloaded function",
 		      TREE_TYPE (t));
 	  op1 = t;
 	}
@@ -3454,9 +3454,9 @@ build_binary_op (code, orig_op0, orig_op1, convert_p)
 	      || code1 == COMPLEX_TYPE))
 	{
 	  if (TREE_CODE (op1) == INTEGER_CST && integer_zerop (op1))
-	    cp_warning ("division by zero in `%E / 0'", op0);
+	    warning ("division by zero in `%E / 0'", op0);
 	  else if (TREE_CODE (op1) == REAL_CST && real_zerop (op1))
-	    cp_warning ("division by zero in `%E / 0.'", op0);
+	    warning ("division by zero in `%E / 0.'", op0);
 	      
 	  if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
 	    resultcode = RDIV_EXPR;
@@ -3511,9 +3511,9 @@ build_binary_op (code, orig_op0, orig_op1, convert_p)
     case TRUNC_MOD_EXPR:
     case FLOOR_MOD_EXPR:
       if (code1 == INTEGER_TYPE && integer_zerop (op1))
-	cp_warning ("division by zero in `%E %% 0'", op0);
+	warning ("division by zero in `%E %% 0'", op0);
       else if (code1 == REAL_TYPE && real_zerop (op1))
-	cp_warning ("division by zero in `%E %% 0.'", op0);
+	warning ("division by zero in `%E %% 0.'", op0);
       
       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
 	{
@@ -3908,7 +3908,7 @@ build_binary_op (code, orig_op0, orig_op1, convert_p)
 	      && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
 	         != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
 	    {
-	      cp_warning ("comparison between types `%#T' and `%#T'", 
+	      warning ("comparison between types `%#T' and `%#T'", 
 			  TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
 	    }
 
@@ -4009,7 +4009,7 @@ build_binary_op (code, orig_op0, orig_op1, convert_p)
 
   if (!result_type)
     {
-      cp_error ("invalid operands of types `%T' and `%T' to binary `%O'",
+      error ("invalid operands of types `%T' and `%T' to binary `%O'",
 		TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), code);
       return error_mark_node;
     }
@@ -4031,7 +4031,7 @@ build_binary_op (code, orig_op0, orig_op1, convert_p)
        performed.  Note that pointer-difference and pointer-addition
        have already been handled above, and so we don't end up here in
        that case.  */
-    cp_warning ("NULL used in arithmetic");
+    warning ("NULL used in arithmetic");
 
   if (! converted)
     {
@@ -4227,7 +4227,7 @@ build_component_addr (arg, argtype)
 
   if (DECL_C_BIT_FIELD (field))
     {
-      cp_error ("attempt to take address of bit-field structure member `%D'",
+      error ("attempt to take address of bit-field structure member `%D'",
                 field);
       return error_mark_node;
     }
@@ -4512,14 +4512,14 @@ build_unary_op (code, xarg, noconvert)
 	    tree type = complete_type (TREE_TYPE (argtype));
 	    
 	    if (!COMPLETE_OR_VOID_TYPE_P (type))
-	      cp_error ("cannot %s a pointer to incomplete type `%T'",
+	      error ("cannot %s a pointer to incomplete type `%T'",
 			((code == PREINCREMENT_EXPR
 			  || code == POSTINCREMENT_EXPR)
 			 ? "increment" : "decrement"), TREE_TYPE (argtype));
 	    else if ((pedantic || warn_pointer_arith)
 		     && (tmp == FUNCTION_TYPE || tmp == METHOD_TYPE
 			 || tmp == VOID_TYPE || tmp == OFFSET_TYPE))
-	      cp_pedwarn ("ISO C++ forbids %sing a pointer of type `%T'",
+	      pedwarn ("ISO C++ forbids %sing a pointer of type `%T'",
 			  ((code == PREINCREMENT_EXPR
 			    || code == POSTINCREMENT_EXPR)
 			   ? "increment" : "decrement"), argtype);
@@ -4578,7 +4578,7 @@ build_unary_op (code, xarg, noconvert)
 	  {
 	    if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR)
 	      {
-		cp_error ("invalid use of `--' on bool variable `%D'", arg);
+		error ("invalid use of `--' on bool variable `%D'", arg);
 		return error_mark_node;
 	      }
 #if 0
@@ -4678,9 +4678,9 @@ build_unary_op (code, xarg, noconvert)
 	      if (current_class_type
 		  && TREE_OPERAND (arg, 0) == current_class_ref)
 		/* An expression like &memfn.  */
-		cp_pedwarn ("ISO C++ forbids taking the address of an unqualified non-static member function to form a pointer to member function.  Say `&%T::%D'", base, name);
+		pedwarn ("ISO C++ forbids taking the address of an unqualified non-static member function to form a pointer to member function.  Say `&%T::%D'", base, name);
 	      else
-		cp_pedwarn ("ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say `&%T::%D'", base, name);
+		pedwarn ("ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say `&%T::%D'", base, name);
 	    }
 	  arg = build_offset_ref (base, name);
         }
@@ -4840,7 +4840,7 @@ unary_complex_lvalue (code, arg)
       if (TREE_CODE (t) == FUNCTION_DECL)
 	{
 	  if (DECL_DESTRUCTOR_P (t))
-	    cp_error ("taking address of destructor");
+	    error ("taking address of destructor");
 	  return build_unary_op (ADDR_EXPR, t, 0);
 	}
       if (TREE_CODE (t) == VAR_DECL)
@@ -4853,7 +4853,7 @@ unary_complex_lvalue (code, arg)
 	      && ! is_dummy_object (TREE_OPERAND (arg, 0))
 	      && TREE_CODE (t) != FIELD_DECL)
 	    {
-	      cp_error ("taking address of bound pointer-to-member expression");
+	      error ("taking address of bound pointer-to-member expression");
 	      return error_mark_node;
 	    }
 
@@ -4937,7 +4937,7 @@ mark_addressable (exp)
       case RESULT_DECL:
 	if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
 	    && !DECL_ARTIFICIAL (x) && extra_warnings)
-	  cp_warning ("address requested for `%D', which is declared `register'",
+	  warning ("address requested for `%D', which is declared `register'",
 		      x);
 	TREE_ADDRESSABLE (x) = 1;
 	return 1;
@@ -5141,7 +5141,7 @@ build_static_cast (type, expr)
      constness.  */
   if (ok && casts_away_constness (intype, type))
     {
-      cp_error ("static_cast from type `%T' to type `%T' casts away constness",
+      error ("static_cast from type `%T' to type `%T' casts away constness",
 		intype, type);
       return error_mark_node;
     }
@@ -5149,7 +5149,7 @@ build_static_cast (type, expr)
   if (ok)
     return build_c_cast (type, expr);
 
-  cp_error ("invalid static_cast from type `%T' to type `%T'", intype, type);
+  error ("invalid static_cast from type `%T' to type `%T'", intype, type);
   return error_mark_node;
 }
 
@@ -5188,7 +5188,7 @@ build_reinterpret_cast (type, expr)
     {
       if (! real_lvalue_p (expr))
 	{
-	  cp_error ("invalid reinterpret_cast of an rvalue expression of type `%T' to type `%T'", intype, type);
+	  error ("invalid reinterpret_cast of an rvalue expression of type `%T' to type `%T'", intype, type);
 	  return error_mark_node;
 	}
       expr = build_unary_op (ADDR_EXPR, expr, 0);
@@ -5208,7 +5208,7 @@ build_reinterpret_cast (type, expr)
   else if (TREE_CODE (type) == INTEGER_TYPE && TYPE_PTR_P (intype))
     {
       if (TYPE_PRECISION (type) < TYPE_PRECISION (intype))
-	cp_pedwarn ("reinterpret_cast from `%T' to `%T' loses precision",
+	pedwarn ("reinterpret_cast from `%T' to `%T' loses precision",
 		    intype, type);
     }
   else if ((TYPE_PTRFN_P (type) && TYPE_PTRFN_P (intype))
@@ -5221,7 +5221,7 @@ build_reinterpret_cast (type, expr)
 	   || (TYPE_PTROBV_P (type) && TYPE_PTROBV_P (intype)))
     {
       if (! comp_ptr_ttypes_reinterpret (TREE_TYPE (type), TREE_TYPE (intype)))
-	cp_pedwarn ("reinterpret_cast from `%T' to `%T' casts away const (or volatile)",
+	pedwarn ("reinterpret_cast from `%T' to `%T' casts away const (or volatile)",
 		    intype, type);
 
       expr = decl_constant_value (expr);
@@ -5236,7 +5236,7 @@ build_reinterpret_cast (type, expr)
     }
   else
     {
-      cp_error ("invalid reinterpret_cast from type `%T' to type `%T'",
+      error ("invalid reinterpret_cast from type `%T' to type `%T'",
                 intype, type);
       return error_mark_node;
     }
@@ -5263,10 +5263,10 @@ build_const_cast (type, expr)
     }
 
   if (!POINTER_TYPE_P (type))
-    cp_error ("invalid use of const_cast with type `%T', which is not a pointer, reference, nor a pointer-to-data-member type", type);
+    error ("invalid use of const_cast with type `%T', which is not a pointer, reference, nor a pointer-to-data-member type", type);
   else if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
     {
-      cp_error ("invalid use of const_cast with type `%T', which is a pointer or reference to a function type", type);
+      error ("invalid use of const_cast with type `%T', which is a pointer or reference to a function type", type);
       return error_mark_node;
     }
 
@@ -5289,7 +5289,7 @@ build_const_cast (type, expr)
     {
       if (! real_lvalue_p (expr))
 	{
-	  cp_error ("invalid const_cast of an rvalue of type `%T' to type `%T'", intype, type);
+	  error ("invalid const_cast of an rvalue of type `%T' to type `%T'", intype, type);
 	  return error_mark_node;
 	}
 
@@ -5305,7 +5305,7 @@ build_const_cast (type, expr)
 	   && comp_ptr_ttypes_const (TREE_TYPE (type), TREE_TYPE (intype)))
     return cp_convert (type, expr);
 
-  cp_error ("invalid const_cast from type `%T' to type `%T'", intype, type);
+  error ("invalid const_cast from type `%T' to type `%T'", intype, type);
   return error_mark_node;
 }
 
@@ -5347,12 +5347,12 @@ build_c_cast (type, expr)
 	 NIHCL uses it. It is not valid ISO C++ however.  */
       if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
 	{
-	  cp_pedwarn ("ISO C++ forbids casting to an array type `%T'", type);
+	  pedwarn ("ISO C++ forbids casting to an array type `%T'", type);
 	  type = build_pointer_type (TREE_TYPE (type));
 	}
       else
 	{
-	  cp_error ("ISO C++ forbids casting to an array type `%T'", type);
+	  error ("ISO C++ forbids casting to an array type `%T'", type);
 	  return error_mark_node;
 	}
     }
@@ -5360,7 +5360,7 @@ build_c_cast (type, expr)
   if (TREE_CODE (type) == FUNCTION_TYPE
       || TREE_CODE (type) == METHOD_TYPE)
     {
-      cp_error ("invalid cast to function type `%T'", type);
+      error ("invalid cast to function type `%T'", type);
       return error_mark_node;
     }
 
@@ -5412,7 +5412,7 @@ build_c_cast (type, expr)
       && TREE_CODE (otype) == POINTER_TYPE
       && !at_least_as_qualified_p (TREE_TYPE (type),
 				   TREE_TYPE (otype)))
-    cp_warning ("cast from `%T' to `%T' discards qualifiers from pointer target type",
+    warning ("cast from `%T' to `%T' discards qualifiers from pointer target type",
                 otype, type);
 
   if (TREE_CODE (type) == INTEGER_TYPE
@@ -5458,7 +5458,7 @@ build_c_cast (type, expr)
       && COMPLETE_TYPE_P (TREE_TYPE (otype))
       && COMPLETE_TYPE_P (TREE_TYPE (type))
       && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
-    cp_warning ("cast from `%T' to `%T' increases required alignment of target type",
+    warning ("cast from `%T' to `%T' increases required alignment of target type",
                 otype, type);
 
     /* Always produce some operator for an explicit cast,
@@ -5646,7 +5646,7 @@ build_modify_expr (lhs, modifycode, rhs)
       newrhs = cp_build_binary_op (modifycode, lhs, rhs);
       if (newrhs == error_mark_node)
 	{
-	  cp_error ("  in evaluation of `%Q(%#T, %#T)'", modifycode,
+	  error ("  in evaluation of `%Q(%#T, %#T)'", modifycode,
 		    TREE_TYPE (lhs), TREE_TYPE (rhs));
 	  return error_mark_node;
 	}
@@ -5779,7 +5779,7 @@ build_modify_expr (lhs, modifycode, rhs)
       
       if (!same_or_base_type_p (lhstype, TREE_TYPE (rhs)))
 	{
-	  cp_error ("incompatible types in assignment of `%T' to `%T'",
+	  error ("incompatible types in assignment of `%T' to `%T'",
 		    TREE_TYPE (rhs), lhstype);
 	  return error_mark_node;
 	}
@@ -5957,7 +5957,7 @@ get_delta_difference (from, to, force)
       if (virt_binfo)
         {
           /* This is a reinterpret cast, we choose to do nothing. */
-          cp_warning ("pointer to member cast via virtual base `%T' of `%T'",
+          warning ("pointer to member cast via virtual base `%T' of `%T'",
 	              BINFO_TYPE (virt_binfo),
 	              BINFO_TYPE (BINFO_INHERITANCE_CHAIN (virt_binfo)));
           return delta;
@@ -5976,11 +5976,11 @@ get_delta_difference (from, to, force)
     {
       /* This is a reinterpret cast, we choose to do nothing. */
       if (force)
-        cp_warning ("pointer to member cast via virtual base `%T' of `%T'",
+        warning ("pointer to member cast via virtual base `%T' of `%T'",
                     BINFO_TYPE (virt_binfo),
                     BINFO_TYPE (BINFO_INHERITANCE_CHAIN (virt_binfo)));
       else
-	cp_error ("pointer to member conversion via virtual base `%T' of `%T'",
+	error ("pointer to member conversion via virtual base `%T' of `%T'",
 		  BINFO_TYPE (virt_binfo),
                   BINFO_TYPE (BINFO_INHERITANCE_CHAIN (virt_binfo)));
       return delta;
@@ -6050,7 +6050,7 @@ build_ptrmemfunc (type, pfn, force)
 
       if (!force 
 	  && !can_convert_arg (to_type, TREE_TYPE (pfn), pfn))
-	cp_error ("invalid conversion to type `%T' from type `%T'", 
+	error ("invalid conversion to type `%T' from type `%T'", 
 		  to_type, pfn_type);
 
       n = get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type),
@@ -6215,10 +6215,10 @@ dubious_conversion_warnings (type, expr, errtype, fndecl, parmnum)
   if (ARITHMETIC_TYPE_P (type) && expr == null_node)
     {
       if (fndecl)
-        cp_warning ("passing NULL used for non-pointer %s %P of `%D'",
+        warning ("passing NULL used for non-pointer %s %P of `%D'",
                     errtype, parmnum, fndecl);
       else
-        cp_warning ("%s to non-pointer type `%T' from NULL", errtype, type);
+        warning ("%s to non-pointer type `%T' from NULL", errtype, type);
     }
   
   /* Warn about assigning a floating-point type to an integer type.  */
@@ -6226,10 +6226,10 @@ dubious_conversion_warnings (type, expr, errtype, fndecl, parmnum)
       && TREE_CODE (type) == INTEGER_TYPE)
     {
       if (fndecl)
-	cp_warning ("passing `%T' for %s %P of `%D'",
+	warning ("passing `%T' for %s %P of `%D'",
 		    TREE_TYPE (expr), errtype, parmnum, fndecl);
       else
-	cp_warning ("%s to `%T' from `%T'", errtype, type, TREE_TYPE (expr));
+	warning ("%s to `%T' from `%T'", errtype, type, TREE_TYPE (expr));
     }
   /* And warn about assigning a negative value to an unsigned
      variable.  */
@@ -6239,10 +6239,10 @@ dubious_conversion_warnings (type, expr, errtype, fndecl, parmnum)
 	  && TREE_NEGATED_INT (expr))
 	{
 	  if (fndecl)
-	    cp_warning ("passing negative value `%E' for %s %P of `%D'",
+	    warning ("passing negative value `%E' for %s %P of `%D'",
 			expr, errtype, parmnum, fndecl);
 	  else
-	    cp_warning ("%s of negative value `%E' to `%T'",
+	    warning ("%s of negative value `%E' to `%T'",
 			errtype, expr, type);
 	}
 
@@ -6329,10 +6329,10 @@ convert_for_assignment (type, rhs, errtype, fndecl, parmnum)
 	  if (rhstype == unknown_type_node)
 	    instantiate_type (type, rhs, itf_complain);
 	  else if (fndecl)
-	    cp_error ("cannot convert `%T' to `%T' for argument `%P' to `%D'",
+	    error ("cannot convert `%T' to `%T' for argument `%P' to `%D'",
 		      rhstype, type, parmnum, fndecl);
 	  else
-	    cp_error ("cannot convert `%T' to `%T' in %s", rhstype, type, 
+	    error ("cannot convert `%T' to `%T' in %s", rhstype, type, 
 		      errtype);
 	  return error_mark_node;
 	}
@@ -6653,13 +6653,13 @@ check_return_expr (retval)
       && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl))
       && ! flag_check_new
       && null_ptr_cst_p (retval))
-    cp_warning ("`operator new' must not return NULL unless it is declared `throw()' (or -fcheck-new is in effect)");
+    warning ("`operator new' must not return NULL unless it is declared `throw()' (or -fcheck-new is in effect)");
 
   /* Effective C++ rule 15.  See also start_function.  */
   if (warn_ecpp
       && DECL_NAME (current_function_decl) == ansi_assopname(NOP_EXPR)
       && retval != current_class_ref)
-    cp_warning ("`operator=' should return a reference to `*this'");
+    warning ("`operator=' should return a reference to `*this'");
 
   /* The fabled Named Return Value optimization, as per [class.copy]/15:
 
diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c
index 71677dd..2706c13 100644
--- a/gcc/cp/typeck2.c
+++ b/gcc/cp/typeck2.c
@@ -51,7 +51,7 @@ error_not_base_type (basetype, type)
 {
   if (TREE_CODE (basetype) == FUNCTION_DECL)
     basetype = DECL_CONTEXT (basetype);
-  cp_error ("type `%T' is not a base type for type `%T'", basetype, type);
+  error ("type `%T' is not a base type for type `%T'", basetype, type);
   return error_mark_node;
 }
 
@@ -83,9 +83,9 @@ readonly_error (arg, string, soft)
   void (*fn) PARAMS ((const char *, ...));
 
   if (soft)
-    fn = cp_pedwarn;
+    fn = pedwarn;
   else
-    fn = cp_error;
+    fn = error;
 
   if (TREE_CODE (arg) == COMPONENT_REF)
     {
@@ -148,22 +148,22 @@ abstract_virtuals_error (decl, type)
 	return 0;
 
       if (TREE_CODE (decl) == VAR_DECL)
-	cp_error ("cannot declare variable `%D' to be of type `%T'",
+	error ("cannot declare variable `%D' to be of type `%T'",
 		    decl, type);
       else if (TREE_CODE (decl) == PARM_DECL)
-	cp_error ("cannot declare parameter `%D' to be of type `%T'",
+	error ("cannot declare parameter `%D' to be of type `%T'",
 		    decl, type);
       else if (TREE_CODE (decl) == FIELD_DECL)
-	cp_error ("cannot declare field `%D' to be of type `%T'",
+	error ("cannot declare field `%D' to be of type `%T'",
 		    decl, type);
       else if (TREE_CODE (decl) == FUNCTION_DECL
 	       && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
-	cp_error ("invalid return type for member function `%#D'", decl);
+	error ("invalid return type for member function `%#D'", decl);
       else if (TREE_CODE (decl) == FUNCTION_DECL)
-	cp_error ("invalid return type for function `%#D'", decl);
+	error ("invalid return type for function `%#D'", decl);
     }
   else
-    cp_error ("cannot allocate an object of type `%T'", type);
+    error ("cannot allocate an object of type `%T'", type);
 
   /* Only go through this once.  */
   if (TREE_PURPOSE (u) == NULL_TREE)
@@ -175,7 +175,7 @@ abstract_virtuals_error (decl, type)
 	cp_error_at ("\t%#D", TREE_VALUE (tu));
     }
   else
-    cp_error ("  since type `%T' has abstract virtual functions", type);
+    error ("  since type `%T' has abstract virtual functions", type);
 
   return 1;
 }
@@ -210,12 +210,12 @@ retry:
     case UNION_TYPE:
     case ENUMERAL_TYPE:
       if (!decl)
-        cp_error ("invalid use of undefined type `%#T'", type);
+        error ("invalid use of undefined type `%#T'", type);
       cp_error_at ("forward declaration of `%#T'", type);
       break;
 
     case VOID_TYPE:
-      cp_error ("invalid use of `%T'", type);
+      error ("invalid use of `%T'", type);
       break;
 
     case ARRAY_TYPE:
@@ -224,27 +224,27 @@ retry:
           type = TREE_TYPE (type);
           goto retry;
         }
-      cp_error ("invalid use of array with unspecified bounds");
+      error ("invalid use of array with unspecified bounds");
       break;
 
     case OFFSET_TYPE:
     bad_member:
-      cp_error ("invalid use of member (did you forget the `&' ?)");
+      error ("invalid use of member (did you forget the `&' ?)");
       break;
 
     case TEMPLATE_TYPE_PARM:
-      cp_error ("invalid use of template type parameter");
+      error ("invalid use of template type parameter");
       break;
 
     case UNKNOWN_TYPE:
       if (value && TREE_CODE (value) == COMPONENT_REF)
         goto bad_member;
       else if (value && TREE_CODE (value) == ADDR_EXPR)
-        cp_error ("address of overloaded function with no contextual type information");
+        error ("address of overloaded function with no contextual type information");
       else if (value && TREE_CODE (value) == OVERLOAD)
-        cp_error ("overloaded function with no contextual type information");
+        error ("overloaded function with no contextual type information");
       else
-        cp_error ("insufficient contextual information to determine type");
+        error ("insufficient contextual information to determine type");
       break;
     
     default:
@@ -322,7 +322,7 @@ store_init_value (decl, init)
 
       if (TREE_CODE (init) == TREE_LIST)
 	{
-	  cp_error ("constructor syntax used, but no constructor declared for type `%T'", type);
+	  error ("constructor syntax used, but no constructor declared for type `%T'", type);
 	  init = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (init));
 	}
 #if 0
@@ -576,10 +576,10 @@ digest_init (type, init, tail)
 	}
       while (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
 	{
-	  cp_pedwarn ("braces around scalar initializer for `%T'", type);
+	  pedwarn ("braces around scalar initializer for `%T'", type);
 	  init = CONSTRUCTOR_ELTS (init);
 	  if (TREE_CHAIN (init))
-	    cp_pedwarn ("ignoring extra initializers for `%T'", type);
+	    pedwarn ("ignoring extra initializers for `%T'", type);
 	  init = TREE_VALUE (init);
 	}
 
@@ -591,7 +591,7 @@ digest_init (type, init, tail)
 
   if (COMPLETE_TYPE_P (type) && ! TREE_CONSTANT (TYPE_SIZE (type)))
     {
-      cp_error ("variable-sized object of type `%T' may not be initialized",
+      error ("variable-sized object of type `%T' may not be initialized",
 		type);
       return error_mark_node;
     }
@@ -601,7 +601,7 @@ digest_init (type, init, tail)
       if (raw_constructor && TYPE_NON_AGGREGATE_CLASS (type)
 	  && TREE_HAS_CONSTRUCTOR (init))
 	{
-	  cp_error ("subobject of type `%T' must be initialized by constructor, not by `%E'",
+	  error ("subobject of type `%T' must be initialized by constructor, not by `%E'",
 		    type, init);
 	  return error_mark_node;
 	}
@@ -839,24 +839,24 @@ process_init_constructor (type, init, elts)
 	      /* Warn when some struct elements are implicitly initialized.  */
 	      if (extra_warnings
 	          && (!init || TREE_HAS_CONSTRUCTOR (init)))
-		cp_warning ("missing initializer for member `%D'", field);
+		warning ("missing initializer for member `%D'", field);
 	    }
 	  else
 	    {
 	      if (TREE_READONLY (field))
-		cp_error ("uninitialized const member `%D'", field);
+		error ("uninitialized const member `%D'", field);
 	      else if (TYPE_LANG_SPECIFIC (TREE_TYPE (field))
 		       && CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
-		cp_error ("member `%D' with uninitialized const fields",
+		error ("member `%D' with uninitialized const fields",
 			  field);
 	      else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
-		cp_error ("member `%D' is uninitialized reference", field);
+		error ("member `%D' is uninitialized reference", field);
 
 	      /* Warn when some struct elements are implicitly initialized
 		 to zero.  */
 	      if (extra_warnings
 	          && (!init || TREE_HAS_CONSTRUCTOR (init)))
-		cp_warning ("missing initializer for member `%D'", field);
+		warning ("missing initializer for member `%D'", field);
 
 	      /* The default zero-initialization is fine for us; don't
 		 add anything to the CONSTRUCTOR.  */
@@ -905,7 +905,7 @@ process_init_constructor (type, init, elts)
 	      if (temp)
 		field = temp, win = 1;
 	      else
-		cp_error ("no field `%D' in union being initialized",
+		error ("no field `%D' in union being initialized",
 			  TREE_PURPOSE (tail));
 	    }
 	  if (!win)
@@ -913,7 +913,7 @@ process_init_constructor (type, init, elts)
 	}
       else if (field == 0)
 	{
-	  cp_error ("union `%T' with no named members cannot be initialized",
+	  error ("union `%T' with no named members cannot be initialized",
 		    type);
 	  TREE_VALUE (tail) = error_mark_node;
 	}
@@ -1067,7 +1067,7 @@ build_x_arrow (datum)
 
       if (last_rval == NULL_TREE)
 	{
-	  cp_error ("base operand of `->' has non-pointer type `%T'", type);
+	  error ("base operand of `->' has non-pointer type `%T'", type);
 	  return error_mark_node;
 	}
 
@@ -1131,15 +1131,15 @@ build_m_component_ref (datum, component)
     }
   else
     {
-      cp_error ("`%E' cannot be used as a member pointer, since it is of type `%T'", 
+      error ("`%E' cannot be used as a member pointer, since it is of type `%T'", 
 		component, TREE_TYPE (component));
       return error_mark_node;
     }
 
   if (! IS_AGGR_TYPE (objtype))
     {
-      cp_error ("cannot apply member pointer `%E' to `%E'", component, datum);
-      cp_error ("which is of non-aggregate type `%T'", objtype);
+      error ("cannot apply member pointer `%E' to `%E'", component, datum);
+      error ("which is of non-aggregate type `%T'", objtype);
       return error_mark_node;
     }
 
@@ -1147,7 +1147,7 @@ build_m_component_ref (datum, component)
 		       ba_check, NULL);
   if (!binfo)
     {
-      cp_error ("member type `%T::' incompatible with object type `%T'",
+      error ("member type `%T::' incompatible with object type `%T'",
 		TYPE_METHOD_BASETYPE (type), objtype);
       return error_mark_node;
     }
@@ -1201,7 +1201,7 @@ build_functional_cast (exp, parms)
 	  type = lookup_name (exp, 1);
 	  if (!type || TREE_CODE (type) != TYPE_DECL)
 	    {
-	      cp_error ("`%T' fails to be a typedef or built-in type", exp);
+	      error ("`%T' fails to be a typedef or built-in type", exp);
 	      return error_mark_node;
 	    }
 	  type = TREE_TYPE (type);