+2001-12-17 Zack Weinberg <zack@codesourcery.com>
+
+ * cp-tree.h: Delete #defines for cp_error, cp_warning,
+ cp_pedwarn, and cp_compiler_error.
+ * call.c, class.c, cp-tree.h, cvt.c, decl.c, decl2.c, error.c,
+ except.c, friend.c, init.c, lex.c, method.c, parse.y, pt.c,
+ rtti.c, search.c, semantics.c, spew.c, tree.c, typeck.c,
+ typeck2.c: Change calls to the above macros to use their
+ language-independent equivalents: error, warning, pedwarn, and
+ internal_error respectively.
+
2001-12-16 Neil Booth <neil@daikokuya.demon.co.uk>
* decl2.c (finish_file): Remove back_end_hook.
(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
2001-12-08 Aldy Hernandez <aldyh@redhat.com>
- * lex.c (rid_to_yy): Add RID_CHOOSE_EXPR and
- RID_TYPES_COMPATIBLE_P.
+ * lex.c (rid_to_yy): Add RID_CHOOSE_EXPR and
+ RID_TYPES_COMPATIBLE_P.
2001-12-08 John David Anglin <dave@hiauly1.hia.nrc.ca>
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.
* cp/search.c (lookup_base_r): Declare bk in variable declaration
space.
-
+
2001-11-25 Nathan Sidwell <nathan@codesourcery.com>
PR g++/3145
* 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
2001-11-20 Mark Mitchell <mark@codesourcery.com>
* call.c (non_reference): Add documentation.
- (convert_class_to_reference): Do not strip reference types
+ (convert_class_to_reference): Do not strip reference types
from conversion operators.
(maybe_handle_ref_bind): Simplify.
(compare_ics): Correct handling of references.
(cp_dump_tree): Dump CLASSTYPE_TEMPLATE_SPECIALIZATION. Use
dump_op. Dump DECL_MUTABLE, access and staticness for VAR_DECLs.
DECL_PURE_VIRTUAL_P, DECL_VIRTUAL_P,
-
+
2001-11-19 Mark Mitchell <mark@codesourcery.com>
PR4629
(struct lang_hooks): Constify.
* lex.c (cxx_init_options): Update.
(lang_identify): Remove.
- * parse.y (language_string): Remove.
+ * parse.y (language_string): Remove.
2001-11-08 Andreas Franck <afranck@gmx.de>
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
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);
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))
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;
}
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);
if (TREE_CODE (candidates->fn) == IDENTIFIER_NODE)
{
if (TREE_VEC_LENGTH (candidates->convs) == 3)
- cp_error ("%s %D(%T, %T, %T) <builtin>", str, candidates->fn,
+ error ("%s %D(%T, %T, %T) <builtin>", str, candidates->fn,
TREE_TYPE (TREE_VEC_ELT (candidates->convs, 0)),
TREE_TYPE (TREE_VEC_ELT (candidates->convs, 1)),
TREE_TYPE (TREE_VEC_ELT (candidates->convs, 2)));
else if (TREE_VEC_LENGTH (candidates->convs) == 2)
- cp_error ("%s %D(%T, %T) <builtin>", str, candidates->fn,
+ error ("%s %D(%T, %T) <builtin>", str, candidates->fn,
TREE_TYPE (TREE_VEC_ELT (candidates->convs, 0)),
TREE_TYPE (TREE_VEC_ELT (candidates->convs, 1)));
else
- cp_error ("%s %D(%T) <builtin>", str, candidates->fn,
+ error ("%s %D(%T) <builtin>", str, candidates->fn,
TREE_TYPE (TREE_VEC_ELT (candidates->convs, 0)));
}
else if (TYPE_P (candidates->fn))
- cp_error ("%s %T <conversion>", str, candidates->fn);
+ error ("%s %T <conversion>", str, candidates->fn);
else
cp_error_at ("%s %+#D%s", str, candidates->fn,
candidates->viable == -1 ? " <near match>" : "");
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
{
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);
}
{
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);
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;
{
/* 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;
}
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;
}
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;
}
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));
}
}
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;
}
|| (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))
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);
if (!result_type)
{
- cp_error ("operands to ?: have different types");
+ error ("operands to ?: have different types");
return error_mark_node;
}
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;
}
/* 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)
&& 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
&& (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;
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;
}
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;
}
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);
}
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);
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);
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));
}
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);
}
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
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;
}
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;
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);
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;
|| 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;
}
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);
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);
{
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
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;
}
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;
}
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;
}
/* Defer to the local function. */
return;
else
- cp_error ("`%#D' and `%#D' cannot be overloaded",
+ error ("`%#D' and `%#D' cannot be overloaded",
fn, method);
}
}
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
{
*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);
}
}
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;
}
}
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;
}
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;
}
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. */
/* 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;
}
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);
}
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);
}
}
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);
}
}
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 ();
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);
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;
/* 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);
{
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);
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;
}
}
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;
}
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);
/* 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, ...));
/* 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 */
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;
}
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;
}
{
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);
}
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;
}
}
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;
}
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;
}
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;
}
else
msg = "conversion to non-const reference type `%#T' from rvalue of type `%T'";
- cp_pedwarn (msg, reftype, intype);
+ pedwarn (msg, reftype, intype);
}
}
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);
}
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);
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;
&& ((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;
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;
&& 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));
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)
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;
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)
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;
}
{
/* [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);
}
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);
{
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;
}
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;
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);
}
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);
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. */
/* 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;
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);
}
&& 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);
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);
}
&& 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;
{
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
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);
}
}
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 ())
{
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));
}
}
{
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);
}
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);
&& ! 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);
/* 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);
}
}
&& !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);
}
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);
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. */
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;
&& 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);
}
}
/* 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,
/* 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);
}
}
/* 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;
}
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)
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))
&& !(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))
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;
}
}
/* 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);
if (! identified)
{
if (decl)
- cp_pedwarn ("jump to label `%D'", decl);
+ pedwarn ("jump to label `%D'", decl);
else
pedwarn ("jump to case label");
if (! identified)
{
if (decl)
- cp_pedwarn ("jump to label `%D'", decl);
+ pedwarn ("jump to label `%D'", decl);
else
pedwarn ("jump to case label");
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
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");
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)
&& !(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;
}
{
/* 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;
}
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;
}
return val;
}
- cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
+ error ("`%D' undeclared in namespace `%D'", name, namespace);
return error_mark_node;
}
}
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)
/* 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;
}
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;
}
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;
}
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;
}
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;
}
&& ! (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);
}
}
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);
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;
}
{
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);
}
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;
{
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 ())
{
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);
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;
}
}
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);
}
; /* 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;
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;
}
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)). */
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;
}
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;
}
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;
}
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
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);
}
/* 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
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)
&& 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
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;
}
{
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;
}
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);
}
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;
}
&& 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;
}
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 ())
{
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;
}
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);
/* 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 ("\
}
}
else
- cp_pedwarn ("non-local function `%#D' uses local type `%T'",
+ pedwarn ("non-local function `%#D' uses local type `%T'",
decl, t);
}
}
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;
}
&& TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
{
if (funcdef_flag)
- cp_error
+ error
("defining explicit specialization `%D' in friend declaration",
orig_declarator);
else
if (PROCESSING_REAL_TEMPLATE_DECL_P ())
{
/* Something like `template <class T> friend void f<T>()'. */
- cp_error ("invalid use of template-id `%D' in declaration of primary template",
+ error ("invalid use of template-id `%D' in declaration of primary template",
orig_declarator);
return NULL_TREE;
}
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;
}
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)
{
/* 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;
}
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);
}
}
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
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;
}
&& 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;
}
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
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
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. */
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;
}
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;
}
{
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;
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;
}
finish_decl (decl, init, NULL_TREE);
}
else
- cp_error ("invalid declarator");
+ error ("invalid declarator");
return 0;
}
innermost_code = TREE_CODE (decl);
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);
}
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;
}
{
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;
}
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);
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);
}
}
}
&& 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;
}
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
{
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;
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
{
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;
{
/* 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.
&& (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
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;
}
&& 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),
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;
}
}
if (quals)
{
- cp_error ("constructors may not be `%s'",
+ error ("constructors may not be `%s'",
IDENTIFIER_POINTER (TREE_VALUE (quals)));
quals = NULL_TREE;
}
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);
}
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;
}
&& (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);
}
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)
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;
}
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;
}
/* 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
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);
}
{
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;
}
|| 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);
}
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;
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);
}
&& 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 ();
}
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)
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;
}
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;
}
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;
}
{
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;
}
&& (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. */
&& 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;
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;
}
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)
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)
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);
}
|| !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;
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;
}
{
/* 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;
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;
}
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);
}
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;
|| 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))
|| TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
goto foundaggr;
}
- cp_error
+ error
("`%D' must have an argument of class or enumerated type",
decl);
foundaggr:
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))
{
&& ! 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);
}
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. */
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);
}
}
}
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)) */
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. */
&& (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);
}
|| 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;
|| 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);
}
}
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));
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;
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);
if (tag_code == union_type)
{
- cp_error ("derived union `%T' invalid", ref);
+ error ("derived union `%T' invalid", ref);
return;
}
&& 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;
}
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
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;
}
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;
}
else
{
- cp_error ("enumerator value for `%D' not integer constant", name);
+ error ("enumerator value for `%D' not integer constant", name);
value = NULL_TREE;
}
}
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;
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. */
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)
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. */
|| 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
{
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;
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);
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);
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");
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;
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;
}
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;
}
/* 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;
}
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))
/* 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))
/* 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;
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. */
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++;
}
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++;
}
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));
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);
}
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;
}
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. */
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;
}
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);
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;
}
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);
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);
}
\f
void
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))
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)
{
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))
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)
{
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));
}
{
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);
}
/* 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)
else
return;
complain:
- cp_error ("`%D' should have been declared inside `%D'",
+ error ("`%D' should have been declared inside `%D'",
decl, scope);
}
}
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;
}
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;
}
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;
}
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;
}
}
}
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
if (!BINDING_VALUE (decls) && !BINDING_TYPE (decls))
{
- cp_error ("`%D' not declared", name);
+ error ("`%D' not declared", name);
return;
}
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;
}
}
*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;
}
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)
{
/* 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);
/* 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)
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))
{
/* 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
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. */
&& 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);
}
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));
}
}
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)
{
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;
}
&& 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;
}
}
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
{
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));
if (! IS_AGGR_TYPE (friend_type))
{
- cp_error ("invalid type `%T' declared `friend'", friend_type);
+ error ("invalid type `%T' declared `friend'", friend_type);
return;
}
Friend declarations shall not declare partial
specializations. */
- cp_error ("partial specialization `%T' declared `friend'",
+ error ("partial specialization `%T' declared `friend'",
friend_type);
return;
}
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;
}
else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
{
/* template <class T> friend typename S<T>::X; */
- cp_error ("typename type `%#T' declared `friend'", friend_type);
+ error ("typename type `%#T' declared `friend'", friend_type);
return;
}
else if (TREE_CODE (friend_type) == TEMPLATE_TYPE_PARM)
{
/* template <class T> friend class T; */
- cp_error ("template parameter type `%T' declared `friend'", friend_type);
+ error ("template parameter type `%T' declared `friend'", friend_type);
return;
}
else if (!CLASSTYPE_TEMPLATE_INFO (friend_type))
{
/* template <class T> friend class A; where A is not a template */
- cp_error ("`%#T' is not a template", friend_type);
+ error ("`%#T' is not a template", friend_type);
return;
}
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
{
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.
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");
{
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)
{
/* 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
{
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;
}
else if (binfo == base_binfo)
{
- cp_error ("base class `%T' already initialized",
+ error ("base class `%T' already initialized",
BINFO_TYPE (binfo));
break;
}
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));
}
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);
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;
}
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;
}
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;
}
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)
&& 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;
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;
}
&& 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;
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;
}
{
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);
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)))
}
else
{
- cp_error ("no method `%T::%D'", type, name);
+ error ("no method `%T::%D'", type, name);
return error_mark_node;
}
}
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;
}
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;
}
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;
}
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;
}
{
if (addr == error_mark_node)
{
- cp_error ("object missing in `%E'", exp);
+ error ("object missing in `%E'", exp);
return error_mark_node;
}
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);
}
}
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. */
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. */
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
{
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)
{
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);
{
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;
}
}
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
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);
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);
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);
}
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. */
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;
}
{ 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
{ 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); }
;
{
if (!processing_template_decl)
{
- cp_error ("use of template qualifier outside template");
+ error ("use of template qualifier outside template");
$$ = error_mark_node;
}
else
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;
parse_end_decl ($<ttype>6, $7, $4);
$$ = convert_from_reference ($<ttype>6);
if (TREE_CODE (TREE_TYPE ($$)) == ARRAY_TYPE)
- cp_error ("definition of array `%#D' in condition", $$);
+ error ("definition of array `%#D' in condition", $$);
}
| expr
;
'(' nonnull_exprlist ')'
{ $$ = $2; }
| '{' nonnull_exprlist '}'
- { cp_pedwarn ("old style placement syntax, use () instead");
+ { pedwarn ("old style placement syntax, use () instead");
$$ = $2; }
;
{ $$ = 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
{ $$.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);
$$.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
&& 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);
}
}
$$.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);
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
{
}
| 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)
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;
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);
}
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;
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
{
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, $$);
}
;
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;
}
;
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))
return decl;
}
else
- cp_error ("invalid member template declaration `%D'", decl);
+ error ("invalid member template declaration `%D'", decl);
return error_mark_node;
}
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]
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 <>. */
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));
}
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
if (TREE_USED (fn)
|| DECL_EXPLICIT_INSTANTIATION (fn))
{
- cp_error ("specialization of %D after instantiation",
+ error ("specialization of %D after instantiation",
fn);
return spec;
}
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;
}
/* This case handles bogus declarations like template <>
template <class T> void f<int>(); */
- cp_error ("template-id `%D' in declaration of primary template",
+ error ("template-id `%D' in declaration of primary template",
declarator);
return decl;
}
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;
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;
}
That used to be legal C++. */
if (pedantic)
- cp_pedwarn
+ pedwarn
("explicit specialization not preceded by `template <>'");
specialization = 1;
SET_DECL_TEMPLATE_SPECIALIZATION (decl);
template <class T> void f<int>(); */
if (uses_template_parms (declarator))
- cp_error ("partial specialization `%D' of function template",
+ error ("partial specialization `%D' of function template",
declarator);
else
- cp_error ("template-id `%D' in declaration of primary template",
+ error ("template-id `%D' in declaration of primary template",
declarator);
return decl;
}
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)
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;
}
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;
}
;
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);
}
}
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)));
}
(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]
&& 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,
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;
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;
{
if (msg)
{
- cp_error (msg, decl);
+ error (msg, decl);
msg = 0;
}
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
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
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
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
if (!TYPE_TEMPLATE_INFO (type))
{
- cp_error ("`%T' is not a template type", type);
+ error ("`%T' is not a template type", type);
return;
}
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));
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;
}
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;
}
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;
}
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;
}
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;
}
}
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;
}
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),
{
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;
{
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;
}
{
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;
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;
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);
}
{
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)
}
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
if (fns == NULL_TREE)
{
- cp_error ("non-template used as template");
+ error ("non-template used as template");
return error_mark_node;
}
if (! template)
{
if (complain)
- cp_error ("`%T' is not a template", d1);
+ error ("`%T' is not a template", d1);
return error_mark_node;
}
{
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);
}
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 ();
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))
{
{
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);
}
-- 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;
}
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;
}
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;
-- 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;
}
|| TREE_CODE (type) == REFERENCE_TYPE)
{
if (complain)
- cp_error ("creating array of `%T'", type);
+ error ("creating array of `%T'", type);
return error_mark_node;
}
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;
}
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;
}
}
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)
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
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;
}
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))
}
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;
}
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);
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;
}
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;
}
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])
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;
}
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;
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))
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);
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;
}
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;
}
&& 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;
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;
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;
}
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;
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;
}
}
if (errstr && protect)
{
- cp_error (errstr, name, type);
+ error (errstr, name, type);
if (lfi.ambiguous)
print_candidates (lfi.ambiguous);
rval = error_mark_node;
{
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);
}
}
}
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;
}
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;
}
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;
}
}
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");
}
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;
}
}
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);
}
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;
}
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;
}
{
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);
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
{
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;
|| 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;
&& 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;
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;
}
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);
}
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
/* 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;
}
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;
}
basetype_path, protect));
case TEMPLATE_DECL:
- cp_error ("invalid use of %D", datum);
+ error ("invalid use of %D", datum);
datum = error_mark_node;
break;
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;
}
{
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);
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
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)
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
{
/* 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
{
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. */
{
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;
}
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;
}
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;
}
|| 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;
}
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;
}
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;
}
|| 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;
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)
{
&& 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));
}
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;
}
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)
{
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;
}
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);
{
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
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);
}
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)
&& ! 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;
}
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;
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;
}
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;
}
{
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);
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))
|| (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);
}
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;
}
}
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;
}
{
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;
}
&& 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;
}
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;
}
}
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;
}
&& 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
&& 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,
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;
}
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;
}
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;
{
/* 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;
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),
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. */
&& 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. */
&& 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);
}
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;
}
&& !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:
{
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;
}
void (*fn) PARAMS ((const char *, ...));
if (soft)
- fn = cp_pedwarn;
+ fn = pedwarn;
else
- fn = cp_error;
+ fn = error;
if (TREE_CODE (arg) == COMPONENT_REF)
{
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)
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;
}
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:
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:
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
}
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);
}
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;
}
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;
}
/* 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. */
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)
}
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;
}
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;
}
}
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;
}
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;
}
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);
git://gcc.gnu.org / gcc.git / commitdiff