From: Zack Weinberg Date: Tue, 18 Dec 2001 03:35:42 +0000 (+0000) Subject: cp-tree.h: Delete #defines for cp_error, cp_warning, cp_pedwarn, and cp_compiler_error. X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=33bd39a26a88cbaabb2f85735c1ff1e51f2a7111;p=gcc.git 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 --- diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index d22f1620a30..fc33867690a 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,14 @@ +2001-12-17 Zack Weinberg + + * 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 * 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 - * 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 @@ -225,7 +236,7 @@ Wed Dec 5 17:00:49 2001 Richard Kenner 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 * cp/search.c (lookup_base_r): Declare bk in variable declaration space. - + 2001-11-25 Nathan Sidwell PR g++/3145 @@ -351,9 +362,9 @@ Tue Nov 27 09:03:47 2001 Richard Kenner * 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 2001-11-20 Mark Mitchell * 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 (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 PR4629 @@ -494,7 +505,7 @@ Tue Nov 27 09:03:47 2001 Richard Kenner (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 diff --git a/gcc/cp/call.c b/gcc/cp/call.c index bd43a404409..cbe4bc664ac 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) ", str, candidates->fn, + error ("%s %D(%T, %T, %T) ", 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) ", str, candidates->fn, + error ("%s %D(%T, %T) ", 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) ", str, candidates->fn, + error ("%s %D(%T) ", str, candidates->fn, TREE_TYPE (TREE_VEC_ELT (candidates->convs, 0))); } else if (TYPE_P (candidates->fn)) - cp_error ("%s %T ", str, candidates->fn); + error ("%s %T ", str, candidates->fn); else cp_error_at ("%s %+#D%s", str, candidates->fn, candidates->viable == -1 ? " " : ""); @@ -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 b9ed718cf0d..02cb9dba476 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 d4fc1b6de0b..5069648752f 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 6eb0a7a153b..3d02456f32c 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 f9aceaa1e3e..d535097a299 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 friend void f()'. */ - 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 0383593c736..73c934e7aca 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 5b1e6f872c4..d1134709d76 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 32f2458bff9..3f3cdcfd3be 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 95373e89bbc..c43e0348d29 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 friend typename S::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 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 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 c0cc3f300bc..b97bbbae7ea 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 41a4db57aa8..82b14ae5623 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 9dbf1e35aa2..759bfbebd85 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 b49f6eb87a5..ccc3ede819b 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 ($6, $7, $4); $$ = convert_from_reference ($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 7775fcf9bf2..61e7186cf9d 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 void f(); */ - 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 void f(); */ 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 f99f1cc6150..af401299adb 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 6e5e2e5fdc6..a6a9a6d46e9 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 632e9132038..e2081b57a14 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 64222257c58..138e23e6145 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 1d0c32475ad..b1271442a36 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 b721faefc9c..d5ba0840f08 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 71677ddd7d4..2706c13a85c 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);