Convert diagnostics to use quoting flag q 7/n

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

gcc/cp/ChangeLog

+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

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,7 +571,7 @@ 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",
+		  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;
@@ -584,7 +585,7 @@ 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",
+		  warning ("dynamic_cast of %q#D to %q#T can never succeed",
                            op, type);
 		  retval = build_int_cst (type, 0); 
 		  return retval;
@@ -663,7 +664,7 @@ 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)",
+  error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
          expr, exprtype, type, errstr);
   return error_mark_node;
 }

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
 	{

gcc/cp/semantics.c

@@ -1130,7 +1130,7 @@ 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", 
+	      error ("type of asm operand %qE could not be determined", 
                      TREE_VALUE (t));
 	      converted_operand = error_mark_node;
 	    }
@@ -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;
     }
 

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;
     }

gcc/testsuite/ChangeLog

+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

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'" "" }
 }

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;

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)