diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 6084f5175de..3d7d7409f68 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,41 @@ +2004-10-10 Gabriel Dos Reis + + 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 PR c++/17867 diff --git a/gcc/cp/rtti.c b/gcc/cp/rtti.c index b995726e09b..c2d5d181381 100644 --- a/gcc/cp/rtti.c +++ b/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; } diff --git a/gcc/cp/search.c b/gcc/cp/search.c index cd6e9b2dc65..ad5dd9e4f3a 100644 --- a/gcc/cp/search.c +++ b/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 { diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c index 78d2683f6ef..124af39e586 100644 --- a/gcc/cp/semantics.c +++ b/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); + ? "% 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; } diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c index a4b7cf9c0d4..cb9379caf8a 100644 --- a/gcc/cp/tree.c +++ b/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; } diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c index 8b9bdd3c523..e59755416ab 100644 --- a/gcc/cp/typeck.c +++ b/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 % " + "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 % 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 % 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 %"); 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 %"); } 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 % 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 ("% must not return NULL unless it is " + "declared % (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 ("% should return a reference to %<*this%>"); } /* The fabled Named Return Value optimization, as per [class.copy]/15: diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c index 089e15501cf..758f5f06de6 100644 --- a/gcc/cp/typeck2.c +++ b/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 %()%> 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); } } diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 28a26b2eb76..3ec98ce366f 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,9 @@ +2004-10-10 Gabriel Dos Reis + + * 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 PR c/17881 diff --git a/gcc/testsuite/g++.dg/overload/pmf1.C b/gcc/testsuite/g++.dg/overload/pmf1.C index 772cb530529..b97f64e764b 100644 --- a/gcc/testsuite/g++.dg/overload/pmf1.C +++ b/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'" "" } } diff --git a/gcc/testsuite/g++.dg/template/qualttp20.C b/gcc/testsuite/g++.dg/template/qualttp20.C index e58e2d2748d..5a9c61c4304 100644 --- a/gcc/testsuite/g++.dg/template/qualttp20.C +++ b/gcc/testsuite/g++.dg/template/qualttp20.C @@ -15,8 +15,8 @@ struct AS template 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; diff --git a/gcc/testsuite/g++.dg/warn/incomplete1.C b/gcc/testsuite/g++.dg/warn/incomplete1.C index 389f8bd539e..aed32a19ac4 100644 --- a/gcc/testsuite/g++.dg/warn/incomplete1.C +++ b/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)