mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-04-09 23:21:31 +08:00
Code Issues Packages Projects Releases Wiki Activity

Convert diagnostics to use quoting flag q 7/n

Browse Source 
cp/
        Convert diagnostics to use quoting flag q 7/n
        * typeck.c (composite_pointer_type_r, composite_pointer_type,
        cxx_sizeof_or_alignof_type, cxx_sizeof_or_alignof_expr,
        string_conv_p, build_class_member_access_expr,
        build_class_member_access_expr, lookup_destructor,
        finish_class_member_access_expr, build_indirect_ref,
        get_member_function_from_ptrfunc, build_function_call,
        convert_arguments, build_binary_op, pointer_diff,
        build_unary_op,
        check_for_casting_away_constness, build_static_cast,
        build_reinterpret_cast, build_const_cast, build_c_cast,
        build_modify_expr, get_delta_difference, build_ptrmemfunc,
        dubious_conversion_warnings, convert_for_assignment,
        convert_for_initialization,
        maybe_warn_about_returning_address_of_local,
        check_return_expr):
        Use quoting marks.

        * typeck2.c (error_not_base_type, readonly_error,
        abstract_virtuals_error, cxx_incomplete_type_diagnostic,
        store_init_value, digest_init, build_x_arrow,
        build_m_component_ref, require_complete_eh_spec_types):
        Likewise.

        * tree.c (cp_build_qualified_type_real,
        handle_java_interface_attribute,
        handle_init_priority_attribute):
        Likewise.

        * semantics.c (finish_asm_stmt, finish_non_static_data_member,
        finish_pseudo_destructor_expr,
        check_template_template_default_arg, begin_class_definition,
        finish_base_specifier, qualified_name_lookup_error,
        finish_id_expression, finish_typeof): Likewise.

        * search.c (lookup_base, check_final_overrider,
        look_for_overrides_r): Likewise.

        * rtti.c (get_tinfo_decl, build_dynamic_cast_1): Likewise.
testsuite/
        * g++.dg/overload/pmf1.C: Adjust quoting marks.
        * g++.dg/warn/incomplete1.C: Likewise.
        * g++.dg/template/qualttp20.C: Likewise.

From-SVN: r88854
This commit is contained in:
Gabriel Dos Reis 2004-10-10 21:36:42 +00:00 committed by Gabriel Dos Reis
parent bba5733fee
commit a82e1a7d18
11 changed files with 277 additions and 219 deletions

38
gcc/cp/ChangeLog

@ -1,3 +1,41 @@
2004-10-10 Gabriel Dos Reis <gdr@integrable-solutions.net>
Convert diagnostics to use quoting flag q 7/n
* typeck.c (composite_pointer_type_r, composite_pointer_type,
cxx_sizeof_or_alignof_type, cxx_sizeof_or_alignof_expr,
string_conv_p, build_class_member_access_expr,
build_class_member_access_expr, lookup_destructor,
finish_class_member_access_expr, build_indirect_ref,
get_member_function_from_ptrfunc, build_function_call,
convert_arguments, build_binary_op, pointer_diff, build_unary_op,
check_for_casting_away_constness, build_static_cast,
build_reinterpret_cast, build_const_cast, build_c_cast,
build_modify_expr, get_delta_difference, build_ptrmemfunc,
dubious_conversion_warnings, convert_for_assignment,
convert_for_initialization,
maybe_warn_about_returning_address_of_local, check_return_expr):
Use quoting marks.
* typeck2.c (error_not_base_type, readonly_error,
abstract_virtuals_error, cxx_incomplete_type_diagnostic,
store_init_value, digest_init, build_x_arrow,
build_m_component_ref, require_complete_eh_spec_types): Likewise.
* tree.c (cp_build_qualified_type_real,
handle_java_interface_attribute, handle_init_priority_attribute):
Likewise.
* semantics.c (finish_asm_stmt, finish_non_static_data_member,
finish_pseudo_destructor_expr,
check_template_template_default_arg, begin_class_definition,
finish_base_specifier, qualified_name_lookup_error,
finish_id_expression, finish_typeof): Likewise.
* search.c (lookup_base, check_final_overrider,
look_for_overrides_r): Likewise.
* rtti.c (get_tinfo_decl, build_dynamic_cast_1): Likewise.
2004-10-09 Mark Mitchell <mark@codesourcery.com>
PR c++/17867

15
gcc/cp/rtti.c

@ -318,7 +318,8 @@ get_tinfo_decl (tree type)
if (COMPLETE_TYPE_P (type)
&& TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
{
error ("cannot create type information for type `%T' because its size is variable",
error ("cannot create type information for type %qT because "
"its size is variable",
type);
return error_mark_node;
}
@ -570,8 +571,8 @@ build_dynamic_cast_1 (tree type, tree expr)
&& TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE)
{
tree expr = throw_bad_cast ();
warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
old_expr, type);
warning ("dynamic_cast of %q#D to %q#T can never succeed",
old_expr, type);
/* Bash it to the expected type. */
TREE_TYPE (expr) = type;
return expr;
@ -584,8 +585,8 @@ build_dynamic_cast_1 (tree type, tree expr)
if (TREE_CODE (op) == VAR_DECL
&& TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
{
warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
op, type);
warning ("dynamic_cast of %q#D to %q#T can never succeed",
op, type);
retval = build_int_cst (type, 0);
return retval;
}
@ -663,8 +664,8 @@ build_dynamic_cast_1 (tree type, tree expr)
errstr = "source type is not polymorphic";
fail:
error ("cannot dynamic_cast `%E' (of type `%#T') to type `%#T' (%s)",
expr, exprtype, type, errstr);
error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
expr, exprtype, type, errstr);
return error_mark_node;
}

20
gcc/cp/search.c

@ -234,7 +234,7 @@ lookup_base (tree t, tree base, base_access access, base_kind *kind_ptr)
binfo = NULL_TREE;
if (!(access & ba_quiet))
{
error ("`%T' is an ambiguous base of `%T'", base, t);
error ("%qT is an ambiguous base of %qT", base, t);
binfo = error_mark_node;
}
break;
@ -252,7 +252,7 @@ lookup_base (tree t, tree base, base_access access, base_kind *kind_ptr)
{
if (!(access & ba_quiet))
{
error ("`%T' is an inaccessible base of `%T'", base, t);
error ("%qT is an inaccessible base of %qT", base, t);
binfo = error_mark_node;
}
else
@ -1740,14 +1740,14 @@ check_final_overrider (tree overrider, tree basefn)
{
if (fail == 1)
{
cp_error_at ("invalid covariant return type for `%#D'", overrider);
cp_error_at (" overriding `%#D'", basefn);
cp_error_at ("invalid covariant return type for %q#D", overrider);
cp_error_at (" overriding %q#D", basefn);
}
else
{
cp_error_at ("conflicting return type specified for `%#D'",
cp_error_at ("conflicting return type specified for %q#D",
overrider);
cp_error_at (" overriding `%#D'", basefn);
cp_error_at (" overriding %q#D", basefn);
}
DECL_INVALID_OVERRIDER_P (overrider) = 1;
return 0;
@ -1756,8 +1756,8 @@ check_final_overrider (tree overrider, tree basefn)
/* Check throw specifier is at least as strict. */
if (!comp_except_specs (base_throw, over_throw, 0))
{
cp_error_at ("looser throw specifier for `%#F'", overrider);
cp_error_at (" overriding `%#F'", basefn);
cp_error_at ("looser throw specifier for %q#F", overrider);
cp_error_at (" overriding %q#F", basefn);
DECL_INVALID_OVERRIDER_P (overrider) = 1;
return 0;
}
@ -1850,8 +1850,8 @@ look_for_overrides_r (tree type, tree fndecl)
{
/* A static member function cannot match an inherited
virtual member function. */
cp_error_at ("`%#D' cannot be declared", fndecl);
cp_error_at (" since `%#D' declared in base class", fn);
cp_error_at ("%q#D cannot be declared", fndecl);
cp_error_at (" since %q#D declared in base class", fn);
}
else
{

52
gcc/cp/semantics.c

@ -1130,8 +1130,8 @@ finish_asm_stmt (int volatile_p, tree string, tree output_operands,
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;
@ -1263,10 +1263,10 @@ finish_non_static_data_member (tree decl, tree object, tree qualifying_scope)
{
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;
@ -1305,7 +1305,7 @@ finish_non_static_data_member (tree decl, tree object, tree qualifying_scope)
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;
}
@ -1886,7 +1886,7 @@ finish_pseudo_destructor_expr (tree object, tree scope, tree destructor)
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;
}
}
@ -2024,10 +2024,10 @@ check_template_template_default_arg (tree argument)
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
@ -2048,7 +2048,7 @@ begin_class_definition (tree t)
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:
@ -2059,7 +2059,7 @@ begin_class_definition (tree t)
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;
}
@ -2073,8 +2073,8 @@ begin_class_definition (tree t)
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;
}
@ -2259,7 +2259,7 @@ finish_base_specifier (tree base, tree access, bool virtual_p)
{
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);
@ -2304,19 +2304,19 @@ qualified_name_lookup_error (tree scope, tree name, tree decl)
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,
@ -2439,7 +2439,7 @@ finish_id_expression (tree id_expression,
&& !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;
@ -2583,7 +2583,7 @@ finish_id_expression (tree id_expression,
{
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;
@ -2591,18 +2591,18 @@ finish_id_expression (tree id_expression,
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;
@ -2665,8 +2665,8 @@ finish_id_expression (tree id_expression,
{
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;
}
}
@ -2717,7 +2717,7 @@ finish_typeof (tree expr)
if (!type || type == unknown_type_node)
{
error ("type of `%E' is unknown", expr);
error ("type of %qE is unknown", expr);
return error_mark_node;
}

13
gcc/cp/tree.c

@ -536,7 +536,7 @@ cp_build_qualified_type_real (tree type,
tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
if (!(complain & tf_ignore_bad_quals))
error ("`%V' qualifiers cannot be applied to `%T'",
error ("%qV qualifiers cannot be applied to %qT",
bad_type, type);
}
}
@ -1771,7 +1771,7 @@ handle_java_interface_attribute (tree* node,
|| !CLASS_TYPE_P (*node)
|| !TYPE_FOR_JAVA (*node))
{
error ("`%E' attribute can only be applied to Java class definitions",
error ("%qE attribute can only be applied to Java class definitions",
name);
*no_add_attrs = true;
return NULL_TREE;
@ -1800,13 +1800,12 @@ handle_com_interface_attribute (tree* node,
|| !CLASS_TYPE_P (*node)
|| *node != TYPE_MAIN_VARIANT (*node))
{
warning ("`%E' attribute can only be applied to class definitions",
name);
warning ("%qE attribute can only be applied to class definitions", name);
return NULL_TREE;
}
if (!warned++)
warning ("`%E' is obsolete; g++ vtables are now COM-compatible by default",
warning ("%qE is obsolete; g++ vtables are now COM-compatible by default",
name);
return NULL_TREE;
@ -1851,7 +1850,7 @@ handle_init_priority_attribute (tree* node,
init_priority value, so don't allow it. */
|| current_function_decl)
{
error ("can only use `%E' attribute on file-scope definitions "
error ("can only use %qE attribute on file-scope definitions "
"of objects of class type", name);
*no_add_attrs = true;
return NULL_TREE;
@ -1879,7 +1878,7 @@ handle_init_priority_attribute (tree* node,
}
else
{
error ("`%E' attribute is not supported on this platform", name);
error ("%qE attribute is not supported on this platform", name);
*no_add_attrs = true;
return NULL_TREE;
}

231
gcc/cp/typeck.c

@ -431,7 +431,7 @@ composite_pointer_type_r (tree t1, tree t2, const char* location)
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;
@ -445,7 +445,7 @@ composite_pointer_type_r (tree t1, tree t2, const char* location)
{
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),
@ -507,7 +507,8 @@ composite_pointer_type (tree t1, tree t2, tree arg1, tree arg2,
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))
@ -537,7 +538,7 @@ composite_pointer_type (tree t1, tree t2, tree arg1, tree arg2,
(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;
}
@ -557,7 +558,7 @@ composite_pointer_type (tree t1, tree t2, tree arg1, tree arg2,
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;
}
@ -1244,7 +1245,7 @@ cxx_sizeof_or_alignof_type (tree type, enum tree_code op, bool complain)
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
@ -1277,12 +1278,13 @@ cxx_sizeof_or_alignof_expr (tree e, enum tree_code op)
&& 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))
@ -1503,7 +1505,7 @@ string_conv_p (tree totype, tree exp, int warn)
/* 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;
}
@ -1617,7 +1619,7 @@ build_class_member_access_expr (tree object, tree member,
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;
}
@ -1644,9 +1646,9 @@ build_class_member_access_expr (tree object, tree member,
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;
}
@ -1696,9 +1698,10 @@ build_class_member_access_expr (tree object, tree member,
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;
}
@ -1723,9 +1726,9 @@ build_class_member_access_expr (tree object, tree member,
&& !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
@ -1810,7 +1813,7 @@ build_class_member_access_expr (tree object, tree member,
}
else
{
error ("invalid use of `%D'", member);
error ("invalid use of %qD", member);
return error_mark_node;
}
@ -1836,13 +1839,13 @@ lookup_destructor (tree object, tree scope, tree dtor_name)
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;
}
@ -1915,7 +1918,7 @@ finish_class_member_access_expr (tree object, tree name)
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;
}
@ -1961,7 +1964,7 @@ finish_class_member_access_expr (tree object, tree name)
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;
}
@ -1972,7 +1975,7 @@ finish_class_member_access_expr (tree object, tree name)
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;
}
}
@ -1991,7 +1994,7 @@ finish_class_member_access_expr (tree object, tree name)
/*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)
@ -2006,7 +2009,7 @@ finish_class_member_access_expr (tree object, tree name)
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;
}
}
@ -2113,7 +2116,7 @@ build_indirect_ref (tree ptr, const char *errorstring)
{
/* 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
@ -2138,11 +2141,11 @@ build_indirect_ref (tree ptr, const char *errorstring)
/* `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");
}
@ -2208,7 +2211,7 @@ build_array_ref (tree array, tree idx)
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)))
{
@ -2260,7 +2263,7 @@ build_array_ref (tree array, tree 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));
@ -2343,7 +2346,7 @@ get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function)
}
else
{
error ("object missing in use of `%E'", function);
error ("object missing in use of %qE", function);
return error_mark_node;
}
}
@ -2444,7 +2447,7 @@ build_function_call (tree function, tree params)
/* 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
@ -2469,8 +2472,9 @@ build_function_call (tree function, tree params)
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;
}
@ -2482,7 +2486,7 @@ build_function_call (tree function, tree params)
|| 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;
}
@ -2561,7 +2565,7 @@ convert_arguments (tree typelist, tree values, tree fndecl, int flags)
{
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");
}
@ -2600,10 +2604,10 @@ convert_arguments (tree typelist, tree values, tree fndecl, int flags)
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
@ -2667,7 +2671,7 @@ convert_arguments (tree typelist, tree values, tree fndecl, int flags)
{
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");
}
@ -2819,8 +2823,8 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
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;
}
}
@ -2829,8 +2833,8 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
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;
}
}
@ -2890,9 +2894,9 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
|| 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)));
@ -2926,9 +2930,9 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
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)
{
@ -3187,7 +3191,7 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
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;
}
@ -3349,8 +3353,8 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
&& 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
@ -3522,7 +3526,7 @@ pointer_diff (tree op0, tree op1, tree ptrtype)
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)
@ -3884,16 +3888,16 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert)
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
@ -3950,7 +3954,7 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert)
{
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);
@ -3979,7 +3983,7 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert)
}
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)
@ -4035,12 +4039,12 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert)
/* 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);
@ -4086,7 +4090,7 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert)
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)
@ -4118,7 +4122,7 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert)
}
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;
}
@ -4251,7 +4255,7 @@ unary_complex_lvalue (enum tree_code code, tree arg)
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;
}
@ -4333,8 +4337,8 @@ cxx_mark_addressable (tree exp)
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;
@ -4473,7 +4477,7 @@ check_for_casting_away_constness (tree src_type, tree dest_type,
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);
}
@ -4675,7 +4679,7 @@ build_static_cast (tree type, tree expr)
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;
}
@ -4718,7 +4722,8 @@ build_reinterpret_cast (tree type, tree expr)
{
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);
@ -4738,8 +4743,8 @@ build_reinterpret_cast (tree type, tree expr)
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)))
@ -4763,8 +4768,8 @@ build_reinterpret_cast (tree type, tree expr)
}
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;
}
@ -4791,10 +4796,12 @@ build_const_cast (tree type, tree expr)
}
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;
}
@ -4817,7 +4824,8 @@ build_const_cast (tree type, tree expr)
{
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;
}
@ -4834,7 +4842,7 @@ build_const_cast (tree type, tree expr)
&& 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;
}
@ -4881,12 +4889,12 @@ build_c_cast (tree type, tree expr)
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;
}
}
@ -4894,7 +4902,7 @@ build_c_cast (tree type, tree expr)
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;
}
@ -4950,8 +4958,9 @@ build_c_cast (tree type, tree expr)
&& 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)
@ -4998,8 +5007,9 @@ build_c_cast (tree type, tree expr)
&& 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. */
@ -5183,7 +5193,7 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
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;
}
@ -5252,7 +5262,7 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
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;
}
@ -5398,10 +5408,10 @@ get_delta_difference (tree from, tree to, int force)
{
/* 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));
}
}
@ -5474,8 +5484,8 @@ build_ptrmemfunc (tree type, tree pfn, int force)
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),
@ -5636,10 +5646,10 @@ dubious_conversion_warnings (tree type, tree expr,
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. */
@ -5647,10 +5657,10 @@ dubious_conversion_warnings (tree type, tree expr,
&& 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. */
@ -5659,11 +5669,10 @@ dubious_conversion_warnings (tree type, tree expr,
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);
@ -5749,11 +5758,10 @@ convert_for_assignment (tree type, tree rhs,
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;
}
}
@ -5829,9 +5837,9 @@ convert_for_initialization (tree exp, tree type, tree rhs, int flags,
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;
}
@ -5900,10 +5908,10 @@ maybe_warn_about_returning_address_of_local (tree retval)
|| 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;
}
@ -6006,7 +6014,8 @@ check_return_expr (tree retval)
&& !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
@ -6031,7 +6040,7 @@ check_return_expr (tree retval)
}
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:

111
gcc/cp/typeck2.c

@ -49,7 +49,7 @@ error_not_base_type (tree basetype, tree type)
{
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;
}
@ -84,9 +84,9 @@ readonly_error (tree arg, const char* string, int soft)
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)
@ -94,22 +94,22 @@ readonly_error (tree arg, const char* string, int soft)
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);
}
@ -289,30 +289,30 @@ abstract_virtuals_error (tree decl, tree type)
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))
@ -321,7 +321,7 @@ abstract_virtuals_error (tree decl, tree type)
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);
@ -331,7 +331,7 @@ abstract_virtuals_error (tree decl, tree type)
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;
@ -374,7 +374,7 @@ cxx_incomplete_type_diagnostic (tree value, tree type, int diag_type)
|| 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:
@ -386,15 +386,15 @@ cxx_incomplete_type_diagnostic (tree value, tree type, int diag_type)
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:
@ -408,7 +408,7 @@ cxx_incomplete_type_diagnostic (tree value, tree type, int diag_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:
@ -419,7 +419,8 @@ cxx_incomplete_type_diagnostic (tree value, tree type, int diag_type)
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
@ -577,7 +578,8 @@ store_init_value (tree decl, tree init)
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));
}
}
@ -752,10 +754,10 @@ digest_init (tree type, tree init, tree* tail)
}
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);
}
@ -767,7 +769,7 @@ digest_init (tree type, tree init, tree* tail)
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;
}
@ -778,7 +780,8 @@ digest_init (tree type, tree init, tree* tail)
{
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;
}
@ -1009,23 +1012,22 @@ process_init_constructor (tree type, tree init, tree* elts)
/* 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),
@ -1078,16 +1080,16 @@ process_init_constructor (tree type, tree init, tree* elts)
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;
}
@ -1248,7 +1250,7 @@ build_x_arrow (tree expr)
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;
}
@ -1272,9 +1274,9 @@ build_x_arrow (tree expr)
}
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;
}
@ -1298,7 +1300,8 @@ build_m_component_ref (tree datum, tree component)
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;
}
@ -1306,8 +1309,9 @@ build_m_component_ref (tree datum, tree component)
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;
}
@ -1327,7 +1331,8 @@ build_m_component_ref (tree datum, tree component)
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;
}
@ -1549,10 +1554,10 @@ require_complete_eh_spec_types (tree fntype, tree decl)
{
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);
}
}

6
gcc/testsuite/ChangeLog

@ -1,3 +1,9 @@
2004-10-10 Gabriel Dos Reis <gdr@integrable-solutions.net>
* g++.dg/overload/pmf1.C: Adjust quoting marks.
* g++.dg/warn/incomplete1.C: Likewise.
* g++.dg/template/qualttp20.C: Likewise.
2004-10-10 Joseph S. Myers <jsm@polyomino.org.uk>
PR c/17881

2
gcc/testsuite/g++.dg/overload/pmf1.C

@ -17,5 +17,5 @@ void f (C) {} // even though this would be well-formed
int main ()
{
f (aip); // { dg-error "`A' is an inaccessible base of `B'" "" }
f (aip); // { dg-error "'A' is an inaccessible base of 'B'" "" }
}

4
gcc/testsuite/g++.dg/template/qualttp20.C

@ -15,8 +15,8 @@ struct AS
template <typename T> struct B1 : T
{
typedef typename T::L __restrict__ r;// { dg-error "`__restrict__' qualifiers cannot" "" }
typedef typename T::myT __restrict__ p;// { dg-warning "ignoring `__restrict__'" "" { xfail *-*-* } }
typedef typename T::L __restrict__ r;// { dg-error "'__restrict__' qualifiers cannot" "" }
typedef typename T::myT __restrict__ p;// { dg-warning "ignoring '__restrict__'" "" { xfail *-*-* } }
// The following are DR 295 dependent
typedef typename T::myT volatile *myvolatile;

4
gcc/testsuite/g++.dg/warn/incomplete1.C

@ -9,9 +9,9 @@
// (But the deletion does not constitute an ill-formed program. So the
// program should nevertheless compile, but it should give a warning.)
class A; // { dg-warning "forward declaration of `struct A'" "" }
class A; // { dg-warning "forward declaration of 'struct A'" "" }
A *a; // { dg-warning "`a' has incomplete type" "" }
A *a; // { dg-warning "'a' has incomplete type" "" }
int
main (int argc, char **argv)