{
if (flags & LOOKUP_COMPLAIN)
{
- error ("conversion from `%T' to `%T' is ambiguous",
+ error ("conversion from %qT to %qT is ambiguous",
fromtype, totype);
print_z_candidates (candidates);
}
if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
fn = TREE_OPERAND (fn, 0);
if (!any_viable_p)
- error ("no matching function for call to `%D(%A)'",
+ error ("no matching function for call to %<%D(%A)%>",
DECL_NAME (OVL_CURRENT (fn)), args);
else
- error ("call of overloaded `%D(%A)' is ambiguous",
+ error ("call of overloaded %<%D(%A)%> is ambiguous",
DECL_NAME (OVL_CURRENT (fn)), args);
if (candidates)
print_z_candidates (candidates);
if (!cand)
{
if (!any_viable_p)
- error ("no matching function for call to `%D(%A)'",
+ error ("no matching function for call to %<%D(%A)%>",
DECL_NAME (OVL_CURRENT (fns)), args);
else
- error ("call of overloaded `%D(%A)' is ambiguous",
+ error ("call of overloaded %<%D(%A)%> is ambiguous",
DECL_NAME (OVL_CURRENT (fns)), args);
if (candidates)
print_z_candidates (candidates);
candidates = splice_viable (candidates, pedantic, &any_viable_p);
if (!any_viable_p)
{
- 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);
result = error_mark_node;
}
cand = tourney (candidates);
if (cand == 0)
{
- 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);
result = error_mark_node;
}
switch (code)
{
case COND_EXPR:
- error ("%s for ternary 'operator?:' in '%E ? %E : %E'",
+ error ("%s for ternary %<operator?:%> in %<%E ? %E : %E%>",
problem, arg1, arg2, arg3);
break;
case POSTINCREMENT_EXPR:
case POSTDECREMENT_EXPR:
- error ("%s for 'operator%s' in '%E%s'", problem, opname, arg1, opname);
+ error ("%s for %<operator%s%> in %<%E%s%>", problem, opname, arg1, opname);
break;
case ARRAY_REF:
- error ("%s for 'operator[]' in '%E[%E]'", problem, arg1, arg2);
+ error ("%s for %<operator[]%> in %<%E[%E]%>", problem, arg1, arg2);
break;
case REALPART_EXPR:
case IMAGPART_EXPR:
- error ("%s for '%s' in '%s %E'", problem, opname, opname, arg1);
+ error ("%s for %qs in %<%s %E%>", problem, opname, opname, arg1);
break;
default:
if (arg2)
- error ("%s for 'operator%s' in '%E %s %E'",
+ error ("%s for %<operator%s%> in %<%E %s %E%>",
problem, opname, arg1, opname, arg2);
else
- error ("%s for 'operator%s' in '%s%E'",
+ error ("%s for %<operator%s%> in %<%s%E%>",
problem, opname, opname, arg1);
break;
}
result_type = void_type_node;
else
{
- error ("`%E' has type `void' and is not a throw-expression",
+ error ("%qE has type %<void%> and is not a throw-expression",
VOID_TYPE_P (arg2_type) ? arg2 : arg3);
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)
- pedwarn ("no `%D(int)' declared for postfix `%s', trying prefix operator instead",
- fnname,
- operator_name_info[code].name);
+ pedwarn ("no %<%D(int)%> declared for postfix %qs, "
+ "trying prefix operator instead",
+ fnname,
+ operator_name_info[code].name);
if (code == POSTINCREMENT_EXPR)
code = PREINCREMENT_EXPR;
else
&& candidates->next
&& ! candidates->next->next)
{
- warning ("using synthesized `%#D' for copy assignment",
+ warning ("using synthesized %q#D for copy assignment",
cand->fn);
- cp_warning_at (" where cfront would use `%#D'",
+ cp_warning_at (" where cfront would use %q#D",
cand == candidates
? candidates->next->fn
: candidates->fn);
&& (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
!= TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
{
- warning ("comparison between `%#T' and `%#T'",
- TREE_TYPE (arg1), TREE_TYPE (arg2));
+ warning ("comparison between %q#T and %q#T",
+ TREE_TYPE (arg1), TREE_TYPE (arg2));
}
break;
default:
if (placement)
return NULL_TREE;
- error ("no suitable `operator %s' for `%T'",
+ error ("no suitable %<operator %s> for %qT",
operator_name_info[(int)code].name, type);
return error_mark_node;
}
if (!accessible_p (basetype_path, decl))
{
if (TREE_PRIVATE (decl))
- cp_error_at ("`%+#D' is private", decl);
+ cp_error_at ("%q+#D is private", decl);
else if (TREE_PROTECTED (decl))
- cp_error_at ("`%+#D' is protected", decl);
+ cp_error_at ("%q+#D is protected", decl);
else
- cp_error_at ("`%+#D' is inaccessible", decl);
+ cp_error_at ("%q+#D is inaccessible", decl);
error ("within this context");
return false;
}
else if (t->kind == ck_identity)
break;
}
- pedwarn ("invalid conversion from `%T' to `%T'", TREE_TYPE (expr), totype);
+ pedwarn ("invalid conversion from %qT to %qT", TREE_TYPE (expr), totype);
if (fn)
- pedwarn (" initializing argument %P of `%D'", argnum, fn);
+ pedwarn (" initializing argument %P of %qD", argnum, fn);
return cp_convert (totype, expr);
}
{
if (fn)
diagnostic_fn
- (" initializing argument %P of `%D' from result of `%D'",
+ (" initializing argument %P of %qD from result of %qD",
argnum, fn, convfn);
else
diagnostic_fn
- (" initializing temporary from result of `%D'", convfn);
+ (" initializing temporary from result of %qD", convfn);
}
expr = build_cplus_new (totype, expr);
}
expr = build_temp (expr, totype, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
&diagnostic_fn);
if (diagnostic_fn && fn)
- diagnostic_fn (" initializing argument %P of `%D'", argnum, fn);
+ diagnostic_fn (" initializing argument %P of %qD", argnum, fn);
return build_cplus_new (totype, expr);
case ck_ref_bind:
cp_lvalue_kind lvalue = real_lvalue_p (expr);
if (lvalue & clk_bitfield)
- error ("cannot bind bitfield `%E' to `%T'",
+ error ("cannot bind bitfield %qE to %qT",
expr, ref_type);
else if (lvalue & clk_packed)
- error ("cannot bind packed field `%E' to `%T'",
+ error ("cannot bind packed field %qE to %qT",
expr, ref_type);
else
- error ("cannot bind rvalue `%E' to `%T'", expr, ref_type);
+ error ("cannot bind rvalue %qE to %qT", expr, ref_type);
return error_mark_node;
}
expr = build_target_expr_with_type (expr, type);
there is no need to emit a warning, since the expression won't be
evaluated. We keep the builtin_trap just as a safety check. */
if (!skip_evaluation)
- warning ("cannot pass objects of non-POD type `%#T' through `...'; "
+ warning ("cannot pass objects of non-POD type %q#T through %<...%>; "
"call will abort at runtime", TREE_TYPE (arg));
arg = call_builtin_trap ();
arg = build2 (COMPOUND_EXPR, integer_type_node, arg,
if (! pod_type_p (type))
{
/* Undefined behavior [expr.call] 5.2.2/7. */
- warning ("cannot receive objects of non-POD type `%#T' through `...'; \
-call will abort at runtime",
- type);
+ warning ("cannot receive objects of non-POD type %q#T' through %<...%>; "
+ "call will abort at runtime", type);
expr = convert (build_pointer_type (type), null_node);
expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr),
call_builtin_trap (), expr);
conversion cannot be performed. */
if (TREE_CODE (arg) == DEFAULT_ARG)
{
- error ("the default argument for parameter %d of `%D' has "
+ error ("the default argument for parameter %d of %qD has "
"not yet been parsed",
parmnum, fn);
return error_mark_node;
/* Check that the base class is accessible. */
if (!accessible_base_p (TREE_TYPE (argtype),
BINFO_TYPE (cand->conversion_path)))
- error ("`%T' is not an accessible base of `%T'",
+ error ("%qT is not an accessible base of %qT",
BINFO_TYPE (cand->conversion_path),
TREE_TYPE (argtype));
/* If fn was found by a using declaration, the conversion path
if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
|| DECL_CONTEXT (iface_ref) != iface)
{
- error ("could not find class$ field in java interface type `%T'",
+ error ("could not find class$ field in java interface type %qT",
iface);
return error_mark_node;
}
if (!BASELINK_P (fns))
{
- error ("call to non-function `%D'", fns);
+ error ("call to non-function %qD", fns);
return error_mark_node;
}
if (! IS_AGGR_TYPE (basetype))
{
if ((flags & LOOKUP_COMPLAIN) && basetype != error_mark_node)
- error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
+ error ("request for member %qD in %qE, which is of non-aggregate "
+ "type %qT",
fns, instance, basetype);
return error_mark_node;
bool free_p;
pretty_name = name_as_c_string (name, basetype, &free_p);
- error ("no matching function for call to `%T::%s(%A)%#V'",
+ error ("no matching function for call to %<%T::%s(%A)%#V%>",
basetype, pretty_name, user_args,
TREE_TYPE (TREE_TYPE (instance_ptr)));
if (free_p)
bool free_p;
pretty_name = name_as_c_string (name, basetype, &free_p);
- error ("call of overloaded `%s(%A)' is ambiguous", pretty_name,
+ error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
user_args);
print_z_candidates (candidates);
if (free_p)
/* This is not an error, it is runtime undefined
behavior. */
warning ((DECL_CONSTRUCTOR_P (current_function_decl) ?
- "abstract virtual `%#D' called from constructor"
- : "abstract virtual `%#D' called from destructor"),
+ "abstract virtual %q#D called from constructor"
+ : "abstract virtual %q#D called from destructor"),
cand->fn);
if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE
&& is_dummy_object (instance_ptr))
{
- error ("cannot call member function `%D' without object",
+ error ("cannot call member function %qD without object",
cand->fn);
call = error_mark_node;
}
if (warn)
{
- warning ("passing `%T' chooses `%T' over `%T'",
+ warning ("passing %qT chooses %qT over %qT",
type, type1, type2);
- warning (" in call to `%D'", w->fn);
+ warning (" in call to %qD", w->fn);
}
else
add_warning (w, l);
tree source = source_type (w->convs[0]);
if (! DECL_CONSTRUCTOR_P (w->fn))
source = TREE_TYPE (source);
- warning ("choosing `%D' over `%D'", w->fn, l->fn);
- warning (" for conversion from `%T' to `%T'",
+ warning ("choosing %qD over %qD", w->fn, l->fn);
+ warning (" for conversion from %qT to %qT",
source, w->second_conv->type);
warning (" because conversion sequence for the argument is better");
}
LOOKUP_NORMAL);
if (!conv)
{
- error ("could not convert `%E' to `%T'", expr, type);
+ error ("could not convert %qE to %qT", expr, type);
expr = error_mark_node;
}
else
if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
&& !real_lvalue_p (expr))
error ("invalid initialization of non-const reference of "
- "type '%T' from a temporary of type '%T'",
+ "type %qT from a temporary of type %qT",
type, TREE_TYPE (expr));
else
error ("invalid initialization of reference of type "
- "'%T' from expression of type '%T'", type,
+ "%qT from expression of type %qT", type,
TREE_TYPE (expr));
return error_mark_node;
}
projects / platform / upstream / linaro-gcc.git / commitdiff