OSDN Git Service

* c-objc-common.c (c_tree_printer): Print identifiers with
authorjsm28 <jsm28@138bc75d-0d04-0410-961f-82ee72b054a4>
Fri, 1 May 2009 14:09:20 +0000 (14:09 +0000)
committerjsm28 <jsm28@138bc75d-0d04-0410-961f-82ee72b054a4>
Fri, 1 May 2009 14:09:20 +0000 (14:09 +0000)
pp_identifier, not pp_string.  Mark "({anonymous})" for
translation.
* c-pretty-print.c (pp_c_ws_string): New.
(pp_c_cv_qualifier, pp_c_type_specifier,
pp_c_specifier_qualifier_list, pp_c_parameter_type_list,
pp_c_storage_class_specifier, pp_c_function_specifier,
pp_c_attributes, pp_c_bool_constant, pp_c_constant,
pp_c_primary_expression, pp_c_postfix_expression,
pp_c_unary_expression, pp_c_shift_expression,
pp_c_relational_expression, pp_c_equality_expression,
pp_c_logical_and_expression, pp_c_logical_or_expression): Mostly
use pp_string and pp_c_ws_string in place of pp_identifier and
pp_c_identifier for non-identifiers.  Mark English strings for
translation.
* c-pretty-print.h (pp_c_ws_string): Declare.

cp:
* cxx-pretty-print.c (is_destructor_name, pp_cxx_unqualified_id,
pp_cxx_template_keyword_if_needed, pp_cxx_postfix_expression,
pp_cxx_new_expression, pp_cxx_delete_expression,
pp_cxx_unary_expression, pp_cxx_assignment_operator,
pp_cxx_assignment_expression, pp_cxx_expression,
pp_cxx_function_specifier, pp_cxx_decl_specifier_seq,
pp_cxx_simple_type_specifier, pp_cxx_type_specifier_seq,
pp_cxx_exception_specification, pp_cxx_direct_declarator,
pp_cxx_ctor_initializer, pp_cxx_type_id, pp_cxx_statement,
pp_cxx_namespace_alias_definition, pp_cxx_template_parameter,
pp_cxx_canonical_template_parameter, pp_cxx_template_declaration,
pp_cxx_declaration, pp_cxx_typeid_expression,
pp_cxx_va_arg_expression, pp_cxx_offsetof_expression,
pp_cxx_trait_expression): Mostly use pp_string and
pp_cxx_ws_string in place of pp_identifier and pp_cxx_identifier
for non-identifiers.  Mark English strings for translation.
* cxx-pretty-print.h (pp_cxx_ws_string): Define.
* error.c (dump_template_parameter, dump_template_bindings,
dump_type, dump_aggr_type, dump_type_prefix, dump_simple_decl,
dump_decl, dump_template_decl, dump_function_decl,
dump_parameters, dump_exception_spec, dump_template_parms,
dump_expr, dump_binary_op, dump_unary_op, op_to_string,
assop_to_string, args_to_string, cp_print_error_function,
print_instantiation_full_context,
print_instantiation_partial_context): Mostly use pp_string and
pp_cxx_ws_string in place of pp_identifier and pp_cxx_identifier
for non-identifiers.  Mark English strings for translation.
(dump_global_iord): Mark strings for translation; use longer
strings instead of substituting single words.
(function_category): Return a format string marked for
translation, not a single word or phrase to substitute in a longer
phrase.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@147033 138bc75d-0d04-0410-961f-82ee72b054a4

gcc/ChangeLog
gcc/c-objc-common.c
gcc/c-pretty-print.c
gcc/c-pretty-print.h
gcc/cp/ChangeLog
gcc/cp/cxx-pretty-print.c
gcc/cp/cxx-pretty-print.h
gcc/cp/error.c

index 4df38d7..75ebba5 100644 (file)
@@ -1,3 +1,22 @@
+2009-05-01  Joseph Myers  <joseph@codesourcery.com>
+
+       * c-objc-common.c (c_tree_printer): Print identifiers with
+       pp_identifier, not pp_string.  Mark "({anonymous})" for
+       translation.
+       * c-pretty-print.c (pp_c_ws_string): New.
+       (pp_c_cv_qualifier, pp_c_type_specifier,
+       pp_c_specifier_qualifier_list, pp_c_parameter_type_list,
+       pp_c_storage_class_specifier, pp_c_function_specifier,
+       pp_c_attributes, pp_c_bool_constant, pp_c_constant,
+       pp_c_primary_expression, pp_c_postfix_expression,
+       pp_c_unary_expression, pp_c_shift_expression,
+       pp_c_relational_expression, pp_c_equality_expression,
+       pp_c_logical_and_expression, pp_c_logical_or_expression): Mostly
+       use pp_string and pp_c_ws_string in place of pp_identifier and
+       pp_c_identifier for non-identifiers.  Mark English strings for
+       translation.
+       * c-pretty-print.h (pp_c_ws_string): Declare.
+
 2009-04-30  Paul Pluzhnikov  <ppluzhnikov@google.com>
            Roland McGrath <roland@redhat.com>
 
index 274f270..d6729ac 100644 (file)
@@ -1,5 +1,6 @@
 /* Some code common to C and ObjC front ends.
-   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
+   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007,
+   2009 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -26,6 +27,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "insn-config.h"
 #include "integrate.h"
 #include "c-tree.h"
+#include "intl.h"
 #include "c-pretty-print.h"
 #include "function.h"
 #include "flags.h"
@@ -98,7 +100,6 @@ c_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
 {
   tree t = va_arg (*text->args_ptr, tree);
   tree name;
-  const char *n = "({anonymous})";
   c_pretty_printer *cpp = (c_pretty_printer *) pp;
   pp->padding = pp_none;
 
@@ -124,7 +125,10 @@ c_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
 
     case 'F':
       if (DECL_NAME (t))
-       n = lang_hooks.decl_printable_name (t, 2);
+       {
+         pp_identifier (cpp, lang_hooks.decl_printable_name (t, 2));
+         return true;
+       }
       break;
 
     case 'T':
@@ -134,7 +138,7 @@ c_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
       if (name && TREE_CODE (name) == TYPE_DECL)
        {
          if (DECL_NAME (name))
-           pp_string (cpp, lang_hooks.decl_printable_name (name, 2));
+           pp_identifier (cpp, lang_hooks.decl_printable_name (name, 2));
          else
            pp_type_id (cpp, t);
          return true;
@@ -148,19 +152,16 @@ c_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
 
     case 'E':
       if (TREE_CODE (t) == IDENTIFIER_NODE)
-       n = IDENTIFIER_POINTER (t);
+       pp_identifier (cpp, IDENTIFIER_POINTER (t));
       else
-       {
-         pp_expression (cpp, t);
-         return true;
-       }
-      break;
+       pp_expression (cpp, t);
+      return true;
 
     default:
       return false;
     }
 
-  pp_string (cpp, n);
+  pp_string (cpp, _("({anonymous})"));
   return true;
 }
 
index ebfb885..efd15ac 100644 (file)
@@ -25,6 +25,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "tm.h"
 #include "real.h"
 #include "fixed-value.h"
+#include "intl.h"
 #include "c-pretty-print.h"
 #include "c-tree.h"
 #include "tree-iterator.h"
@@ -177,7 +178,7 @@ pp_c_cv_qualifier (c_pretty_printer *pp, const char *cv)
      logic in the C++ pretty-printer.  */
   if (p != NULL && (*p == '*' || *p == '&'))
     pp_c_whitespace (pp);
-  pp_c_identifier (pp, cv);
+  pp_c_ws_string (pp, cv);
 }
 
 /* Pretty-print T using the type-cast notation '( type-name )'.  */
@@ -306,7 +307,7 @@ pp_c_type_specifier (c_pretty_printer *pp, tree t)
   switch (code)
     {
     case ERROR_MARK:
-      pp_c_identifier (pp, "<type-error>");
+      pp_c_ws_string (pp, _("<type-error>"));
       break;
 
     case IDENTIFIER_NODE:
@@ -345,14 +346,14 @@ pp_c_type_specifier (c_pretty_printer *pp, tree t)
                {
                case INTEGER_TYPE:
                  pp_string (pp, (TYPE_UNSIGNED (t)
-                                 ? "<unnamed-unsigned:"
-                                 : "<unnamed-signed:"));
+                                 ? _("<unnamed-unsigned:")
+                                 : _("<unnamed-signed:")));
                  break;
                case REAL_TYPE:
-                 pp_string (pp, "<unnamed-float:");
+                 pp_string (pp, _("<unnamed-float:"));
                  break;
                case FIXED_POINT_TYPE:
-                 pp_string (pp, "<unnamed-fixed:");
+                 pp_string (pp, _("<unnamed-fixed:"));
                  break;
                default:
                  gcc_unreachable ();
@@ -367,25 +368,25 @@ pp_c_type_specifier (c_pretty_printer *pp, tree t)
       if (DECL_NAME (t))
        pp_id_expression (pp, t);
       else
-       pp_c_identifier (pp, "<typedef-error>");
+       pp_c_ws_string (pp, _("<typedef-error>"));
       break;
 
     case UNION_TYPE:
     case RECORD_TYPE:
     case ENUMERAL_TYPE:
       if (code == UNION_TYPE)
-       pp_c_identifier (pp, "union");
+       pp_c_ws_string (pp, "union");
       else if (code == RECORD_TYPE)
-       pp_c_identifier (pp, "struct");
+       pp_c_ws_string (pp, "struct");
       else if (code == ENUMERAL_TYPE)
-       pp_c_identifier (pp, "enum");
+       pp_c_ws_string (pp, "enum");
       else
-       pp_c_identifier (pp, "<tag-error>");
+       pp_c_ws_string (pp, _("<tag-error>"));
 
       if (TYPE_NAME (t))
        pp_id_expression (pp, TYPE_NAME (t));
       else
-       pp_c_identifier (pp, "<anonymous>");
+       pp_c_ws_string (pp, _("<anonymous>"));
       break;
 
     default:
@@ -441,9 +442,9 @@ pp_c_specifier_qualifier_list (c_pretty_printer *pp, tree t)
     case COMPLEX_TYPE:
       pp_c_specifier_qualifier_list (pp, TREE_TYPE (t));
       if (code == COMPLEX_TYPE)
-       pp_c_identifier (pp, flag_isoc99 ? "_Complex" : "__complex__");
+       pp_c_ws_string (pp, flag_isoc99 ? "_Complex" : "__complex__");
       else if (code == VECTOR_TYPE)
-       pp_c_identifier (pp, "__vector__");
+       pp_c_ws_string (pp, "__vector__");
       break;
 
     default:
@@ -471,7 +472,7 @@ pp_c_parameter_type_list (c_pretty_printer *pp, tree t)
   tree parms = want_parm_decl ? DECL_ARGUMENTS (t) :  TYPE_ARG_TYPES (t);
   pp_c_left_paren (pp);
   if (parms == void_list_node)
-    pp_c_identifier (pp, "void");
+    pp_c_ws_string (pp, "void");
   else
     {
       bool first = true;
@@ -587,13 +588,13 @@ void
 pp_c_storage_class_specifier (c_pretty_printer *pp, tree t)
 {
   if (TREE_CODE (t) == TYPE_DECL)
-    pp_c_identifier (pp, "typedef");
+    pp_c_ws_string (pp, "typedef");
   else if (DECL_P (t))
     {
       if (DECL_REGISTER (t))
-       pp_c_identifier (pp, "register");
+       pp_c_ws_string (pp, "register");
       else if (TREE_STATIC (t) && TREE_CODE (t) == VAR_DECL)
-       pp_c_identifier (pp, "static");
+       pp_c_ws_string (pp, "static");
     }
 }
 
@@ -604,7 +605,7 @@ void
 pp_c_function_specifier (c_pretty_printer *pp, tree t)
 {
   if (TREE_CODE (t) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (t))
-    pp_c_identifier (pp, "inline");
+    pp_c_ws_string (pp, "inline");
 }
 
 /* declaration-specifiers:
@@ -733,7 +734,7 @@ pp_c_attributes (c_pretty_printer *pp, tree attributes)
   if (attributes == NULL_TREE)
     return;
 
-  pp_c_identifier (pp, "__attribute__");
+  pp_c_ws_string (pp, "__attribute__");
   pp_c_left_paren (pp);
   pp_c_left_paren (pp);
   for (; attributes != NULL_TREE; attributes = TREE_CHAIN (attributes))
@@ -869,18 +870,18 @@ pp_c_bool_constant (c_pretty_printer *pp, tree b)
   if (b == boolean_false_node)
     {
       if (c_dialect_cxx ())
-       pp_c_identifier (pp, "false");
+       pp_c_ws_string (pp, "false");
       else if (flag_isoc99)
-       pp_c_identifier (pp, "_False");
+       pp_c_ws_string (pp, "_False");
       else
        pp_unsupported_tree (pp, b);
     }
   else if (b == boolean_true_node)
     {
       if (c_dialect_cxx ())
-       pp_c_identifier (pp, "true");
+       pp_c_ws_string (pp, "true");
       else if (flag_isoc99)
-       pp_c_identifier (pp, "_True");
+       pp_c_ws_string (pp, "_True");
       else
        pp_unsupported_tree (pp, b);
     }
@@ -1069,7 +1070,20 @@ pp_c_constant (c_pretty_printer *pp, tree e)
     }
 }
 
-/* Pretty-print an IDENTIFIER_NODE, preceded by whitespace is necessary.  */
+/* Pretty-print a string such as an identifier, without changing its
+   encoding, preceded by whitespace is necessary.  */
+
+void
+pp_c_ws_string (c_pretty_printer *pp, const char *str)
+{
+  pp_c_maybe_whitespace (pp);
+  pp_string (pp, str);
+  pp_base (pp)->padding = pp_before;
+}
+
+/* Pretty-print an IDENTIFIER_NODE, which may contain UTF-8 sequences
+   that need converting to the locale encoding, preceded by whitespace
+   is necessary.  */
 
 void
 pp_c_identifier (c_pretty_printer *pp, const char *id)
@@ -1105,11 +1119,11 @@ pp_c_primary_expression (c_pretty_printer *pp, tree e)
       break;
 
     case ERROR_MARK:
-      pp_c_identifier (pp, "<erroneous-expression>");
+      pp_c_ws_string (pp, _("<erroneous-expression>"));
       break;
 
     case RESULT_DECL:
-      pp_c_identifier (pp, "<return-value>");
+      pp_c_ws_string (pp, _("<return-value>"));
       break;
 
     case INTEGER_CST:
@@ -1120,7 +1134,7 @@ pp_c_primary_expression (c_pretty_printer *pp, tree e)
       break;
 
     case TARGET_EXPR:
-      pp_c_identifier (pp, "__builtin_memcpy");
+      pp_c_ws_string (pp, "__builtin_memcpy");
       pp_c_left_paren (pp);
       pp_ampersand (pp);
       pp_primary_expression (pp, TREE_OPERAND (e, 0));
@@ -1338,7 +1352,7 @@ pp_c_postfix_expression (c_pretty_printer *pp, tree e)
     case POSTINCREMENT_EXPR:
     case POSTDECREMENT_EXPR:
       pp_postfix_expression (pp, TREE_OPERAND (e, 0));
-      pp_identifier (pp, code == POSTINCREMENT_EXPR ? "++" : "--");
+      pp_string (pp, code == POSTINCREMENT_EXPR ? "++" : "--");
       break;
 
     case ARRAY_REF:
@@ -1365,49 +1379,49 @@ pp_c_postfix_expression (c_pretty_printer *pp, tree e)
       }
 
     case UNORDERED_EXPR:
-      pp_c_identifier (pp, flag_isoc99
+      pp_c_ws_string (pp, flag_isoc99
                           ? "isunordered"
                           : "__builtin_isunordered");
       goto two_args_fun;
 
     case ORDERED_EXPR:
-      pp_c_identifier (pp, flag_isoc99
+      pp_c_ws_string (pp, flag_isoc99
                           ? "!isunordered"
                           : "!__builtin_isunordered");
       goto two_args_fun;
 
     case UNLT_EXPR:
-      pp_c_identifier (pp, flag_isoc99
+      pp_c_ws_string (pp, flag_isoc99
                           ? "!isgreaterequal"
                           : "!__builtin_isgreaterequal");
       goto two_args_fun;
 
     case UNLE_EXPR:
-      pp_c_identifier (pp, flag_isoc99
+      pp_c_ws_string (pp, flag_isoc99
                           ? "!isgreater"
                           : "!__builtin_isgreater");
       goto two_args_fun;
 
     case UNGT_EXPR:
-      pp_c_identifier (pp, flag_isoc99
+      pp_c_ws_string (pp, flag_isoc99
                           ? "!islessequal"
                           : "!__builtin_islessequal");
       goto two_args_fun;
 
     case UNGE_EXPR:
-      pp_c_identifier (pp, flag_isoc99
+      pp_c_ws_string (pp, flag_isoc99
                           ? "!isless"
                           : "!__builtin_isless");
       goto two_args_fun;
 
     case UNEQ_EXPR:
-      pp_c_identifier (pp, flag_isoc99
+      pp_c_ws_string (pp, flag_isoc99
                           ? "!islessgreater"
                           : "!__builtin_islessgreater");
       goto two_args_fun;
 
     case LTGT_EXPR:
-      pp_c_identifier (pp, flag_isoc99
+      pp_c_ws_string (pp, flag_isoc99
                           ? "islessgreater"
                           : "__builtin_islessgreater");
       goto two_args_fun;
@@ -1421,7 +1435,7 @@ pp_c_postfix_expression (c_pretty_printer *pp, tree e)
       break;
 
     case ABS_EXPR:
-      pp_c_identifier (pp, "__builtin_abs");
+      pp_c_ws_string (pp, "__builtin_abs");
       pp_c_left_paren (pp);
       pp_expression (pp, TREE_OPERAND (e, 0));
       pp_c_right_paren (pp);
@@ -1491,7 +1505,7 @@ pp_c_postfix_expression (c_pretty_printer *pp, tree e)
       break;
 
     case VA_ARG_EXPR:
-      pp_c_identifier (pp, "__builtin_va_arg");
+      pp_c_ws_string (pp, "__builtin_va_arg");
       pp_c_left_paren (pp);
       pp_assignment_expression (pp, TREE_OPERAND (e, 0));
       pp_separate_with (pp, ',');
@@ -1580,7 +1594,7 @@ pp_c_unary_expression (c_pretty_printer *pp, tree e)
     {
     case PREINCREMENT_EXPR:
     case PREDECREMENT_EXPR:
-      pp_identifier (pp, code == PREINCREMENT_EXPR ? "++" : "--");
+      pp_string (pp, code == PREINCREMENT_EXPR ? "++" : "--");
       pp_c_unary_expression (pp, TREE_OPERAND (e, 0));
       break;
 
@@ -1606,7 +1620,7 @@ pp_c_unary_expression (c_pretty_printer *pp, tree e)
 
     case REALPART_EXPR:
     case IMAGPART_EXPR:
-      pp_c_identifier (pp, code == REALPART_EXPR ? "__real__" : "__imag__");
+      pp_c_ws_string (pp, code == REALPART_EXPR ? "__real__" : "__imag__");
       pp_c_whitespace (pp);
       pp_unary_expression (pp, TREE_OPERAND (e, 0));
       break;
@@ -1717,7 +1731,7 @@ pp_c_shift_expression (c_pretty_printer *pp, tree e)
     case RSHIFT_EXPR:
       pp_c_shift_expression (pp, TREE_OPERAND (e, 0));
       pp_c_whitespace (pp);
-      pp_identifier (pp, code == LSHIFT_EXPR ? "<<" : ">>");
+      pp_string (pp, code == LSHIFT_EXPR ? "<<" : ">>");
       pp_c_whitespace (pp);
       pp_c_additive_expression (pp, TREE_OPERAND (e, 1));
       break;
@@ -1751,9 +1765,9 @@ pp_c_relational_expression (c_pretty_printer *pp, tree e)
       else if (code == GT_EXPR)
        pp_greater (pp);
       else if (code == LE_EXPR)
-       pp_identifier (pp, "<=");
+       pp_string (pp, "<=");
       else if (code == GE_EXPR)
-       pp_identifier (pp, ">=");
+       pp_string (pp, ">=");
       pp_c_whitespace (pp);
       pp_c_shift_expression (pp, TREE_OPERAND (e, 1));
       break;
@@ -1779,7 +1793,7 @@ pp_c_equality_expression (c_pretty_printer *pp, tree e)
     case NE_EXPR:
       pp_c_equality_expression (pp, TREE_OPERAND (e, 0));
       pp_c_whitespace (pp);
-      pp_identifier (pp, code == EQ_EXPR ? "==" : "!=");
+      pp_string (pp, code == EQ_EXPR ? "==" : "!=");
       pp_c_whitespace (pp);
       pp_c_relational_expression (pp, TREE_OPERAND (e, 1));
       break;
@@ -1863,7 +1877,7 @@ pp_c_logical_and_expression (c_pretty_printer *pp, tree e)
     {
       pp_c_logical_and_expression (pp, TREE_OPERAND (e, 0));
       pp_c_whitespace (pp);
-      pp_identifier (pp, "&&");
+      pp_string (pp, "&&");
       pp_c_whitespace (pp);
       pp_c_inclusive_or_expression (pp, TREE_OPERAND (e, 1));
     }
@@ -1883,7 +1897,7 @@ pp_c_logical_or_expression (c_pretty_printer *pp, tree e)
     {
       pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
       pp_c_whitespace (pp);
-      pp_identifier (pp, "||");
+      pp_string (pp, "||");
       pp_c_whitespace (pp);
       pp_c_logical_and_expression (pp, TREE_OPERAND (e, 1));
     }
index 75f31ca..8f12bb0 100644 (file)
@@ -1,5 +1,5 @@
 /* Various declarations for the C and C++ pretty-printers.
-   Copyright (C) 2002, 2003, 2004, 2007 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2003, 2004, 2007, 2009 Free Software Foundation, Inc.
    Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
 
 This file is part of GCC.
@@ -203,6 +203,7 @@ void pp_c_primary_expression (c_pretty_printer *, tree);
 void pp_c_init_declarator (c_pretty_printer *, tree);
 void pp_c_constant (c_pretty_printer *, tree);
 void pp_c_id_expression (c_pretty_printer *, tree);
+void pp_c_ws_string (c_pretty_printer *, const char *);
 void pp_c_identifier (c_pretty_printer *, const char *);
 void pp_c_string_literal (c_pretty_printer *, tree);
 
index 710484b..785dbb1 100644 (file)
@@ -1,3 +1,38 @@
+2009-05-01  Joseph Myers  <joseph@codesourcery.com>
+
+       * cxx-pretty-print.c (is_destructor_name, pp_cxx_unqualified_id,
+       pp_cxx_template_keyword_if_needed, pp_cxx_postfix_expression,
+       pp_cxx_new_expression, pp_cxx_delete_expression,
+       pp_cxx_unary_expression, pp_cxx_assignment_operator,
+       pp_cxx_assignment_expression, pp_cxx_expression,
+       pp_cxx_function_specifier, pp_cxx_decl_specifier_seq,
+       pp_cxx_simple_type_specifier, pp_cxx_type_specifier_seq,
+       pp_cxx_exception_specification, pp_cxx_direct_declarator,
+       pp_cxx_ctor_initializer, pp_cxx_type_id, pp_cxx_statement,
+       pp_cxx_namespace_alias_definition, pp_cxx_template_parameter,
+       pp_cxx_canonical_template_parameter, pp_cxx_template_declaration,
+       pp_cxx_declaration, pp_cxx_typeid_expression,
+       pp_cxx_va_arg_expression, pp_cxx_offsetof_expression,
+       pp_cxx_trait_expression): Mostly use pp_string and
+       pp_cxx_ws_string in place of pp_identifier and pp_cxx_identifier
+       for non-identifiers.  Mark English strings for translation.
+       * cxx-pretty-print.h (pp_cxx_ws_string): Define.
+       * error.c (dump_template_parameter, dump_template_bindings,
+       dump_type, dump_aggr_type, dump_type_prefix, dump_simple_decl,
+       dump_decl, dump_template_decl, dump_function_decl,
+       dump_parameters, dump_exception_spec, dump_template_parms,
+       dump_expr, dump_binary_op, dump_unary_op, op_to_string,
+       assop_to_string, args_to_string, cp_print_error_function,
+       print_instantiation_full_context,
+       print_instantiation_partial_context): Mostly use pp_string and
+       pp_cxx_ws_string in place of pp_identifier and pp_cxx_identifier
+       for non-identifiers.  Mark English strings for translation.
+       (dump_global_iord): Mark strings for translation; use longer
+       strings instead of substituting single words.
+       (function_category): Return a format string marked for
+       translation, not a single word or phrase to substitute in a longer
+       phrase.
+
 2009-04-28  Ben Elliston  <bje@au.ibm.com>
 
        PR c++/35652
index cf9ed48..2edffd3 100644 (file)
@@ -1,5 +1,6 @@
 /* Implementation of subroutines for the GNU C++ pretty-printer.
-   Copyright (C) 2003, 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
+   Copyright (C) 2003, 2004, 2005, 2007, 2008,
+   2009 Free Software Foundation, Inc.
    Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
 
 This file is part of GCC.
@@ -23,6 +24,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "coretypes.h"
 #include "tm.h"
 #include "real.h"
+#include "intl.h"
 #include "cxx-pretty-print.h"
 #include "cp-tree.h"
 #include "toplev.h"
@@ -116,7 +118,7 @@ is_destructor_name (tree name)
 static inline void
 pp_cxx_conversion_function_id (cxx_pretty_printer *pp, tree t)
 {
-  pp_cxx_identifier (pp, "operator");
+  pp_cxx_ws_string (pp, "operator");
   pp_cxx_type_specifier_seq (pp, TREE_TYPE (t));
 }
 
@@ -145,7 +147,7 @@ pp_cxx_unqualified_id (cxx_pretty_printer *pp, tree t)
   switch (code)
     {
     case RESULT_DECL:
-      pp_cxx_identifier (pp, "<return-value>");
+      pp_cxx_ws_string (pp, _("<return-value>"));
       break;
 
     case OVERLOAD:
@@ -164,7 +166,7 @@ pp_cxx_unqualified_id (cxx_pretty_printer *pp, tree t)
 
     case IDENTIFIER_NODE:
       if (t == NULL)
-       pp_cxx_identifier (pp, "<unnamed>");
+       pp_cxx_ws_string (pp, _("<unnamed>"));
       else if (IDENTIFIER_TYPENAME_P (t))
        pp_cxx_conversion_function_id (pp, t);
       else
@@ -237,7 +239,7 @@ pp_cxx_template_keyword_if_needed (cxx_pretty_printer *pp, tree scope, tree t)
 {
   if (TREE_CODE (t) == TEMPLATE_ID_EXPR
       && TYPE_P (scope) && dependent_type_p (scope))
-    pp_cxx_identifier (pp, "template");
+    pp_cxx_ws_string (pp, "template");
 }
 
 /* nested-name-specifier:
@@ -566,13 +568,13 @@ pp_cxx_postfix_expression (cxx_pretty_printer *pp, tree t)
     case REINTERPRET_CAST_EXPR:
     case CONST_CAST_EXPR:
       if (code == DYNAMIC_CAST_EXPR)
-       pp_cxx_identifier (pp, "dynamic_cast");
+       pp_cxx_ws_string (pp, "dynamic_cast");
       else if (code == STATIC_CAST_EXPR)
-       pp_cxx_identifier (pp, "static_cast");
+       pp_cxx_ws_string (pp, "static_cast");
       else if (code == REINTERPRET_CAST_EXPR)
-       pp_cxx_identifier (pp, "reinterpret_cast");
+       pp_cxx_ws_string (pp, "reinterpret_cast");
       else
-       pp_cxx_identifier (pp, "const_cast");
+       pp_cxx_ws_string (pp, "const_cast");
       pp_cxx_begin_template_argument_list (pp);
       pp_cxx_type_id (pp, TREE_TYPE (t));
       pp_cxx_end_template_argument_list (pp);
@@ -644,7 +646,7 @@ pp_cxx_new_expression (cxx_pretty_printer *pp, tree t)
     case VEC_NEW_EXPR:
       if (NEW_EXPR_USE_GLOBAL (t))
        pp_cxx_colon_colon (pp);
-      pp_cxx_identifier (pp, "new");
+      pp_cxx_ws_string (pp, "new");
       if (TREE_OPERAND (t, 0))
        {
          pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0));
@@ -689,7 +691,7 @@ pp_cxx_delete_expression (cxx_pretty_printer *pp, tree t)
     case VEC_DELETE_EXPR:
       if (DELETE_EXPR_USE_GLOBAL (t))
        pp_cxx_colon_colon (pp);
-      pp_cxx_identifier (pp, "delete");
+      pp_cxx_ws_string (pp, "delete");
       pp_space (pp);
       if (code == VEC_DELETE_EXPR
          || DELETE_EXPR_USE_VEC (t))
@@ -743,8 +745,8 @@ pp_cxx_unary_expression (cxx_pretty_printer *pp, tree t)
     case SIZEOF_EXPR:
       if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
        {
-         pp_cxx_identifier (pp, "sizeof");
-         pp_cxx_identifier (pp, "...");
+         pp_cxx_ws_string (pp, "sizeof");
+         pp_cxx_ws_string (pp, "...");
          pp_cxx_whitespace (pp);
          pp_cxx_left_paren (pp);
          if (TYPE_P (TREE_OPERAND (t, 0)))
@@ -757,7 +759,7 @@ pp_cxx_unary_expression (cxx_pretty_printer *pp, tree t)
       /* Fall through  */
 
     case ALIGNOF_EXPR:
-      pp_cxx_identifier (pp, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
+      pp_cxx_ws_string (pp, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
       pp_cxx_whitespace (pp);
       if (TYPE_P (TREE_OPERAND (t, 0)))
        {
@@ -924,7 +926,7 @@ pp_cxx_assignment_operator (cxx_pretty_printer *pp, tree t)
       break;
     }
 
-  pp_cxx_identifier (pp, op);
+  pp_cxx_ws_string (pp, op);
 }
 
 
@@ -954,7 +956,7 @@ pp_cxx_assignment_expression (cxx_pretty_printer *pp, tree e)
       break;
 
     case THROW_EXPR:
-      pp_cxx_identifier (pp, "throw");
+      pp_cxx_ws_string (pp, "throw");
       if (TREE_OPERAND (e, 0))
        pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 0));
       break;
@@ -1076,7 +1078,7 @@ pp_cxx_expression (cxx_pretty_printer *pp, tree t)
 
     case EXPR_PACK_EXPANSION:
       pp_cxx_expression (pp, PACK_EXPANSION_PATTERN (t));
-      pp_cxx_identifier (pp, "...");
+      pp_cxx_ws_string (pp, "...");
       break;
 
     case NONTYPE_ARGUMENT_PACK:
@@ -1113,9 +1115,9 @@ pp_cxx_function_specifier (cxx_pretty_printer *pp, tree t)
     {
     case FUNCTION_DECL:
       if (DECL_VIRTUAL_P (t))
-       pp_cxx_identifier (pp, "virtual");
+       pp_cxx_ws_string (pp, "virtual");
       else if (DECL_CONSTRUCTOR_P (t) && DECL_NONCONVERTING_P (t))
-       pp_cxx_identifier (pp, "explicit");
+       pp_cxx_ws_string (pp, "explicit");
       else
        pp_c_function_specifier (pp_c_base (pp), t);
 
@@ -1148,7 +1150,7 @@ pp_cxx_decl_specifier_seq (cxx_pretty_printer *pp, tree t)
       break;
 
     case TYPE_DECL:
-      pp_cxx_identifier (pp, "typedef");
+      pp_cxx_ws_string (pp, "typedef");
       pp_cxx_decl_specifier_seq (pp, TREE_TYPE (t));
       break;
 
@@ -1209,7 +1211,7 @@ pp_cxx_simple_type_specifier (cxx_pretty_printer *pp, tree t)
       break;
 
     case TYPENAME_TYPE:
-      pp_cxx_identifier (pp, "typename");
+      pp_cxx_ws_string (pp, "typename");
       pp_cxx_nested_name_specifier (pp, TYPE_CONTEXT (t));
       pp_cxx_unqualified_id (pp, TYPE_NAME (t));
       break;
@@ -1251,7 +1253,7 @@ pp_cxx_type_specifier_seq (cxx_pretty_printer *pp, tree t)
       break;
 
     case DECLTYPE_TYPE:
-      pp_cxx_identifier (pp, "decltype");
+      pp_cxx_ws_string (pp, "decltype");
       pp_cxx_left_paren (pp);
       pp_cxx_expression (pp, DECLTYPE_TYPE_EXPR (t));
       pp_cxx_right_paren (pp);
@@ -1393,7 +1395,7 @@ pp_cxx_exception_specification (cxx_pretty_printer *pp, tree t)
 
   if (!TYPE_NOTHROW_P (t) && ex_spec == NULL)
     return;
-  pp_cxx_identifier (pp, "throw");
+  pp_cxx_ws_string (pp, "throw");
   pp_cxx_left_paren (pp);
   for (; ex_spec && TREE_VALUE (ex_spec); ex_spec = TREE_CHAIN (ex_spec))
     {
@@ -1447,7 +1449,7 @@ pp_cxx_direct_declarator (cxx_pretty_printer *pp, tree t)
              || template_parameter_pack_p (t))
            /* A function parameter pack or non-type template
               parameter pack.  */
-           pp_cxx_identifier (pp, "...");
+           pp_cxx_ws_string (pp, "...");
                      
          pp_cxx_id_expression (pp, DECL_NAME (t));
        }
@@ -1523,7 +1525,7 @@ pp_cxx_ctor_initializer (cxx_pretty_printer *pp, tree t)
        pp_cxx_primary_expression (pp, purpose);
       pp_cxx_call_argument_list (pp, TREE_VALUE (t));
       if (is_pack)
-       pp_cxx_identifier (pp, "...");
+       pp_cxx_ws_string (pp, "...");
       if (TREE_CHAIN (t))
        pp_cxx_separate_with (pp, ',');
     }
@@ -1647,7 +1649,7 @@ pp_cxx_type_id (cxx_pretty_printer *pp, tree t)
 
     case TYPE_PACK_EXPANSION:
       pp_cxx_type_id (pp, PACK_EXPANSION_PATTERN (t));
-      pp_cxx_identifier (pp, "...");
+      pp_cxx_ws_string (pp, "...");
       break;
 
     default:
@@ -1730,15 +1732,15 @@ pp_cxx_statement (cxx_pretty_printer *pp, tree t)
       break;
 
     case USING_STMT:
-      pp_cxx_identifier (pp, "using");
-      pp_cxx_identifier (pp, "namespace");
+      pp_cxx_ws_string (pp, "using");
+      pp_cxx_ws_string (pp, "namespace");
       if (DECL_CONTEXT (t))
        pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
       pp_cxx_qualified_id (pp, USING_STMT_NAMESPACE (t));
       break;
 
     case USING_DECL:
-      pp_cxx_identifier (pp, "using");
+      pp_cxx_ws_string (pp, "using");
       pp_cxx_nested_name_specifier (pp, USING_DECL_SCOPE (t));
       pp_cxx_unqualified_id (pp, DECL_NAME (t));
       break;
@@ -1750,7 +1752,7 @@ pp_cxx_statement (cxx_pretty_printer *pp, tree t)
            try compound-statement handler-seq  */
     case TRY_BLOCK:
       pp_maybe_newline_and_indent (pp, 0);
-      pp_cxx_identifier (pp, "try");
+      pp_cxx_ws_string (pp, "try");
       pp_newline_and_indent (pp, 3);
       pp_cxx_statement (pp, TRY_STMTS (t));
       pp_newline_and_indent (pp, -3);
@@ -1772,7 +1774,7 @@ pp_cxx_statement (cxx_pretty_printer *pp, tree t)
            type-specifier-seq abstract-declarator
            ...   */
     case HANDLER:
-      pp_cxx_identifier (pp, "catch");
+      pp_cxx_ws_string (pp, "catch");
       pp_cxx_left_paren (pp);
       pp_cxx_exception_declaration (pp, HANDLER_PARMS (t));
       pp_cxx_right_paren (pp);
@@ -1787,7 +1789,7 @@ pp_cxx_statement (cxx_pretty_printer *pp, tree t)
            if ( expression ) statement
            if ( expression ) statement else statement  */
     case IF_STMT:
-      pp_cxx_identifier (pp, "if");
+      pp_cxx_ws_string (pp, "if");
       pp_cxx_whitespace (pp);
       pp_cxx_left_paren (pp);
       pp_cxx_expression (pp, IF_COND (t));
@@ -1798,7 +1800,7 @@ pp_cxx_statement (cxx_pretty_printer *pp, tree t)
       if (ELSE_CLAUSE (t))
        {
          tree else_clause = ELSE_CLAUSE (t);
-         pp_cxx_identifier (pp, "else");
+         pp_cxx_ws_string (pp, "else");
          if (TREE_CODE (else_clause) == IF_STMT)
            pp_cxx_whitespace (pp);
          else
@@ -1810,7 +1812,7 @@ pp_cxx_statement (cxx_pretty_printer *pp, tree t)
       break;
 
     case SWITCH_STMT:
-      pp_cxx_identifier (pp, "switch");
+      pp_cxx_ws_string (pp, "switch");
       pp_space (pp);
       pp_cxx_left_paren (pp);
       pp_cxx_expression (pp, SWITCH_STMT_COND (t));
@@ -1827,7 +1829,7 @@ pp_cxx_statement (cxx_pretty_printer *pp, tree t)
            for ( expression(opt) ; expression(opt) ; expression(opt) ) statement
            for ( declaration expression(opt) ; expression(opt) ) statement  */
     case WHILE_STMT:
-      pp_cxx_identifier (pp, "while");
+      pp_cxx_ws_string (pp, "while");
       pp_space (pp);
       pp_cxx_left_paren (pp);
       pp_cxx_expression (pp, WHILE_COND (t));
@@ -1839,11 +1841,11 @@ pp_cxx_statement (cxx_pretty_printer *pp, tree t)
       break;
 
     case DO_STMT:
-      pp_cxx_identifier (pp, "do");
+      pp_cxx_ws_string (pp, "do");
       pp_newline_and_indent (pp, 3);
       pp_cxx_statement (pp, DO_BODY (t));
       pp_newline_and_indent (pp, -3);
-      pp_cxx_identifier (pp, "while");
+      pp_cxx_ws_string (pp, "while");
       pp_space (pp);
       pp_cxx_left_paren (pp);
       pp_cxx_expression (pp, DO_COND (t));
@@ -1853,7 +1855,7 @@ pp_cxx_statement (cxx_pretty_printer *pp, tree t)
       break;
 
     case FOR_STMT:
-      pp_cxx_identifier (pp, "for");
+      pp_cxx_ws_string (pp, "for");
       pp_space (pp);
       pp_cxx_left_paren (pp);
       if (FOR_INIT_STMT (t))
@@ -1882,7 +1884,7 @@ pp_cxx_statement (cxx_pretty_printer *pp, tree t)
            return expression(opt) ;  */
     case BREAK_STMT:
     case CONTINUE_STMT:
-      pp_identifier (pp, TREE_CODE (t) == BREAK_STMT ? "break" : "continue");
+      pp_string (pp, TREE_CODE (t) == BREAK_STMT ? "break" : "continue");
       pp_cxx_semicolon (pp);
       pp_needs_newline (pp) = true;
       break;
@@ -1896,11 +1898,11 @@ pp_cxx_statement (cxx_pretty_printer *pp, tree t)
       break;
 
     case CLEANUP_STMT:
-      pp_cxx_identifier (pp, "try");
+      pp_cxx_ws_string (pp, "try");
       pp_newline_and_indent (pp, 2);
       pp_cxx_statement (pp, CLEANUP_BODY (t));
       pp_newline_and_indent (pp, -2);
-      pp_cxx_identifier (pp, CLEANUP_EH_ONLY (t) ? "catch" : "finally");
+      pp_cxx_ws_string (pp, CLEANUP_EH_ONLY (t) ? "catch" : "finally");
       pp_newline_and_indent (pp, 2);
       pp_cxx_statement (pp, CLEANUP_EXPR (t));
       pp_newline_and_indent (pp, -2);
@@ -1924,7 +1926,7 @@ pp_cxx_statement (cxx_pretty_printer *pp, tree t)
 static void
 pp_cxx_original_namespace_definition (cxx_pretty_printer *pp, tree t)
 {
-  pp_cxx_identifier (pp, "namespace");
+  pp_cxx_ws_string (pp, "namespace");
   if (DECL_CONTEXT (t))
     pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
   if (DECL_NAME (t))
@@ -1948,7 +1950,7 @@ pp_cxx_original_namespace_definition (cxx_pretty_printer *pp, tree t)
 static void
 pp_cxx_namespace_alias_definition (cxx_pretty_printer *pp, tree t)
 {
-  pp_cxx_identifier (pp, "namespace");
+  pp_cxx_ws_string (pp, "namespace");
   if (DECL_CONTEXT (t))
     pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
   pp_cxx_unqualified_id (pp, t);
@@ -2011,9 +2013,9 @@ pp_cxx_template_parameter (cxx_pretty_printer *pp, tree t)
   switch (TREE_CODE (parameter))
     {
     case TYPE_DECL:
-      pp_cxx_identifier (pp, "class");
+      pp_cxx_ws_string (pp, "class");
       if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
-       pp_cxx_identifier (pp, "...");
+       pp_cxx_ws_string (pp, "...");
       if (DECL_NAME (parameter))
        pp_cxx_tree_identifier (pp, DECL_NAME (parameter));
       /* FIXME: Check if we should print also default argument.  */
@@ -2046,7 +2048,7 @@ pp_cxx_canonical_template_parameter (cxx_pretty_printer *pp, tree parm)
     parm = TEMPLATE_TYPE_PARM_INDEX (parm);
 
   pp_cxx_begin_template_argument_list (pp);
-  pp_cxx_identifier (pp, "template-parameter-");
+  pp_cxx_ws_string (pp, _("template-parameter-"));
   pp_wide_integer (pp, TEMPLATE_PARM_LEVEL (parm));
   pp_minus (pp);
   pp_wide_integer (pp, TEMPLATE_PARM_IDX (parm) + 1);
@@ -2067,7 +2069,7 @@ pp_cxx_template_declaration (cxx_pretty_printer *pp, tree t)
   pp_maybe_newline_and_indent (pp, 0);
   for (level = DECL_TEMPLATE_PARMS (tmpl); level; level = TREE_CHAIN (level))
     {
-      pp_cxx_identifier (pp, "template");
+      pp_cxx_ws_string (pp, "template");
       pp_cxx_begin_template_argument_list (pp);
       pp_cxx_template_parameter_list (pp, TREE_VALUE (level));
       pp_cxx_end_template_argument_list (pp);
@@ -2114,7 +2116,7 @@ pp_cxx_declaration (cxx_pretty_printer *pp, tree t)
 {
   if (TREE_CODE (t) == STATIC_ASSERT)
     {
-      pp_cxx_identifier (pp, "static_assert");
+      pp_cxx_ws_string (pp, "static_assert");
       pp_cxx_left_paren (pp);
       pp_cxx_expression (pp, STATIC_ASSERT_CONDITION (t));
       pp_cxx_separate_with (pp, ',');
@@ -2172,7 +2174,7 @@ static void
 pp_cxx_typeid_expression (cxx_pretty_printer *pp, tree t)
 {
   t = TREE_OPERAND (t, 0);
-  pp_cxx_identifier (pp, "typeid");
+  pp_cxx_ws_string (pp, "typeid");
   pp_cxx_left_paren (pp);
   if (TYPE_P (t))
     pp_cxx_type_id (pp, t);
@@ -2184,7 +2186,7 @@ pp_cxx_typeid_expression (cxx_pretty_printer *pp, tree t)
 void
 pp_cxx_va_arg_expression (cxx_pretty_printer *pp, tree t)
 {
-  pp_cxx_identifier (pp, "va_arg");
+  pp_cxx_ws_string (pp, "va_arg");
   pp_cxx_left_paren (pp);
   pp_cxx_assignment_expression (pp, TREE_OPERAND (t, 0));
   pp_cxx_separate_with (pp, ',');
@@ -2228,7 +2230,7 @@ pp_cxx_offsetof_expression_1 (cxx_pretty_printer *pp, tree t)
 void
 pp_cxx_offsetof_expression (cxx_pretty_printer *pp, tree t)
 {
-  pp_cxx_identifier (pp, "offsetof");
+  pp_cxx_ws_string (pp, "offsetof");
   pp_cxx_left_paren (pp);
   if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
     pp_cxx_expression (pp, TREE_OPERAND (t, 0));
@@ -2243,55 +2245,55 @@ pp_cxx_trait_expression (cxx_pretty_printer *pp, tree t)
   switch (kind)
     {
     case CPTK_HAS_NOTHROW_ASSIGN:
-      pp_cxx_identifier (pp, "__has_nothrow_assign");
+      pp_cxx_ws_string (pp, "__has_nothrow_assign");
       break;
     case CPTK_HAS_TRIVIAL_ASSIGN:
-      pp_cxx_identifier (pp, "__has_trivial_assign");
+      pp_cxx_ws_string (pp, "__has_trivial_assign");
       break;
     case CPTK_HAS_NOTHROW_CONSTRUCTOR:
-      pp_cxx_identifier (pp, "__has_nothrow_constructor");
+      pp_cxx_ws_string (pp, "__has_nothrow_constructor");
       break;
     case CPTK_HAS_TRIVIAL_CONSTRUCTOR:
-      pp_cxx_identifier (pp, "__has_trivial_constructor");
+      pp_cxx_ws_string (pp, "__has_trivial_constructor");
       break;
     case CPTK_HAS_NOTHROW_COPY:
-      pp_cxx_identifier (pp, "__has_nothrow_copy");
+      pp_cxx_ws_string (pp, "__has_nothrow_copy");
       break;
     case CPTK_HAS_TRIVIAL_COPY:
-      pp_cxx_identifier (pp, "__has_trivial_copy");
+      pp_cxx_ws_string (pp, "__has_trivial_copy");
       break;
     case CPTK_HAS_TRIVIAL_DESTRUCTOR:
-      pp_cxx_identifier (pp, "__has_trivial_destructor");
+      pp_cxx_ws_string (pp, "__has_trivial_destructor");
       break;
     case CPTK_HAS_VIRTUAL_DESTRUCTOR:
-      pp_cxx_identifier (pp, "__has_virtual_destructor");
+      pp_cxx_ws_string (pp, "__has_virtual_destructor");
       break;
     case CPTK_IS_ABSTRACT:
-      pp_cxx_identifier (pp, "__is_abstract");
+      pp_cxx_ws_string (pp, "__is_abstract");
       break;
     case CPTK_IS_BASE_OF:
-      pp_cxx_identifier (pp, "__is_base_of");
+      pp_cxx_ws_string (pp, "__is_base_of");
       break;
     case CPTK_IS_CLASS:
-      pp_cxx_identifier (pp, "__is_class");
+      pp_cxx_ws_string (pp, "__is_class");
       break;
     case CPTK_IS_CONVERTIBLE_TO:
-      pp_cxx_identifier (pp, "__is_convertible_to");
+      pp_cxx_ws_string (pp, "__is_convertible_to");
       break;
     case CPTK_IS_EMPTY:
-      pp_cxx_identifier (pp, "__is_empty");
+      pp_cxx_ws_string (pp, "__is_empty");
       break;
     case CPTK_IS_ENUM:
-      pp_cxx_identifier (pp, "__is_enum");
+      pp_cxx_ws_string (pp, "__is_enum");
       break;
     case CPTK_IS_POD:
-      pp_cxx_identifier (pp, "__is_pod");
+      pp_cxx_ws_string (pp, "__is_pod");
       break;
     case CPTK_IS_POLYMORPHIC:
-      pp_cxx_identifier (pp, "__is_polymorphic");
+      pp_cxx_ws_string (pp, "__is_polymorphic");
       break;
     case CPTK_IS_UNION:
-      pp_cxx_identifier (pp, "__is_union");
+      pp_cxx_ws_string (pp, "__is_union");
       break;
 
     default:
index e7c4220..a88d4c5 100644 (file)
@@ -1,5 +1,5 @@
 /* Interface for the GNU C++ pretty-printer.
-   Copyright (C) 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
+   Copyright (C) 2003, 2004, 2005, 2007, 2009 Free Software Foundation, Inc.
    Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
 
 This file is part of GCC.
@@ -57,6 +57,7 @@ typedef struct
 #define pp_cxx_semicolon(PP)           pp_c_semicolon (pp_c_base (PP))
 #define pp_cxx_complement(PP)          pp_c_complement (pp_c_base (PP))
 
+#define pp_cxx_ws_string(PP, I)                pp_c_ws_string (pp_c_base (PP), I)
 #define pp_cxx_identifier(PP, I)       pp_c_identifier (pp_c_base (PP), I)
 #define pp_cxx_tree_identifier(PP, T) \
   pp_c_tree_identifier (pp_c_base (PP), T)
index 4e7e9ec..13b32ad 100644 (file)
@@ -29,6 +29,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "flags.h"
 #include "diagnostic.h"
 #include "langhooks-def.h"
+#include "intl.h"
 #include "cxx-pretty-print.h"
 #include "pointer-set.h"
 
@@ -231,9 +232,9 @@ dump_template_parameter (tree parm, int flags)
     {
       if (flags & TFF_DECL_SPECIFIERS)
        {
-         pp_cxx_identifier (cxx_pp, "class");
+         pp_cxx_ws_string (cxx_pp, "class");
           if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p)))
-            pp_cxx_identifier (cxx_pp, "...");
+            pp_cxx_ws_string (cxx_pp, "...");
          if (DECL_NAME (p))
            pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
        }
@@ -297,7 +298,7 @@ dump_template_bindings (tree parms, tree args, VEC(tree,gc)* typenames)
          if (arg)
            dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
          else
-           pp_identifier (cxx_pp, "<missing>");
+           pp_string (cxx_pp, _("<missing>"));
 
          ++arg_idx;
          need_comma = 1;
@@ -338,9 +339,9 @@ dump_type (tree t, int flags)
     {
     case UNKNOWN_TYPE:
       if (t == init_list_type_node)
-       pp_identifier (cxx_pp, "<brace-enclosed initializer list>");
+       pp_string (cxx_pp, _("<brace-enclosed initializer list>"));
       else
-       pp_identifier (cxx_pp, "<unresolved overloaded function type>");
+       pp_string (cxx_pp, _("<unresolved overloaded function type>"));
       break;
 
     case TREE_LIST:
@@ -436,7 +437,7 @@ dump_type (tree t, int flags)
          break;
        }
       pp_cxx_cv_qualifier_seq (cxx_pp, t);
-      pp_cxx_identifier (cxx_pp,
+      pp_cxx_ws_string (cxx_pp,
                         TYPENAME_IS_ENUM_P (t) ? "enum"
                         : TYPENAME_IS_CLASS_P (t) ? "class"
                         : "typename");
@@ -446,12 +447,12 @@ dump_type (tree t, int flags)
     case UNBOUND_CLASS_TEMPLATE:
       dump_type (TYPE_CONTEXT (t), flags);
       pp_cxx_colon_colon (cxx_pp);
-      pp_cxx_identifier (cxx_pp, "template");
+      pp_cxx_ws_string (cxx_pp, "template");
       dump_type (DECL_NAME (TYPE_NAME (t)), flags);
       break;
 
     case TYPEOF_TYPE:
-      pp_cxx_identifier (cxx_pp, "__typeof__");
+      pp_cxx_ws_string (cxx_pp, "__typeof__");
       pp_cxx_whitespace (cxx_pp);
       pp_cxx_left_paren (cxx_pp);
       dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
@@ -460,7 +461,7 @@ dump_type (tree t, int flags)
 
     case TYPE_PACK_EXPANSION:
       dump_type (PACK_EXPANSION_PATTERN (t), flags);
-      pp_cxx_identifier (cxx_pp, "...");
+      pp_cxx_ws_string (cxx_pp, "...");
       break;
 
     case TYPE_ARGUMENT_PACK:
@@ -468,7 +469,7 @@ dump_type (tree t, int flags)
       break;
 
     case DECLTYPE_TYPE:
-      pp_cxx_identifier (cxx_pp, "decltype");
+      pp_cxx_ws_string (cxx_pp, "decltype");
       pp_cxx_whitespace (cxx_pp);
       pp_cxx_left_paren (cxx_pp);
       dump_expr (DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
@@ -480,7 +481,7 @@ dump_type (tree t, int flags)
       /* Fall through to error.  */
 
     case ERROR_MARK:
-      pp_identifier (cxx_pp, "<type error>");
+      pp_string (cxx_pp, _("<type error>"));
       break;
     }
 }
@@ -535,7 +536,7 @@ dump_aggr_type (tree t, int flags)
   pp_cxx_cv_qualifier_seq (cxx_pp, t);
 
   if (flags & TFF_CLASS_KEY_OR_ENUM)
-    pp_cxx_identifier (cxx_pp, variety);
+    pp_cxx_ws_string (cxx_pp, variety);
 
   name = TYPE_NAME (t);
 
@@ -577,9 +578,9 @@ dump_aggr_type (tree t, int flags)
   if (name == 0 || ANON_AGGRNAME_P (name))
     {
       if (flags & TFF_CLASS_KEY_OR_ENUM)
-       pp_identifier (cxx_pp, "<anonymous>");
+       pp_string (cxx_pp, _("<anonymous>"));
       else
-       pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety);
+       pp_printf (pp_base (cxx_pp), _("<anonymous %s>"), variety);
     }
   else
     pp_cxx_tree_identifier (cxx_pp, name);
@@ -701,7 +702,7 @@ dump_type_prefix (tree t, int flags)
       pp_unsupported_tree (cxx_pp, t);
       /* fall through.  */
     case ERROR_MARK:
-      pp_identifier (cxx_pp, "<typeprefixerror>");
+      pp_string (cxx_pp, _("<typeprefixerror>"));
       break;
     }
 }
@@ -811,13 +812,13 @@ dump_global_iord (tree t)
   const char *p = NULL;
 
   if (DECL_GLOBAL_CTOR_P (t))
-    p = "initializers";
+    p = _("(static initializers for %s)");
   else if (DECL_GLOBAL_DTOR_P (t))
-    p = "destructors";
+    p = _("(static destructors for %s)");
   else
     gcc_unreachable ();
 
-  pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename);
+  pp_printf (pp_base (cxx_pp), p, input_filename);
 }
 
 static void
@@ -836,11 +837,11 @@ dump_simple_decl (tree t, tree type, int flags)
   if ((flags & TFF_DECL_SPECIFIERS)
       && DECL_TEMPLATE_PARM_P (t) 
       && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t)))
-    pp_identifier (cxx_pp, "...");
+    pp_string (cxx_pp, "...");
   if (DECL_NAME (t))
     dump_decl (DECL_NAME (t), flags);
   else
-    pp_identifier (cxx_pp, "<anonymous>");
+    pp_string (cxx_pp, _("<anonymous>"));
   if (flags & TFF_DECL_SPECIFIERS)
     dump_type_suffix (type, flags);
 }
@@ -863,18 +864,18 @@ dump_decl (tree t, int flags)
              && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
            {
              /* Say `class T' not just `T'.  */
-             pp_cxx_identifier (cxx_pp, "class");
+             pp_cxx_ws_string (cxx_pp, "class");
 
              /* Emit the `...' for a parameter pack.  */
              if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
-               pp_cxx_identifier (cxx_pp, "...");
+               pp_cxx_ws_string (cxx_pp, "...");
            }
 
          dump_type (TREE_TYPE (t), flags);
          break;
        }
       if (flags & TFF_DECL_SPECIFIERS)
-       pp_cxx_identifier (cxx_pp, "typedef");
+       pp_cxx_ws_string (cxx_pp, "typedef");
       dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
                        ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
                        flags);
@@ -883,7 +884,7 @@ dump_decl (tree t, int flags)
     case VAR_DECL:
       if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
        {
-         pp_string (cxx_pp, "vtable for ");
+         pp_string (cxx_pp, _("vtable for "));
          gcc_assert (TYPE_P (DECL_CONTEXT (t)));
          dump_type (DECL_CONTEXT (t), flags);
          break;
@@ -895,7 +896,7 @@ dump_decl (tree t, int flags)
       break;
 
     case RESULT_DECL:
-      pp_string (cxx_pp, "<return value> ");
+      pp_string (cxx_pp, _("<return value> "));
       dump_simple_decl (t, TREE_TYPE (t), flags);
       break;
 
@@ -908,7 +909,7 @@ dump_decl (tree t, int flags)
            dump_scope (CP_DECL_CONTEXT (t), flags);
          flags &= ~TFF_UNQUALIFIED_NAME;
          if (DECL_NAME (t) == NULL_TREE)
-           pp_identifier (cxx_pp, "<unnamed>");
+           pp_string (cxx_pp, _("<unnamed>"));
          else
            pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
        }
@@ -948,7 +949,7 @@ dump_decl (tree t, int flags)
     case IDENTIFIER_NODE:
       if (IDENTIFIER_TYPENAME_P (t))
        {
-         pp_cxx_identifier (cxx_pp, "operator");
+         pp_cxx_ws_string (cxx_pp, "operator");
          /* Not exactly IDENTIFIER_TYPE_VALUE.  */
          dump_type (TREE_TYPE (t), flags);
          break;
@@ -982,7 +983,7 @@ dump_decl (tree t, int flags)
 
     case FUNCTION_DECL:
       if (! DECL_LANG_SPECIFIC (t))
-       pp_identifier (cxx_pp, "<built-in>");
+       pp_string (cxx_pp, _("<built-in>"));
       else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
        dump_global_iord (t);
       else
@@ -1021,11 +1022,11 @@ dump_decl (tree t, int flags)
       else if (DECL_INITIAL (t))
        dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
       else
-       pp_identifier (cxx_pp, "<enumerator>");
+       pp_string (cxx_pp, _("<enumerator>"));
       break;
 
     case USING_DECL:
-      pp_cxx_identifier (cxx_pp, "using");
+      pp_cxx_ws_string (cxx_pp, "using");
       dump_type (USING_DECL_SCOPE (t), flags);
       pp_cxx_colon_colon (cxx_pp);
       dump_decl (DECL_NAME (t), flags);
@@ -1061,7 +1062,7 @@ dump_decl (tree t, int flags)
       /* Fall through to error.  */
 
     case ERROR_MARK:
-      pp_identifier (cxx_pp, "<declaration error>");
+      pp_string (cxx_pp, _("<declaration error>"));
       break;
     }
 }
@@ -1085,7 +1086,7 @@ dump_template_decl (tree t, int flags)
          tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
          int len = TREE_VEC_LENGTH (inner_parms);
 
-         pp_cxx_identifier (cxx_pp, "template");
+         pp_cxx_ws_string (cxx_pp, "template");
          pp_cxx_begin_template_argument_list (cxx_pp);
 
          /* If we've shown the template prefix, we'd better show the
@@ -1106,11 +1107,11 @@ dump_template_decl (tree t, int flags)
       if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
        {
          /* Say `template<arg> class TT' not just `template<arg> TT'.  */
-         pp_cxx_identifier (cxx_pp, "class");
+         pp_cxx_ws_string (cxx_pp, "class");
 
          /* If this is a parameter pack, print the ellipsis.  */
          if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
-           pp_cxx_identifier (cxx_pp, "...");
+           pp_cxx_ws_string (cxx_pp, "...");
        }
     }
 
@@ -1241,9 +1242,9 @@ dump_function_decl (tree t, int flags)
   if (!(flags & TFF_DECL_SPECIFIERS))
     /* OK */;
   else if (DECL_STATIC_FUNCTION_P (t))
-    pp_cxx_identifier (cxx_pp, "static");
+    pp_cxx_ws_string (cxx_pp, "static");
   else if (DECL_VIRTUAL_P (t))
-    pp_cxx_identifier (cxx_pp, "virtual");
+    pp_cxx_ws_string (cxx_pp, "virtual");
 
   /* Print the return type?  */
   if (show_return)
@@ -1291,7 +1292,7 @@ dump_function_decl (tree t, int flags)
     {
       pp_cxx_whitespace (cxx_pp);
       pp_cxx_left_bracket (cxx_pp);
-      pp_cxx_identifier (cxx_pp, "with");
+      pp_cxx_ws_string (cxx_pp, _("with"));
       pp_cxx_whitespace (cxx_pp);
       dump_template_bindings (template_parms, template_args, typenames);
       pp_cxx_right_bracket (cxx_pp);
@@ -1316,7 +1317,7 @@ dump_parameters (tree parmtypes, int flags)
       first = 0;
       if (!parmtypes)
        {
-         pp_cxx_identifier (cxx_pp, "...");
+         pp_cxx_ws_string (cxx_pp, "...");
          break;
        }
 
@@ -1341,7 +1342,7 @@ dump_exception_spec (tree t, int flags)
 {
   if (t)
     {
-      pp_cxx_identifier (cxx_pp, "throw");
+      pp_cxx_ws_string (cxx_pp, "throw");
       pp_cxx_whitespace (cxx_pp);
       pp_cxx_left_paren (cxx_pp);
       if (TREE_VALUE (t) != NULL_TREE)
@@ -1397,7 +1398,7 @@ dump_function_name (tree t, int flags)
         declarations, both will have the same name, yet
         the types will be different, hence the TREE_TYPE field
         of the first name will be clobbered by the second.  */
-      pp_cxx_identifier (cxx_pp, "operator");
+      pp_cxx_ws_string (cxx_pp, "operator");
       dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
     }
   else if (IDENTIFIER_OPNAME_P (name))
@@ -1456,7 +1457,7 @@ dump_template_parms (tree info, int primary, int flags)
             pp_separate_with_comma (cxx_pp);
           
           if (!arg)
-            pp_identifier (cxx_pp, "<template parameter error>");
+            pp_string (cxx_pp, _("<template parameter error>"));
           else
             dump_template_argument (arg, flags);
         }
@@ -1476,7 +1477,7 @@ dump_template_parms (tree info, int primary, int flags)
 
           if (TREE_VEC_ELT (parms, ix) == error_mark_node)
             {
-              pp_identifier (cxx_pp, "<template parameter error>");
+              pp_string (cxx_pp, _("<template parameter error>"));
               continue;
             }
 
@@ -1602,7 +1603,7 @@ dump_expr (tree t, int flags)
 
   if (STATEMENT_CLASS_P (t))
     {
-      pp_cxx_identifier (cxx_pp, "<statement>");
+      pp_cxx_ws_string (cxx_pp, _("<statement>"));
       return;
     }
 
@@ -1631,7 +1632,7 @@ dump_expr (tree t, int flags)
     case THROW_EXPR:
       /* While waiting for caret diagnostics, avoid printing
         __cxa_allocate_exception, __cxa_throw, and the like.  */
-      pp_cxx_identifier (cxx_pp, "<throw-expression>");
+      pp_cxx_ws_string (cxx_pp, _("<throw-expression>"));
       break;
 
     case PTRMEM_CST:
@@ -1662,7 +1663,7 @@ dump_expr (tree t, int flags)
     case SAVE_EXPR:
       if (TREE_HAS_CONSTRUCTOR (t))
        {
-         pp_cxx_identifier (cxx_pp, "new");
+         pp_cxx_ws_string (cxx_pp, "new");
          pp_cxx_whitespace (cxx_pp);
          dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
        }
@@ -1856,7 +1857,7 @@ dump_expr (tree t, int flags)
     case POSTINCREMENT_EXPR:
       pp_cxx_left_paren (cxx_pp);
       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
-      pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
+      pp_cxx_ws_string (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
       pp_cxx_right_paren (cxx_pp);
       break;
 
@@ -2027,16 +2028,16 @@ dump_expr (tree t, int flags)
       break;
 
     case STATIC_CAST_EXPR:
-      pp_cxx_identifier (cxx_pp, "static_cast");
+      pp_cxx_ws_string (cxx_pp, "static_cast");
       goto cast;
     case REINTERPRET_CAST_EXPR:
-      pp_cxx_identifier (cxx_pp, "reinterpret_cast");
+      pp_cxx_ws_string (cxx_pp, "reinterpret_cast");
       goto cast;
     case CONST_CAST_EXPR:
-      pp_cxx_identifier (cxx_pp, "const_cast");
+      pp_cxx_ws_string (cxx_pp, "const_cast");
       goto cast;
     case DYNAMIC_CAST_EXPR:
-      pp_cxx_identifier (cxx_pp, "dynamic_cast");
+      pp_cxx_ws_string (cxx_pp, "dynamic_cast");
     cast:
       pp_cxx_begin_template_argument_list (cxx_pp);
       dump_type (TREE_TYPE (t), flags);
@@ -2054,11 +2055,11 @@ dump_expr (tree t, int flags)
     case SIZEOF_EXPR:
     case ALIGNOF_EXPR:
       if (TREE_CODE (t) == SIZEOF_EXPR)
-       pp_cxx_identifier (cxx_pp, "sizeof");
+       pp_cxx_ws_string (cxx_pp, "sizeof");
       else
        {
          gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
-         pp_cxx_identifier (cxx_pp, "__alignof__");
+         pp_cxx_ws_string (cxx_pp, "__alignof__");
        }
       pp_cxx_whitespace (cxx_pp);
       pp_cxx_left_paren (cxx_pp);
@@ -2071,13 +2072,13 @@ dump_expr (tree t, int flags)
 
     case REALPART_EXPR:
     case IMAGPART_EXPR:
-      pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
+      pp_cxx_ws_string (cxx_pp, operator_name_info[TREE_CODE (t)].name);
       pp_cxx_whitespace (cxx_pp);
       dump_expr (TREE_OPERAND (t, 0), flags);
       break;
 
     case DEFAULT_ARG:
-      pp_identifier (cxx_pp, "<unparsed>");
+      pp_string (cxx_pp, _("<unparsed>"));
       break;
 
     case TRY_CATCH_EXPR:
@@ -2223,7 +2224,7 @@ dump_expr (tree t, int flags)
       pp_unsupported_tree (cxx_pp, t);
       /* fall through to ERROR_MARK...  */
     case ERROR_MARK:
-      pp_identifier (cxx_pp, "<expression error>");
+      pp_string (cxx_pp, _("<expression error>"));
       break;
     }
 }
@@ -2235,9 +2236,9 @@ dump_binary_op (const char *opstring, tree t, int flags)
   dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
   pp_cxx_whitespace (cxx_pp);
   if (opstring)
-    pp_cxx_identifier (cxx_pp, opstring);
+    pp_cxx_ws_string (cxx_pp, opstring);
   else
-    pp_identifier (cxx_pp, "<unknown operator>");
+    pp_string (cxx_pp, _("<unknown operator>"));
   pp_cxx_whitespace (cxx_pp);
   dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
   pp_cxx_right_paren (cxx_pp);
@@ -2248,7 +2249,7 @@ dump_unary_op (const char *opstring, tree t, int flags)
 {
   if (flags & TFF_EXPR_IN_PARENS)
     pp_cxx_left_paren (cxx_pp);
-  pp_cxx_identifier (cxx_pp, opstring);
+  pp_cxx_ws_string (cxx_pp, opstring);
   dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
   if (flags & TFF_EXPR_IN_PARENS)
     pp_cxx_right_paren (cxx_pp);
@@ -2419,7 +2420,7 @@ static const char *
 op_to_string (enum tree_code p)
 {
   tree id = operator_name_info[(int) p].identifier;
-  return id ? IDENTIFIER_POINTER (id) : "<unknown>";
+  return id ? IDENTIFIER_POINTER (id) : _("<unknown>");
 }
 
 static const char *
@@ -2439,7 +2440,7 @@ static const char *
 assop_to_string (enum tree_code p)
 {
   tree id = assignment_operator_name_info[(int) p].identifier;
-  return id ? IDENTIFIER_POINTER (id) : "{unknown}";
+  return id ? IDENTIFIER_POINTER (id) : _("{unknown}");
 }
 
 static const char *
@@ -2459,7 +2460,7 @@ args_to_string (tree p, int verbose)
   for (; p; p = TREE_CHAIN (p))
     {
       if (TREE_VALUE (p) == null_node)
-       pp_cxx_identifier (cxx_pp, "NULL");
+       pp_cxx_ws_string (cxx_pp, "NULL");
       else
        dump_type (error_type (TREE_VALUE (p)), flags);
       if (TREE_CHAIN (p))
@@ -2521,7 +2522,7 @@ cp_print_error_function (diagnostic_context *context,
       pp_base_set_prefix (context->printer, new_prefix);
 
       if (current_function_decl == NULL)
-       pp_base_string (context->printer, "At global scope:");
+       pp_base_string (context->printer, _("At global scope:"));
       else
        {
          tree fndecl, ao;
@@ -2539,8 +2540,7 @@ cp_print_error_function (diagnostic_context *context,
          else
            fndecl = current_function_decl;
 
-         pp_printf (context->printer, "In %s %qs",
-                    function_category (fndecl),
+         pp_printf (context->printer, function_category (fndecl),
                     cxx_printable_name (fndecl, 2));
 
          while (abstract_origin)
@@ -2591,18 +2591,18 @@ cp_print_error_function (diagnostic_context *context,
                    {
                      if (flag_show_column && s.column != 0)
                        pp_printf (context->printer,
-                                  "    inlined from %qs at %s:%d:%d",
+                                  _("    inlined from %qs at %s:%d:%d"),
                                   cxx_printable_name (fndecl, 2),
                                   s.file, s.line, s.column);
                      else
                        pp_printf (context->printer,
-                                  "    inlined from %qs at %s:%d",
+                                  _("    inlined from %qs at %s:%d"),
                                   cxx_printable_name (fndecl, 2),
                                   s.file, s.line);
 
                    }
                  else
-                   pp_printf (context->printer, "    inlined from %qs",
+                   pp_printf (context->printer, _("    inlined from %qs"),
                               cxx_printable_name (fndecl, 2));
                }
            }
@@ -2616,25 +2616,26 @@ cp_print_error_function (diagnostic_context *context,
     }
 }
 
-/* Returns a description of FUNCTION using standard terminology.  */
+/* Returns a description of FUNCTION using standard terminology.  The
+   result is a format string of the form "In CATEGORY %qs".  */
 static const char *
 function_category (tree fn)
 {
   if (DECL_FUNCTION_MEMBER_P (fn))
     {
       if (DECL_STATIC_FUNCTION_P (fn))
-       return "static member function";
+       return _("In static member function %qs");
       else if (DECL_COPY_CONSTRUCTOR_P (fn))
-       return "copy constructor";
+       return _("In copy constructor %qs");
       else if (DECL_CONSTRUCTOR_P (fn))
-       return "constructor";
+       return _("In constructor %qs");
       else if (DECL_DESTRUCTOR_P (fn))
-       return "destructor";
+       return _("In destructor %qs");
       else
-       return "member function";
+       return _("In member function %qs");
     }
   else
-    return "function";
+    return _("In function %qs");
 }
 
 /* Report the full context of a current template instantiation,
@@ -2659,7 +2660,7 @@ print_instantiation_full_context (diagnostic_context *context)
            /* Avoid redundancy with the "In function" line.  */;
          else
            pp_verbatim (context->printer,
-                        "%s: In instantiation of %qs:\n",
+                        _("%s: In instantiation of %qs:\n"),
                         LOCATION_FILE (location),
                         decl_as_string (p->decl,
                                         TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
@@ -2683,13 +2684,13 @@ print_instantiation_partial_context (diagnostic_context *context,
       xloc = expand_location (loc);
       if (t == NULL)
        break;
-      pp_verbatim (context->printer, "%s:%d:   instantiated from %qs\n",
+      pp_verbatim (context->printer, _("%s:%d:   instantiated from %qs\n"),
                   xloc.file, xloc.line,
                   decl_as_string (t->decl,
                                   TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
       loc = t->locus;
     }
-  pp_verbatim (context->printer, "%s:%d:   instantiated from here",
+  pp_verbatim (context->printer, _("%s:%d:   instantiated from here"),
               xloc.file, xloc.line);
   pp_base_newline (context->printer);
 }