resolve the overloading. */
if (TREE_TYPE (converted_operand) == unknown_type_node)
{
- error ("type of asm operand `%E' could not be determined",
- TREE_VALUE (t));
+ error ("type of asm operand %qE could not be determined",
+ TREE_VALUE (t));
converted_operand = error_mark_node;
}
TREE_VALUE (t) = converted_operand;
{
if (current_function_decl
&& DECL_STATIC_FUNCTION_P (current_function_decl))
- cp_error_at ("invalid use of member `%D' in static member function",
+ cp_error_at ("invalid use of member %qD in static member function",
decl);
else
- cp_error_at ("invalid use of non-static data member `%D'", decl);
+ cp_error_at ("invalid use of non-static data member %qD", decl);
error ("from this location");
return error_mark_node;
if (!access_type)
{
- cp_error_at ("object missing in reference to `%D'", decl);
+ cp_error_at ("object missing in reference to %qD", decl);
error ("from this location");
return error_mark_node;
}
if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object),
destructor))
{
- error ("`%E' is not of type `%T'", object, destructor);
+ error ("%qE is not of type %qT", object, destructor);
return error_mark_node;
}
}
that the user is using a template instantiation. */
if (CLASSTYPE_TEMPLATE_INFO (t)
&& CLASSTYPE_TEMPLATE_INSTANTIATION (t))
- error ("invalid use of type `%T' as a default value for a "
+ error ("invalid use of type %qT as a default value for a "
"template template-parameter", t);
else
- error ("invalid use of `%D' as a default value for a template "
+ error ("invalid use of %qD as a default value for a template "
"template-parameter", argument);
}
else
if (processing_template_parmlist)
{
- error ("definition of `%#T' inside template parameter list", t);
+ error ("definition of %q#T inside template parameter list", t);
return error_mark_node;
}
/* A non-implicit typename comes from code like:
This is erroneous. */
else if (TREE_CODE (t) == TYPENAME_TYPE)
{
- error ("invalid definition of qualified type `%T'", t);
+ error ("invalid definition of qualified type %qT", t);
t = error_mark_node;
}
that's an error. */
if (COMPLETE_TYPE_P (t))
{
- error ("redefinition of `%#T'", t);
- cp_error_at ("previous definition of `%#T'", t);
+ error ("redefinition of %q#T", t);
+ cp_error_at ("previous definition of %q#T", t);
return error_mark_node;
}
{
if (cp_type_quals (base) != 0)
{
- error ("base class `%T' has cv qualifiers", base);
+ error ("base class %qT has cv qualifiers", base);
base = TYPE_MAIN_VARIANT (base);
}
result = build_tree_list (access, base);
if (TYPE_P (scope))
{
if (!COMPLETE_TYPE_P (scope))
- error ("incomplete type `%T' used in nested name specifier", scope);
+ error ("incomplete type %qT used in nested name specifier", scope);
else if (TREE_CODE (decl) == TREE_LIST)
{
- error ("reference to `%T::%D' is ambiguous", scope, name);
+ error ("reference to %<%T::%D%> is ambiguous", scope, name);
print_candidates (decl);
}
else
- error ("`%D' is not a member of `%T'", name, scope);
+ error ("%qD is not a member of %qT", name, scope);
}
else if (scope != global_namespace)
- error ("`%D' is not a member of `%D'", name, scope);
+ error ("%qD is not a member of %qD", name, scope);
else
- error ("`::%D' has not been declared", name);
+ error ("%<::%D%> has not been declared", name);
}
/* ID_EXPRESSION is a representation of parsed, but unprocessed,
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (decl)))
{
if (!allow_non_integral_constant_expression_p)
- error ("template parameter `%D' of type `%T' is not allowed in "
+ error ("template parameter %qD of type %qT is not allowed in "
"an integral constant expression because it is not of "
"integral or enumeration type", decl, TREE_TYPE (decl));
*non_integral_constant_expression_p = true;
{
if (!allow_non_integral_constant_expression_p)
{
- error ("`%D' cannot appear in a constant-expression", decl);
+ error ("%qD cannot appear in a constant-expression", decl);
return error_mark_node;
}
*non_integral_constant_expression_p = true;
if (TREE_CODE (decl) == NAMESPACE_DECL)
{
- error ("use of namespace `%D' as expression", decl);
+ error ("use of namespace %qD as expression", decl);
return error_mark_node;
}
else if (DECL_CLASS_TEMPLATE_P (decl))
{
- error ("use of class template `%T' as expression", decl);
+ error ("use of class template %qT as expression", decl);
return error_mark_node;
}
else if (TREE_CODE (decl) == TREE_LIST)
{
/* Ambiguous reference to base members. */
- error ("request for member `%D' is ambiguous in "
+ error ("request for member %qD is ambiguous in "
"multiple inheritance lattice", id_expression);
print_candidates (decl);
return error_mark_node;
{
error ("use of %s from containing function",
(TREE_CODE (decl) == VAR_DECL
- ? "`auto' variable" : "parameter"));
- cp_error_at (" `%#D' declared here", decl);
+ ? "%<auto%> variable" : "parameter"));
+ cp_error_at (" %q#D declared here", decl);
return error_mark_node;
}
}
if (!type || type == unknown_type_node)
{
- error ("type of `%E' is unknown", expr);
+ error ("type of %qE is unknown", expr);
return error_mark_node;
}
result_type = composite_pointer_type_r (pointee1, pointee2, location);
else
{
- pedwarn ("%s between distinct pointer types `%T' and `%T' "
+ pedwarn ("%s between distinct pointer types %qT and %qT "
"lacks a cast",
location, t1, t2);
result_type = void_type_node;
{
if (!same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1),
TYPE_PTRMEM_CLASS_TYPE (t2)))
- pedwarn ("%s between distinct pointer types `%T' and `%T' "
+ pedwarn ("%s between distinct pointer types %qT and %qT "
"lacks a cast",
location, t1, t2);
result_type = build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1),
tree result_type;
if (pedantic && TYPE_PTRFN_P (t2))
- pedwarn ("ISO C++ forbids %s between pointer of type `void *' and pointer-to-function", location);
+ pedwarn ("ISO C++ forbids %s between pointer of type %<void *%> "
+ "and pointer-to-function", location);
result_type
= cp_build_qualified_type (void_type_node,
(cp_type_quals (TREE_TYPE (t1))
(cp_build_qualified_type (class2, TYPE_QUALS (class1))));
else
{
- error ("%s between distinct pointer types `%T' and `%T' "
+ error ("%s between distinct pointer types %qT and %qT "
"lacks a cast", location, t1, t2);
return error_mark_node;
}
t2 = build_ptrmem_type (class1, TYPE_PTRMEM_POINTED_TO_TYPE (t2));
else
{
- error ("%s between distinct pointer-to-member types `%T' and `%T' "
+ error ("%s between distinct pointer-to-member types %qT and %qT "
"lacks a cast", location, t1, t2);
return error_mark_node;
}
if (type_code == METHOD_TYPE)
{
if (complain && (pedantic || warn_pointer_arith))
- pedwarn ("invalid application of `%s' to a member function", op_name);
+ pedwarn ("invalid application of %qs to a member function", op_name);
value = size_one_node;
}
else
&& TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL
&& DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
{
- error ("invalid application of `%s' to a bit-field", op_name);
+ error ("invalid application of %qs to a bit-field", op_name);
e = char_type_node;
}
else if (is_overloaded_fn (e))
{
- pedwarn ("ISO C++ forbids applying `%s' to an expression of function type", op_name);
+ pedwarn ("ISO C++ forbids applying %qs to an expression of "
+ "function type", op_name);
e = char_type_node;
}
else if (type_unknown_p (e))
/* This warning is not very useful, as it complains about printf. */
if (warn && warn_write_strings)
- warning ("deprecated conversion from string constant to `%T'", totype);
+ warning ("deprecated conversion from string constant to %qT'", totype);
return 1;
}
return error_mark_node;
if (!CLASS_TYPE_P (object_type))
{
- error ("request for member `%D' in `%E', which is of non-class type `%T'",
+ error ("request for member %qD in %qE, which is of non-class type %qT",
member, object, object_type);
return error_mark_node;
}
if (!member_scope || !DERIVED_FROM_P (member_scope, object_type))
{
if (TREE_CODE (member) == FIELD_DECL)
- error ("invalid use of nonstatic data member '%E'", member);
+ error ("invalid use of nonstatic data member %qE", member);
else
- error ("`%D' is not a member of `%T'", member, object_type);
+ error ("%qD is not a member of %qT", member, object_type);
return error_mark_node;
}
offsetof macro. */
if (null_object_p && kind == bk_via_virtual)
{
- error ("invalid access to non-static data member `%D' of NULL object",
+ error ("invalid access to non-static data member %qD of "
+ "NULL object",
member);
- error ("(perhaps the `offsetof' macro was used incorrectly)");
+ error ("(perhaps the %<offsetof%> macro was used incorrectly)");
return error_mark_node;
}
&& !DECL_FIELD_IS_BASE (member)
&& !skip_evaluation)
{
- warning ("invalid access to non-static data member `%D' of NULL object",
+ warning ("invalid access to non-static data member %qD of NULL object",
member);
- warning ("(perhaps the `offsetof' macro was used incorrectly)");
+ warning ("(perhaps the %<offsetof%> macro was used incorrectly)");
}
/* If MEMBER is from an anonymous aggregate, we have converted
}
else
{
- error ("invalid use of `%D'", member);
+ error ("invalid use of %qD", member);
return error_mark_node;
}
if (scope && !check_dtor_name (scope, dtor_name))
{
- error ("qualified type `%T' does not match destructor name `~%T'",
+ error ("qualified type %qT does not match destructor name ~%qT",
scope, dtor_type);
return error_mark_node;
}
if (!DERIVED_FROM_P (dtor_type, TYPE_MAIN_VARIANT (object_type)))
{
- error ("the type being destroyed is `%T', but the destructor refers to `%T'",
+ error ("the type being destroyed is %qT, but the destructor refers to %qT",
TYPE_MAIN_VARIANT (object_type), dtor_type);
return error_mark_node;
}
return error_mark_node;
if (!CLASS_TYPE_P (object_type))
{
- error ("request for member `%D' in `%E', which is of non-class type `%T'",
+ error ("request for member %qD in %qE, which is of non-class type %qT",
name, object, object_type);
return error_mark_node;
}
name a member of OBJECT_TYPE. */
if (TREE_CODE (scope) == NAMESPACE_DECL)
{
- error ("`%D::%D' is not a member of `%T'",
+ error ("%<%D::%D%> is not a member of %qT",
scope, name, object_type);
return error_mark_node;
}
return error_mark_node;
if (!access_path)
{
- error ("`%T' is not a base of `%T'", scope, object_type);
+ error ("%qT is not a base of %qT", scope, object_type);
return error_mark_node;
}
}
/*want_type=*/false);
if (member == NULL_TREE)
{
- error ("'%D' has no member named '%E'", object_type, name);
+ error ("%qD has no member named %qE", object_type, name);
return error_mark_node;
}
if (member == error_mark_node)
template = lookup_template_function (template, template_args);
else
{
- error ("`%D' is not a member template function", name);
+ error ("%qD is not a member template function", name);
return error_mark_node;
}
}
{
/* A pointer to incomplete type (other than cv void) can be
dereferenced [expr.unary.op]/1 */
- error ("`%T' is not a pointer-to-object type", type);
+ error ("%qT is not a pointer-to-object type", type);
return error_mark_node;
}
else if (TREE_CODE (pointer) == ADDR_EXPR
/* `pointer' won't be an error_mark_node if we were given a
pointer to member, so it's cool to check for this here. */
else if (TYPE_PTR_TO_MEMBER_P (type))
- error ("invalid use of `%s' on pointer to member", errorstring);
+ error ("invalid use of %qs on pointer to member", errorstring);
else if (pointer != error_mark_node)
{
if (errorstring)
- error ("invalid type argument of `%s'", errorstring);
+ error ("invalid type argument of %qs", errorstring);
else
error ("invalid type argument");
}
must have done so deliberately. */
if (warn_char_subscripts
&& TYPE_MAIN_VARIANT (TREE_TYPE (idx)) == char_type_node)
- warning ("array subscript has type `char'");
+ warning ("array subscript has type %<char%>");
if (!INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (idx)))
{
while (TREE_CODE (foo) == COMPONENT_REF)
foo = TREE_OPERAND (foo, 0);
if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
- warning ("subscripting array declared `register'");
+ warning ("subscripting array declared %<register%>");
}
type = TREE_TYPE (TREE_TYPE (array));
}
else
{
- error ("object missing in use of `%E'", function);
+ error ("object missing in use of %qE", function);
return error_mark_node;
}
}
/* Convert anything with function type to a pointer-to-function. */
if (pedantic && DECL_MAIN_P (function))
- pedwarn ("ISO C++ forbids calling `::main' from within program");
+ pedwarn ("ISO C++ forbids calling %<::main%> from within program");
/* Differs from default_conversion by not setting TREE_ADDRESSABLE
(because calling an inline function does not mean the function
if (TYPE_PTRMEMFUNC_P (fntype))
{
- error ("must use .* or ->* to call pointer-to-member function in `%E (...)'",
- original);
+ error ("must use %<.*%> or %<->*%> to call pointer-to-member "
+ "function in %<%E (...)%>",
+ original);
return error_mark_node;
}
|| is_method
|| TREE_CODE (function) == TEMPLATE_ID_EXPR))
{
- error ("`%E' cannot be used as a function", original);
+ error ("%qE cannot be used as a function", original);
return error_mark_node;
}
{
if (fndecl)
{
- cp_error_at ("too many arguments to %s `%+#D'", called_thing,
+ cp_error_at ("too many arguments to %s %q+#D", called_thing,
fndecl);
error ("at this point in file");
}
if (!COMPLETE_TYPE_P (complete_type (type)))
{
if (fndecl)
- error ("parameter %P of `%D' has incomplete type `%T'",
+ error ("parameter %P of %qD has incomplete type %qT",
i, fndecl, type);
else
- error ("parameter %P has incomplete type `%T'", i, type);
+ error ("parameter %P has incomplete type %qT", i, type);
parmval = error_mark_node;
}
else
{
if (fndecl)
{
- cp_error_at ("too few arguments to %s `%+#D'",
+ cp_error_at ("too few arguments to %s %q+#D",
called_thing, fndecl);
error ("at this point in file");
}
tree t = instantiate_type (TREE_TYPE (op1), op0, tf_none);
if (t != error_mark_node)
{
- pedwarn ("assuming cast to type `%T' from overloaded function",
- TREE_TYPE (t));
+ pedwarn ("assuming cast to type %qT from overloaded function",
+ TREE_TYPE (t));
op0 = t;
}
}
tree t = instantiate_type (TREE_TYPE (op0), op1, tf_none);
if (t != error_mark_node)
{
- pedwarn ("assuming cast to type `%T' from overloaded function",
- TREE_TYPE (t));
+ pedwarn ("assuming cast to type %qT from overloaded function",
+ TREE_TYPE (t));
op1 = t;
}
}
|| code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
{
if (TREE_CODE (op1) == INTEGER_CST && integer_zerop (op1))
- 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))
- warning ("division by zero in `%E / 0.'", op0);
+ warning ("division by zero in %<%E / 0.%>", op0);
if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
code0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
case TRUNC_MOD_EXPR:
case FLOOR_MOD_EXPR:
if (code1 == INTEGER_TYPE && integer_zerop (op1))
- warning ("division by zero in `%E %% 0'", op0);
+ warning ("division by zero in %<%E %% 0%>", op0);
else if (code1 == REAL_TYPE && real_zerop (op1))
- warning ("division by zero in `%E %% 0.'", op0);
+ warning ("division by zero in %<%E %% 0.%>", op0);
if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
{
if (!result_type)
{
- error ("invalid operands of types `%T' and `%T' to binary `%O'",
+ error ("invalid operands of types %qT and %qT to binary %qO",
TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), code);
return error_mark_node;
}
&& TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
!= TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
{
- warning ("comparison between types `%#T' and `%#T'",
- TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
+ warning ("comparison between types %q#T and %q#T",
+ TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
}
/* Give warnings for comparisons between signed and unsigned
if (pedantic || warn_pointer_arith)
{
if (TREE_CODE (target_type) == VOID_TYPE)
- pedwarn ("ISO C++ forbids using pointer of type `void *' in subtraction");
+ pedwarn ("ISO C++ forbids using pointer of type %<void *%> in subtraction");
if (TREE_CODE (target_type) == FUNCTION_TYPE)
pedwarn ("ISO C++ forbids using pointer to a function in subtraction");
if (TREE_CODE (target_type) == METHOD_TYPE)
tree type = complete_type (TREE_TYPE (argtype));
if (!COMPLETE_OR_VOID_TYPE_P (type))
- error ("cannot %s a pointer to incomplete type `%T'",
- ((code == PREINCREMENT_EXPR
- || code == POSTINCREMENT_EXPR)
- ? "increment" : "decrement"), TREE_TYPE (argtype));
+ error ("cannot %s a pointer to incomplete type %qT",
+ ((code == PREINCREMENT_EXPR
+ || code == POSTINCREMENT_EXPR)
+ ? "increment" : "decrement"), TREE_TYPE (argtype));
else if ((pedantic || warn_pointer_arith)
&& !TYPE_PTROB_P (argtype))
- pedwarn ("ISO C++ forbids %sing a pointer of type `%T'",
- ((code == PREINCREMENT_EXPR
- || code == POSTINCREMENT_EXPR)
- ? "increment" : "decrement"), argtype);
+ pedwarn ("ISO C++ forbids %sing a pointer of type %qT",
+ ((code == PREINCREMENT_EXPR
+ || code == POSTINCREMENT_EXPR)
+ ? "increment" : "decrement"), argtype);
inc = cxx_sizeof_nowarn (TREE_TYPE (argtype));
}
else
{
if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR)
{
- error ("invalid use of `--' on bool variable `%D'", arg);
+ error ("invalid use of %<--%> on bool variable %qD", arg);
return error_mark_node;
}
val = boolean_increment (code, arg);
}
else if (pedantic && DECL_MAIN_P (arg))
/* ARM $3.4 */
- pedwarn ("ISO C++ forbids taking address of function `::main'");
+ pedwarn ("ISO C++ forbids taking address of function %<::main%>");
/* Let &* cancel out to simplify resulting code. */
if (TREE_CODE (arg) == INDIRECT_REF)
/* An expression like &memfn. */
pedwarn ("ISO C++ forbids taking the address of an unqualified"
" or parenthesized non-static member function to form"
- " a pointer to member function. Say `&%T::%D'",
+ " a pointer to member function. Say %<&%T::%D%>",
base, name);
else
pedwarn ("ISO C++ forbids taking the address of a bound member"
" function to form a pointer to member function."
- " Say `&%T::%D'",
+ " Say %<&%T::%D%>",
base, name);
}
arg = build_offset_ref (base, name, /*address_p=*/true);
is an error. */
else if (TREE_CODE (argtype) != FUNCTION_TYPE
&& TREE_CODE (argtype) != METHOD_TYPE
- && !lvalue_or_else (arg, "unary `&'"))
+ && !lvalue_or_else (arg, "unary %<&$>"))
return error_mark_node;
if (argtype != error_mark_node)
}
else if (DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
{
- error ("attempt to take address of bit-field structure member `%D'",
+ error ("attempt to take address of bit-field structure member %qD",
TREE_OPERAND (arg, 1));
return error_mark_node;
}
if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
{
- error ("cannot create pointer to reference member `%D'", t);
+ error ("cannot create pointer to reference member %qD", t);
return error_mark_node;
}
case RESULT_DECL:
if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
&& !DECL_ARTIFICIAL (x) && extra_warnings)
- warning ("address requested for `%D', which is declared `register'",
- x);
+ warning ("address requested for %qD, which is declared `register'",
+ x);
TREE_ADDRESSABLE (x) = 1;
return true;
const char *description)
{
if (casts_away_constness (src_type, dest_type))
- error ("%s from type `%T' to type `%T' casts away constness",
+ error ("%s from type %qT to type %qT casts away constness",
description, src_type, dest_type);
}
return build_nop (type, expr);
}
- error ("invalid static_cast from type `%T' to type `%T'", intype, type);
+ error ("invalid static_cast from type %qT to type %qT", intype, type);
return error_mark_node;
}
{
if (! real_lvalue_p (expr))
{
- 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 "
+ "%qT to type %qT", 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))
- pedwarn ("reinterpret_cast from `%T' to `%T' loses precision",
- intype, type);
+ pedwarn ("reinterpret_cast from %qT to %qT loses precision",
+ intype, type);
}
else if ((TYPE_PTRFN_P (type) && TYPE_PTRFN_P (intype))
|| (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
}
else
{
- error ("invalid reinterpret_cast from type `%T' to type `%T'",
- intype, type);
+ error ("invalid reinterpret_cast from type %qT to type %qT",
+ intype, type);
return error_mark_node;
}
}
if (!POINTER_TYPE_P (type) && !TYPE_PTRMEM_P (type))
- 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 %qT, which is not a pointer, "
+ "reference, nor a pointer-to-data-member type", type);
else if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
{
- 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 %qT, which is a pointer "
+ "or reference to a function type", type);
return error_mark_node;
}
{
if (! real_lvalue_p (expr))
{
- error ("invalid const_cast of an rvalue of type `%T' to type `%T'", intype, type);
+ error ("invalid const_cast of an rvalue of type %qT to type %qT",
+ intype, type);
return error_mark_node;
}
&& comp_ptr_ttypes_const (TREE_TYPE (type), TREE_TYPE (intype)))
return cp_convert (type, expr);
- error ("invalid const_cast from type `%T' to type `%T'", intype, type);
+ error ("invalid const_cast from type %qT to type %qT", intype, type);
return error_mark_node;
}
NIHCL uses it. It is not valid ISO C++ however. */
if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
{
- pedwarn ("ISO C++ forbids casting to an array type `%T'", type);
+ pedwarn ("ISO C++ forbids casting to an array type %qT", type);
type = build_pointer_type (TREE_TYPE (type));
}
else
{
- error ("ISO C++ forbids casting to an array type `%T'", type);
+ error ("ISO C++ forbids casting to an array type %qT", type);
return error_mark_node;
}
}
if (TREE_CODE (type) == FUNCTION_TYPE
|| TREE_CODE (type) == METHOD_TYPE)
{
- error ("invalid cast to function type `%T'", type);
+ error ("invalid cast to function type %qT", type);
return error_mark_node;
}
&& TREE_CODE (otype) == POINTER_TYPE
&& !at_least_as_qualified_p (TREE_TYPE (type),
TREE_TYPE (otype)))
- warning ("cast from `%T' to `%T' discards qualifiers from pointer target type",
- otype, type);
+ warning ("cast from %qT to %qT discards qualifiers from pointer "
+ "target type",
+ otype, type);
if (TREE_CODE (type) == INTEGER_TYPE
&& TYPE_PTR_P (otype)
&& COMPLETE_TYPE_P (TREE_TYPE (otype))
&& COMPLETE_TYPE_P (TREE_TYPE (type))
&& TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
- warning ("cast from `%T' to `%T' increases required alignment of target type",
- otype, type);
+ warning ("cast from %qT to %qT increases required alignment of "
+ "target type",
+ otype, type);
/* Always produce some operator for an explicit cast,
so we can tell (for -pedantic) that the cast is no lvalue. */
newrhs = cp_build_binary_op (modifycode, lhs, rhs);
if (newrhs == error_mark_node)
{
- 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 (TYPE_MAIN_VARIANT (lhstype),
TYPE_MAIN_VARIANT (TREE_TYPE (rhs))))
{
- error ("incompatible types in assignment of `%T' to `%T'",
+ error ("incompatible types in assignment of %qT to %qT",
TREE_TYPE (rhs), lhstype);
return error_mark_node;
}
{
/* This is a reinterpret cast, we choose to do nothing. */
if (force)
- warning ("pointer to member cast via virtual base `%T'",
+ warning ("pointer to member cast via virtual base %qT",
BINFO_TYPE (virt_binfo));
else
- error ("pointer to member conversion via virtual base `%T'",
+ error ("pointer to member conversion via virtual base %qT",
BINFO_TYPE (virt_binfo));
}
}
if (!force
&& !can_convert_arg (to_type, TREE_TYPE (pfn), pfn))
- error ("invalid conversion to type `%T' from type `%T'",
- to_type, pfn_type);
+ error ("invalid conversion to type %qT from type %qT",
+ to_type, pfn_type);
n = get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type),
TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type),
if (ARITHMETIC_TYPE_P (type) && expr == null_node)
{
if (fndecl)
- warning ("passing NULL used for non-pointer %s %P of `%D'",
- errtype, parmnum, fndecl);
+ warning ("passing NULL used for non-pointer %s %P of %qD",
+ errtype, parmnum, fndecl);
else
- warning ("%s to non-pointer type `%T' from NULL", errtype, type);
+ warning ("%s to non-pointer type %qT from NULL", errtype, type);
}
/* Warn about assigning a floating-point type to an integer type. */
&& TREE_CODE (type) == INTEGER_TYPE)
{
if (fndecl)
- warning ("passing `%T' for %s %P of `%D'",
- TREE_TYPE (expr), errtype, parmnum, fndecl);
+ warning ("passing %qT for %s %P of %qD",
+ TREE_TYPE (expr), errtype, parmnum, fndecl);
else
- warning ("%s to `%T' from `%T'", errtype, type, TREE_TYPE (expr));
+ warning ("%s to %qT from %qT", errtype, type, TREE_TYPE (expr));
}
/* And warn about assigning a negative value to an unsigned
variable. */
if (TREE_CODE (expr) == INTEGER_CST && TREE_NEGATED_INT (expr))
{
if (fndecl)
- warning ("passing negative value `%E' for %s %P of `%D'",
- expr, errtype, parmnum, fndecl);
+ warning ("passing negative value %qE for %s %P of %qD",
+ expr, errtype, parmnum, fndecl);
else
- warning ("%s of negative value `%E' to `%T'",
- errtype, expr, type);
+ warning ("%s of negative value %qE to %qT", errtype, expr, type);
}
overflow_warning (expr);
if (rhstype == unknown_type_node)
instantiate_type (type, rhs, tf_error | tf_warning);
else if (fndecl)
- error ("cannot convert `%T' to `%T' for argument `%P' to `%D'",
- rhstype, type, parmnum, fndecl);
+ error ("cannot convert %qT to %qT for argument %qP to %qD",
+ rhstype, type, parmnum, fndecl);
else
- error ("cannot convert `%T' to `%T' in %s", rhstype, type,
- errtype);
+ error ("cannot convert %qT to %qT in %s", rhstype, type, errtype);
return error_mark_node;
}
}
if (fndecl)
{
if (warningcount > savew)
- cp_warning_at ("in passing argument %P of `%+D'", parmnum, fndecl);
+ cp_warning_at ("in passing argument %P of %q+D", parmnum, fndecl);
else if (errorcount > savee)
- cp_error_at ("in passing argument %P of `%+D'", parmnum, fndecl);
+ cp_error_at ("in passing argument %P of %q+D", parmnum, fndecl);
}
return rhs;
}
|| TREE_PUBLIC (whats_returned)))
{
if (TREE_CODE (valtype) == REFERENCE_TYPE)
- cp_warning_at ("reference to local variable `%D' returned",
+ cp_warning_at ("reference to local variable %qD returned",
whats_returned);
else
- cp_warning_at ("address of local variable `%D' returned",
+ cp_warning_at ("address of local variable %qD returned",
whats_returned);
return;
}
&& !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl))
&& ! flag_check_new
&& null_ptr_cst_p (retval))
- 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
}
if (warn)
- 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);
- error ("type `%T' is not a base type for type `%T'", basetype, type);
+ error ("type %qT is not a base type for type %qT", basetype, type);
return error_mark_node;
}
if (TREE_CODE (arg) == COMPONENT_REF)
{
if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
- fmt = "%s of data-member `%D' in read-only structure";
+ fmt = "%s of data-member %qD in read-only structure";
else
- fmt = "%s of read-only data-member `%D'";
+ fmt = "%s of read-only data-member %qD";
(*fn) (fmt, string, TREE_OPERAND (arg, 1));
}
else if (TREE_CODE (arg) == VAR_DECL)
if (DECL_LANG_SPECIFIC (arg)
&& DECL_IN_AGGR_P (arg)
&& !TREE_STATIC (arg))
- fmt = "%s of constant field `%D'";
+ fmt = "%s of constant field %qD";
else
- fmt = "%s of read-only variable `%D'";
+ fmt = "%s of read-only variable %qD";
(*fn) (fmt, string, arg);
}
else if (TREE_CODE (arg) == PARM_DECL)
- (*fn) ("%s of read-only parameter `%D'", string, arg);
+ (*fn) ("%s of read-only parameter %qD", string, arg);
else if (TREE_CODE (arg) == INDIRECT_REF
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE
&& (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL
|| TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
- (*fn) ("%s of read-only reference `%D'", string, TREE_OPERAND (arg, 0));
+ (*fn) ("%s of read-only reference %qD", string, TREE_OPERAND (arg, 0));
else if (TREE_CODE (arg) == RESULT_DECL)
- (*fn) ("%s of read-only named return value `%D'", string, arg);
+ (*fn) ("%s of read-only named return value %qD", string, arg);
else if (TREE_CODE (arg) == FUNCTION_DECL)
- (*fn) ("%s of function `%D'", string, arg);
+ (*fn) ("%s of function %qD", string, arg);
else
(*fn) ("%s of read-only location", string);
}
return 0;
if (TREE_CODE (decl) == VAR_DECL)
- cp_error_at ("cannot declare variable `%+D' to be of abstract "
- "type `%T'", decl, type);
+ cp_error_at ("cannot declare variable %q+D to be of abstract "
+ "type %qT", decl, type);
else if (TREE_CODE (decl) == PARM_DECL)
- cp_error_at ("cannot declare parameter `%+D' to be of abstract "
- "type `%T'", decl, type);
+ cp_error_at ("cannot declare parameter %q+D to be of abstract "
+ "type %qT", decl, type);
else if (TREE_CODE (decl) == FIELD_DECL)
- cp_error_at ("cannot declare field `%+D' to be of abstract "
- "type `%T'", decl, type);
+ cp_error_at ("cannot declare field %q+D to be of abstract "
+ "type %qT", decl, type);
else if (TREE_CODE (decl) == FUNCTION_DECL
&& TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
- cp_error_at ("invalid abstract return type for member function `%+#D'",
+ cp_error_at ("invalid abstract return type for member function %q+#D",
decl);
else if (TREE_CODE (decl) == FUNCTION_DECL)
- cp_error_at ("invalid abstract return type for function `%+#D'",
+ cp_error_at ("invalid abstract return type for function %q+#D",
decl);
else if (TREE_CODE (decl) == IDENTIFIER_NODE)
/* Here we do not have location information, so use error instead
of cp_error_at. */
- error ("invalid abstract type `%T' for `%E'", type, decl);
+ error ("invalid abstract type %qT for %qE", type, decl);
else
- cp_error_at ("invalid abstract type for `%+D'", decl);
+ cp_error_at ("invalid abstract type for %q+D", decl);
}
else
- error ("cannot allocate an object of abstract type `%T'", type);
+ error ("cannot allocate an object of abstract type %qT", type);
/* Only go through this once. */
if (VEC_length (tree, pure))
tree fn;
inform ("%J because the following virtual functions are pure "
- "within `%T':", TYPE_MAIN_DECL (type), type);
+ "within %qT:", TYPE_MAIN_DECL (type), type);
for (ix = 0; VEC_iterate (tree, pure, ix, fn); ix++)
inform ("%J\t%#D", fn, fn);
VEC_truncate (tree, pure, 0);
}
else
- inform ("%J since type `%T' has pure virtual functions",
+ inform ("%J since type %qT has pure virtual functions",
TYPE_MAIN_DECL (type), type);
return 1;
|| TREE_CODE (value) == PARM_DECL
|| TREE_CODE (value) == FIELD_DECL))
{
- (*p_msg_at) ("`%D' has incomplete type", value);
+ (*p_msg_at) ("%qD has incomplete type", value);
decl = 1;
}
retry:
case UNION_TYPE:
case ENUMERAL_TYPE:
if (!decl)
- (*p_msg) ("invalid use of undefined type `%#T'", type);
+ (*p_msg) ("invalid use of undefined type %q#T", type);
if (!TYPE_TEMPLATE_INFO (type))
- (*p_msg_at) ("forward declaration of `%#T'", type);
+ (*p_msg_at) ("forward declaration of %q#T", type);
else
- (*p_msg_at) ("declaration of `%#T'", type);
+ (*p_msg_at) ("declaration of %q#T", type);
break;
case VOID_TYPE:
- (*p_msg) ("invalid use of `%T'", type);
+ (*p_msg) ("invalid use of %qT", type);
break;
case ARRAY_TYPE:
case OFFSET_TYPE:
bad_member:
- (*p_msg) ("invalid use of member (did you forget the `&' ?)");
+ (*p_msg) ("invalid use of member (did you forget the %<&%> ?)");
break;
case TEMPLATE_TYPE_PARM:
if (value && TREE_CODE (value) == COMPONENT_REF)
goto bad_member;
else if (value && TREE_CODE (value) == ADDR_EXPR)
- (*p_msg) ("address of overloaded function with no contextual type information");
+ (*p_msg) ("address of overloaded function with no contextual "
+ "type information");
else if (value && TREE_CODE (value) == OVERLOAD)
(*p_msg) ("overloaded function with no contextual type information");
else
if (TREE_CODE (init) == TREE_LIST)
{
- error ("constructor syntax used, but no constructor declared for type `%T'", type);
+ error ("constructor syntax used, but no constructor declared "
+ "for type %qT", type);
init = build_constructor (NULL_TREE, nreverse (init));
}
}
}
while (BRACE_ENCLOSED_INITIALIZER_P (init))
{
- pedwarn ("braces around scalar initializer for `%T'", type);
+ pedwarn ("braces around scalar initializer for %qT", type);
init = CONSTRUCTOR_ELTS (init);
if (TREE_CHAIN (init))
- pedwarn ("ignoring extra initializers for `%T'", type);
+ pedwarn ("ignoring extra initializers for %qT", type);
init = TREE_VALUE (init);
}
if (COMPLETE_TYPE_P (type) && ! TREE_CONSTANT (TYPE_SIZE (type)))
{
- error ("variable-sized object of type `%T' may not be initialized",
+ error ("variable-sized object of type %qT may not be initialized",
type);
return error_mark_node;
}
{
if (TYPE_NON_AGGREGATE_CLASS (type))
{
- error ("subobject of type `%T' must be initialized by constructor, not by `%E'",
+ error ("subobject of type %qT must be initialized by "
+ "constructor, not by %qE",
type, init);
return error_mark_node;
}
/* Warn when some struct elements are implicitly initialized. */
if (warn_missing_field_initializers
&& (!init || BRACE_ENCLOSED_INITIALIZER_P (init)))
- warning ("missing initializer for member `%D'", field);
+ warning ("missing initializer for member %qD", field);
}
else
{
if (TREE_READONLY (field))
- error ("uninitialized const member `%D'", field);
+ error ("uninitialized const member %qD", field);
else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
- error ("member `%D' with uninitialized const fields",
- field);
+ error ("member %qD with uninitialized const fields", field);
else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
- error ("member `%D' is uninitialized reference", field);
+ error ("member %qD is uninitialized reference", field);
/* Warn when some struct elements are implicitly initialized
to zero. */
if (warn_missing_field_initializers
&& (!init || BRACE_ENCLOSED_INITIALIZER_P (init)))
- warning ("missing initializer for member `%D'", field);
+ warning ("missing initializer for member %qD", field);
if (! zero_init_p (TREE_TYPE (field)))
next1 = build_zero_init (TREE_TYPE (field),
if (temp)
field = temp, win = 1;
else
- error ("no field `%D' in union being initialized",
- TREE_PURPOSE (tail));
+ error ("no field %qD in union being initialized",
+ TREE_PURPOSE (tail));
}
if (!win)
TREE_VALUE (tail) = error_mark_node;
}
else if (field == 0)
{
- error ("union `%T' with no named members cannot be initialized",
- type);
+ error ("union %qT with no named members cannot be initialized",
+ type);
TREE_VALUE (tail) = error_mark_node;
}
if (last_rval == NULL_TREE)
{
- error ("base operand of `->' has non-pointer type `%T'", type);
+ error ("base operand of %<->%> has non-pointer type %qT", type);
return error_mark_node;
}
}
if (types_memoized)
- error ("result of `operator->()' yields non-pointer result");
+ error ("result of %<operator->()%> yields non-pointer result");
else
- error ("base operand of `->' is not a pointer");
+ error ("base operand of %<->%> is not a pointer");
return error_mark_node;
}
ptrmem_type = TREE_TYPE (component);
if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
{
- error ("`%E' cannot be used as a member pointer, since it is of type `%T'",
+ error ("%qE cannot be used as a member pointer, since it is of "
+ "type %qT",
component, ptrmem_type);
return error_mark_node;
}
objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
if (! IS_AGGR_TYPE (objtype))
{
- error ("cannot apply member pointer `%E' to `%E', which is of non-aggregate type `%T'",
- component, datum, objtype);
+ error ("cannot apply member pointer %qE to %qE, which is of "
+ "non-aggregate type %qT",
+ component, datum, objtype);
return error_mark_node;
}
if (!binfo)
{
mismatch:
- error ("pointer to member type `%T' incompatible with object type `%T'",
+ error ("pointer to member type %qT incompatible with object "
+ "type %qT",
type, objtype);
return error_mark_node;
}
{
if (decl)
error
- ("call to function `%D' which throws incomplete type `%#T'",
+ ("call to function %qD which throws incomplete type %q#T",
decl, type);
else
- error ("call to function which throws incomplete type `%#T'",
+ error ("call to function which throws incomplete type %q#T",
decl);
}
}
projects / gcc.git / commitdiff