X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=gcc%2Fcp%2Ferror.c;h=22c2d304d88ca02e84dfb14619d2a2a766fcd57e;hp=17dc1185cdbe34157f629d0f438ff93a261bde9b;hb=d65b3a4091670f1e49fadb3f1a0a336dd96ae7d7;hpb=6beb3f768f89ec3d5a2b29fa3cbb0bace1f630a1

diff --git a/gcc/cp/error.c b/gcc/cp/error.c
index 17dc1185cdb..22c2d304d88 100644
--- a/gcc/cp/error.c
+++ b/gcc/cp/error.c
@@ -1,7 +1,7 @@
 /* Call-backs for C++ error reporting.
    This code is non-reentrant.
    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002,
-   2003 Free Software Foundation, Inc.
+   2003, 2004, 2005 Free Software Foundation, Inc.
    This file is part of GCC.
 
 GCC is free software; you can redistribute it and/or modify
@@ -16,8 +16,8 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING.  If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA.  */
+the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA.  */
 
 #include "config.h"
 #include "system.h"
@@ -30,38 +30,18 @@ Boston, MA 02111-1307, USA.  */
 #include "flags.h"
 #include "diagnostic.h"
 #include "langhooks-def.h"
+#include "cxx-pretty-print.h"
 
-enum pad { none, before, after };
-
-#define sorry_for_unsupported_tree(T)                                      \
-   sorry ("`%s' not supported by %s", tree_code_name[(int) TREE_CODE (T)], \
-             __FUNCTION__)
-
-#define print_scope_operator(BUFFER)  output_add_string ((BUFFER), "::")
-#define print_left_paren(BUFFER)      output_add_character ((BUFFER), '(')
-#define print_right_paren(BUFFER)     output_add_character ((BUFFER), ')')
-#define print_left_bracket(BUFFER)    output_add_character ((BUFFER), '[')
-#define print_right_bracket(BUFFER)   output_add_character ((BUFFER), ']')
-#define print_template_argument_list_start(BUFFER) \
-   print_non_consecutive_character ((BUFFER), '<')
-#define print_template_argument_list_end(BUFFER)  \
-   print_non_consecutive_character ((BUFFER), '>')
-#define print_tree_identifier(BUFFER, TID) \
-   output_add_string ((BUFFER), IDENTIFIER_POINTER (TID))
-#define print_identifier(BUFFER, ID) output_add_string ((BUFFER), (ID))
-#define separate_with_comma(BUFFER) output_add_string ((BUFFER), ", ")
+#define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
 
 /* The global buffer where we dump everything.  It is there only for
    transitional purpose.  It is expected, in the near future, to be
    completely removed.  */
-static output_buffer scratch_buffer_rec;
-static output_buffer *scratch_buffer = &scratch_buffer_rec;
+static cxx_pretty_printer scratch_pretty_printer;
+#define cxx_pp (&scratch_pretty_printer)
 
 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
 
-#define reinit_global_formatting_buffer() \
-   output_clear_message_text (scratch_buffer)
-
 static const char *args_to_string (tree, int);
 static const char *assop_to_string (enum tree_code);
 static const char *code_to_string (enum tree_code);
@@ -83,16 +63,13 @@ static void dump_expr (tree, int);
 static void dump_unary_op (const char *, tree, int);
 static void dump_binary_op (const char *, tree, int);
 static void dump_aggr_type (tree, int);
-static enum pad dump_type_prefix (tree, int);
+static void dump_type_prefix (tree, int);
 static void dump_type_suffix (tree, int);
 static void dump_function_name (tree, int);
 static void dump_expr_list (tree, int);
 static void dump_global_iord (tree);
-static enum pad dump_qualifiers (tree, enum pad);
-static void dump_char (int);
 static void dump_parameters (tree, int);
 static void dump_exception_spec (tree, int);
-static const char *class_key_or_enum (tree);
 static void dump_template_argument (tree, int);
 static void dump_template_argument_list (tree, int);
 static void dump_template_parameter (tree, int);
@@ -104,14 +81,13 @@ static const char *function_category (tree);
 static void maybe_print_instantiation_context (diagnostic_context *);
 static void print_instantiation_full_context (diagnostic_context *);
 static void print_instantiation_partial_context (diagnostic_context *,
-                                                 tree, location_t);
+						 tree, location_t);
 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
 static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
 
-static bool cp_printer (output_buffer *, text_info *);
-static void print_non_consecutive_character (output_buffer *, int);
-static tree locate_error (const char *, va_list);
+static bool cp_printer (pretty_printer *, text_info *, const char *,
+			int, bool, bool, bool);
 static location_t location_of (tree);
 
 void
@@ -121,7 +97,8 @@ init_error (void)
   diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer;
   diagnostic_format_decoder (global_dc) = cp_printer;
 
-  init_output_buffer (scratch_buffer, /* prefix */NULL, /* line-width */0);
+  pp_construct (pp_base (cxx_pp), NULL, 0);
+  pp_cxx_pretty_printer_init (cxx_pp);
 }
 
 /* Dump a scope, if deemed necessary.  */
@@ -137,53 +114,21 @@ dump_scope (tree scope, int flags)
   if (TREE_CODE (scope) == NAMESPACE_DECL)
     {
       if (scope != global_namespace)
-        {
-          dump_decl (scope, f);
-          print_scope_operator (scratch_buffer);
-        }
+	{
+	  dump_decl (scope, f);
+	  pp_cxx_colon_colon (cxx_pp);
+	}
     }
   else if (AGGREGATE_TYPE_P (scope))
     {
       dump_type (scope, f);
-      print_scope_operator (scratch_buffer);
+      pp_cxx_colon_colon (cxx_pp);
     }
   else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
     {
       dump_function_decl (scope, f);
-      print_scope_operator (scratch_buffer);
-    }
-}
-
-/* Dump type qualifiers, providing padding as requested. Return an
-   indication of whether we dumped something.  */
-
-static enum pad
-dump_qualifiers (tree t, enum pad p)
-{
-  static const int masks[] =
-    {TYPE_QUAL_CONST, TYPE_QUAL_VOLATILE, TYPE_QUAL_RESTRICT};
-  static const char *const names[] =
-    {"const", "volatile", "__restrict"};
-  int ix;
-  int quals = TYPE_QUALS (t);
-  int do_after = p == after;
-
-  if (quals)
-    {
-      for (ix = 0; ix != 3; ix++)
-        if (masks[ix] & quals)
-          {
-            if (p == before)
-              output_add_space (scratch_buffer);
-            p = before;
-            print_identifier (scratch_buffer, names[ix]);
-          }
-      if (do_after)
-        output_add_space (scratch_buffer);
+      pp_cxx_colon_colon (cxx_pp);
     }
-  else
-    p = none;
-  return p;
 }
 
 /* Dump the template ARGument under control of FLAGS.  */
@@ -210,7 +155,7 @@ dump_template_argument_list (tree args, int flags)
   for (i = 0; i< n; ++i)
     {
       if (need_comma)
-        separate_with_comma (scratch_buffer);
+	pp_separate_with_comma (cxx_pp);
       dump_template_argument (TREE_VEC_ELT (args, i), flags);
       need_comma = 1;
     }
@@ -227,29 +172,28 @@ dump_template_parameter (tree parm, int flags)
   if (TREE_CODE (p) == TYPE_DECL)
     {
       if (flags & TFF_DECL_SPECIFIERS)
-        {
-          print_identifier (scratch_buffer, "class");
-          if (DECL_NAME (p))
-            {
-              output_add_space (scratch_buffer);
-              print_tree_identifier (scratch_buffer, DECL_NAME (p));
-            }
-        }
+	{
+	  pp_cxx_identifier (cxx_pp, "class");
+	  if (DECL_NAME (p))
+	    pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
+	}
       else if (DECL_NAME (p))
-        print_tree_identifier (scratch_buffer, DECL_NAME (p));
+	pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
       else
-        print_identifier (scratch_buffer, "{template default argument error}");
+	pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
     }
   else
     dump_decl (p, flags | TFF_DECL_SPECIFIERS);
 
   if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
     {
-      output_add_string (scratch_buffer, " = ");
+      pp_cxx_whitespace (cxx_pp);
+      pp_equal (cxx_pp);
+      pp_cxx_whitespace (cxx_pp);
       if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
-        dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
+	dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
       else
-        dump_expr (a, flags | TFF_EXPR_IN_PARENS);
+	dump_expr (a, flags | TFF_EXPR_IN_PARENS);
     }
 }
 
@@ -282,13 +226,15 @@ dump_template_bindings (tree parms, tree args)
 	    }
 
 	  if (need_comma)
-	    separate_with_comma (scratch_buffer);
+	    pp_separate_with_comma (cxx_pp);
 	  dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
-	  output_add_string (scratch_buffer, " = ");
+	  pp_cxx_whitespace (cxx_pp);
+	  pp_equal (cxx_pp);
+	  pp_cxx_whitespace (cxx_pp);
 	  if (arg)
 	    dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
 	  else
-	    print_identifier (scratch_buffer, "<missing>");
+	    pp_identifier (cxx_pp, "<missing>");
 
 	  ++arg_idx;
 	  need_comma = 1;
@@ -313,7 +259,7 @@ dump_type (tree t, int flags)
   switch (TREE_CODE (t))
     {
     case UNKNOWN_TYPE:
-      print_identifier (scratch_buffer, "<unknown type>");
+      pp_identifier (cxx_pp, "<unresolved overloaded function type>");
       break;
 
     case TREE_LIST:
@@ -322,10 +268,10 @@ dump_type (tree t, int flags)
       break;
 
     case IDENTIFIER_NODE:
-      print_tree_identifier (scratch_buffer, t);
+      pp_cxx_tree_identifier (cxx_pp, t);
       break;
 
-    case TREE_VEC:
+    case TREE_BINFO:
       dump_type (BINFO_TYPE (t), flags);
       break;
 
@@ -337,85 +283,53 @@ dump_type (tree t, int flags)
 
     case TYPE_DECL:
       if (flags & TFF_CHASE_TYPEDEF)
-        {
-          dump_type (DECL_ORIGINAL_TYPE (t)
-                     ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
-          break;
-        }
-      /* else fallthrough */
+	{
+	  dump_type (DECL_ORIGINAL_TYPE (t)
+		     ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
+	  break;
+	}
+      /* Else fall through.  */
 
     case TEMPLATE_DECL:
     case NAMESPACE_DECL:
       dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
       break;
 
-    case COMPLEX_TYPE:
-      output_add_string (scratch_buffer, "__complex__ ");
-      dump_type (TREE_TYPE (t), flags);
-      break;
-
-    case VECTOR_TYPE:
-      output_add_string (scratch_buffer, "__vector__ ");
-      {
-	/* The subtype of a VECTOR_TYPE is something like intQI_type_node,
-	   which has no name and is not very useful for diagnostics.  So
-	   look up the equivalent C type and print its name.  */
-	tree elt = TREE_TYPE (t);
-	elt = c_common_type_for_mode (TYPE_MODE (elt), TREE_UNSIGNED (elt));
-	dump_type (elt, flags);
-      }
-      break;
-
     case INTEGER_TYPE:
-      if (!TREE_UNSIGNED (TYPE_MAIN_VARIANT (t)) && TREE_UNSIGNED (t))
-	output_add_string (scratch_buffer, "unsigned ");
-      else if (TREE_UNSIGNED (TYPE_MAIN_VARIANT (t)) && !TREE_UNSIGNED (t))
-	output_add_string (scratch_buffer, "signed ");
-
-      /* fall through.  */
     case REAL_TYPE:
     case VOID_TYPE:
     case BOOLEAN_TYPE:
-      {
-	tree type;
-	dump_qualifiers (t, after);
-	type = flags & TFF_CHASE_TYPEDEF ? TYPE_MAIN_VARIANT (t) : t;
-	if (TYPE_NAME (type) && TYPE_IDENTIFIER (type))
-	  print_tree_identifier (scratch_buffer, TYPE_IDENTIFIER (type));
-	else
-	  /* Types like intQI_type_node and friends have no names.
-	     These don't come up in user error messages, but it's nice
-	     to be able to print them from the debugger.  */
-	  print_identifier (scratch_buffer, "<anonymous>");
-      }
+    case COMPLEX_TYPE:
+    case VECTOR_TYPE:
+      pp_type_specifier_seq (cxx_pp, t);
       break;
 
     case TEMPLATE_TEMPLATE_PARM:
       /* For parameters inside template signature.  */
       if (TYPE_IDENTIFIER (t))
-	print_tree_identifier (scratch_buffer, TYPE_IDENTIFIER (t));
+	pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
       else
-	print_identifier
-          (scratch_buffer, "<anonymous template template parameter>");
+	pp_cxx_canonical_template_parameter (cxx_pp, t);
       break;
 
     case BOUND_TEMPLATE_TEMPLATE_PARM:
       {
 	tree args = TYPE_TI_ARGS (t);
-	print_tree_identifier (scratch_buffer, TYPE_IDENTIFIER (t));
-	print_template_argument_list_start (scratch_buffer);
-        dump_template_argument_list (args, flags);
-	print_template_argument_list_end (scratch_buffer);
+	pp_cxx_cv_qualifier_seq (cxx_pp, t);
+	pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
+	pp_cxx_begin_template_argument_list (cxx_pp);
+	dump_template_argument_list (args, flags);
+	pp_cxx_end_template_argument_list (cxx_pp);
       }
       break;
 
     case TEMPLATE_TYPE_PARM:
-      dump_qualifiers (t, after);
+      pp_cxx_cv_qualifier_seq (cxx_pp, t);
       if (TYPE_IDENTIFIER (t))
-	print_tree_identifier (scratch_buffer, TYPE_IDENTIFIER (t));
+	pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
       else
-	print_identifier
-          (scratch_buffer, "<anonymous template type parameter>");
+	pp_cxx_canonical_template_parameter
+	  (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
       break;
 
       /* This is not always necessary for pointers and such, but doing this
@@ -433,30 +347,35 @@ dump_type (tree t, int flags)
       break;
     }
     case TYPENAME_TYPE:
-      dump_qualifiers (t, after);
-      output_add_string (scratch_buffer, "typename ");
+      pp_cxx_cv_qualifier_seq (cxx_pp, t);
+      pp_cxx_identifier (cxx_pp,
+			 TYPENAME_IS_ENUM_P (t) ? "enum"
+			 : TYPENAME_IS_CLASS_P (t) ? "class"
+			 : "typename");
       dump_typename (t, flags);
       break;
 
     case UNBOUND_CLASS_TEMPLATE:
       dump_type (TYPE_CONTEXT (t), flags);
-      print_scope_operator (scratch_buffer);
-      print_identifier (scratch_buffer, "template ");
+      pp_cxx_colon_colon (cxx_pp);
+      pp_cxx_identifier (cxx_pp, "template");
       dump_type (DECL_NAME (TYPE_NAME (t)), flags);
       break;
 
     case TYPEOF_TYPE:
-      output_add_string (scratch_buffer, "__typeof (");
-      dump_expr (TYPE_FIELDS (t), flags & ~TFF_EXPR_IN_PARENS);
-      print_right_paren (scratch_buffer);
+      pp_cxx_identifier (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);
+      pp_cxx_right_paren (cxx_pp);
       break;
 
     default:
-      sorry_for_unsupported_tree (t);
+      pp_unsupported_tree (cxx_pp, t);
       /* Fall through to error.  */
 
     case ERROR_MARK:
-      print_identifier (scratch_buffer, "<type error>");
+      pp_identifier (cxx_pp, "<type error>");
       break;
     }
 }
@@ -473,14 +392,14 @@ dump_typename (tree t, int flags)
     dump_typename (ctx, flags);
   else
     dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
-  print_scope_operator (scratch_buffer);
+  pp_cxx_colon_colon (cxx_pp);
   dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
 }
 
 /* Return the name of the supplied aggregate, or enumeral type.  */
 
-static const char *
-class_key_or_enum (tree t)
+const char *
+class_key_or_enum_as_string (tree t)
 {
   if (TREE_CODE (t) == ENUMERAL_TYPE)
     return "enum";
@@ -499,17 +418,14 @@ static void
 dump_aggr_type (tree t, int flags)
 {
   tree name;
-  const char *variety = class_key_or_enum (t);
+  const char *variety = class_key_or_enum_as_string (t);
   int typdef = 0;
   int tmplate = 0;
 
-  dump_qualifiers (t, after);
+  pp_cxx_cv_qualifier_seq (cxx_pp, t);
 
   if (flags & TFF_CLASS_KEY_OR_ENUM)
-    {
-      print_identifier (scratch_buffer, variety);
-      output_add_space (scratch_buffer);
-    }
+    pp_cxx_identifier (cxx_pp, variety);
 
   if (flags & TFF_CHASE_TYPEDEF)
     t = TYPE_MAIN_VARIANT (t);
@@ -520,38 +436,36 @@ dump_aggr_type (tree t, int flags)
     {
       typdef = !DECL_ARTIFICIAL (name);
       tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
-                && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
-                && (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
-                    || TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
-                    || DECL_TEMPLATE_SPECIALIZATION (CLASSTYPE_TI_TEMPLATE (t))
-                    || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
+		&& TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
+		&& (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
+		    || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
       dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
       if (tmplate)
-        {
-          /* Because the template names are mangled, we have to locate
-             the most general template, and use that name.  */
-          tree tpl = CLASSTYPE_TI_TEMPLATE (t);
-
-          while (DECL_TEMPLATE_INFO (tpl))
-            tpl = DECL_TI_TEMPLATE (tpl);
-          name = tpl;
-        }
+	{
+	  /* Because the template names are mangled, we have to locate
+	     the most general template, and use that name.  */
+	  tree tpl = CLASSTYPE_TI_TEMPLATE (t);
+
+	  while (DECL_TEMPLATE_INFO (tpl))
+	    tpl = DECL_TI_TEMPLATE (tpl);
+	  name = tpl;
+	}
       name = DECL_NAME (name);
     }
 
   if (name == 0 || ANON_AGGRNAME_P (name))
     {
       if (flags & TFF_CLASS_KEY_OR_ENUM)
-        print_identifier (scratch_buffer, "<anonymous>");
+	pp_identifier (cxx_pp, "<anonymous>");
       else
-        output_printf (scratch_buffer, "<anonymous %s>", variety);
+	pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety);
     }
   else
-    print_tree_identifier (scratch_buffer, name);
+    pp_cxx_tree_identifier (cxx_pp, name);
   if (tmplate)
     dump_template_parms (TYPE_TEMPLATE_INFO (t),
-                         !CLASSTYPE_USE_TEMPLATE (t),
-                         flags & ~TFF_TEMPLATE_HEADER);
+			 !CLASSTYPE_USE_TEMPLATE (t),
+			 flags & ~TFF_TEMPLATE_HEADER);
 }
 
 /* Dump into the obstack the initial part of the output for a given type.
@@ -563,16 +477,11 @@ dump_aggr_type (tree t, int flags)
    deal with prefix and suffix.
 
    Arrays must also do this for DECL nodes, like int a[], and for things like
-   int *[]&.
-
-   Return indicates how you should pad an object name after this. I.e. you
-   want to pad non-*, non-& cores, but not pad * or & types.  */
+   int *[]&.  */
 
-static enum pad
+static void
 dump_type_prefix (tree t, int flags)
 {
-  enum pad padding = before;
-
   if (TYPE_PTRMEMFUNC_P (t))
     {
       t = TYPE_PTRMEMFUNC_FN_TYPE (t);
@@ -586,59 +495,52 @@ dump_type_prefix (tree t, int flags)
       {
 	tree sub = TREE_TYPE (t);
 
-	padding = dump_type_prefix (sub, flags);
-	/* A tree for a member pointer looks like pointer to offset,
-	   so let the OFFSET_TYPE case handle it.  */
-	if (!TYPE_PTRMEM_P (t))
+	dump_type_prefix (sub, flags);
+	if (TREE_CODE (sub) == ARRAY_TYPE)
 	  {
-	    if (TREE_CODE (sub) == ARRAY_TYPE)
-              {
-                output_add_space (scratch_buffer);
-                print_left_paren (scratch_buffer);
-              }
-            output_add_character
-              (scratch_buffer, "&*"[TREE_CODE (t) == POINTER_TYPE]);
-	    padding = dump_qualifiers (t, before);
+	    pp_cxx_whitespace (cxx_pp);
+	    pp_cxx_left_paren (cxx_pp);
 	  }
+	pp_character (cxx_pp, "&*"[TREE_CODE (t) == POINTER_TYPE]);
+	pp_base (cxx_pp)->padding = pp_before;
+	pp_cxx_cv_qualifier_seq (cxx_pp, t);
       }
       break;
 
     case OFFSET_TYPE:
     offset_type:
-      padding = dump_type_prefix (TREE_TYPE (t), flags);
+      dump_type_prefix (TREE_TYPE (t), flags);
       if (TREE_CODE (t) == OFFSET_TYPE)	/* pmfs deal with this in d_t_p */
 	{
-	  if (padding != none)
-	    output_add_space (scratch_buffer);
+	  pp_maybe_space (cxx_pp);
+	  if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
+	     pp_cxx_left_paren (cxx_pp);
 	  dump_type (TYPE_OFFSET_BASETYPE (t), flags);
-	  print_scope_operator (scratch_buffer);
+	  pp_cxx_colon_colon (cxx_pp);
 	}
-      output_add_character (scratch_buffer, '*');
-      padding = dump_qualifiers (t, none);
+      pp_cxx_star (cxx_pp);
+      pp_cxx_cv_qualifier_seq (cxx_pp, t);
+      pp_base (cxx_pp)->padding = pp_before;
       break;
 
       /* Can only be reached through function pointer -- this would not be
-         correct if FUNCTION_DECLs used it.  */
+	 correct if FUNCTION_DECLs used it.  */
     case FUNCTION_TYPE:
-      padding = dump_type_prefix (TREE_TYPE (t), flags);
-      if (padding != none)
-        output_add_space (scratch_buffer);
-      print_left_paren (scratch_buffer);
-      padding = none;
+      dump_type_prefix (TREE_TYPE (t), flags);
+      pp_maybe_space (cxx_pp);
+      pp_cxx_left_paren (cxx_pp);
       break;
 
     case METHOD_TYPE:
-      padding = dump_type_prefix (TREE_TYPE (t), flags);
-      if (padding != none)
-        output_add_space (scratch_buffer);
-      print_left_paren (scratch_buffer);
-      padding = none;
+      dump_type_prefix (TREE_TYPE (t), flags);
+      pp_maybe_space (cxx_pp);
+      pp_cxx_left_paren (cxx_pp);
       dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
-      print_scope_operator (scratch_buffer);
+      pp_cxx_colon_colon (cxx_pp);
       break;
 
     case ARRAY_TYPE:
-      padding = dump_type_prefix (TREE_TYPE (t), flags);
+      dump_type_prefix (TREE_TYPE (t), flags);
       break;
 
     case ENUMERAL_TYPE:
@@ -661,17 +563,16 @@ dump_type_prefix (tree t, int flags)
     case VECTOR_TYPE:
     case TYPEOF_TYPE:
       dump_type (t, flags);
-      padding = before;
+      pp_base (cxx_pp)->padding = pp_before;
       break;
 
     default:
-      sorry_for_unsupported_tree (t);
+      pp_unsupported_tree (cxx_pp, t);
       /* fall through.  */
     case ERROR_MARK:
-      print_identifier (scratch_buffer, "<typeprefixerror>");
+      pp_identifier (cxx_pp, "<typeprefixerror>");
       break;
     }
-  return padding;
 }
 
 /* Dump the suffix of type T, under control of FLAGS.  This is the part
@@ -689,16 +590,16 @@ dump_type_suffix (tree t, int flags)
     case REFERENCE_TYPE:
     case OFFSET_TYPE:
       if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
-	print_right_paren (scratch_buffer);
+	pp_cxx_right_paren (cxx_pp);
       dump_type_suffix (TREE_TYPE (t), flags);
       break;
 
-      /* Can only be reached through function pointer */
+      /* Can only be reached through function pointer.  */
     case FUNCTION_TYPE:
     case METHOD_TYPE:
       {
 	tree arg;
-        print_right_paren (scratch_buffer);
+	pp_cxx_right_paren (cxx_pp);
 	arg = TYPE_ARG_TYPES (t);
 	if (TREE_CODE (t) == METHOD_TYPE)
 	  arg = TREE_CHAIN (arg);
@@ -708,31 +609,33 @@ dump_type_suffix (tree t, int flags)
 	dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
 
 	if (TREE_CODE (t) == METHOD_TYPE)
-	  dump_qualifiers
-	    (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), before);
+	  pp_cxx_cv_qualifier_seq
+	    (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
+	else
+	  pp_cxx_cv_qualifier_seq(cxx_pp, t);
 	dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
 	dump_type_suffix (TREE_TYPE (t), flags);
 	break;
       }
 
     case ARRAY_TYPE:
-      print_left_bracket (scratch_buffer);
+      pp_maybe_space (cxx_pp);
+      pp_cxx_left_bracket (cxx_pp);
       if (TYPE_DOMAIN (t))
 	{
 	  if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0))
-	    output_host_wide_integer
-              (scratch_buffer,
-               tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1);
+	    pp_wide_integer
+	      (cxx_pp, tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1);
 	  else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR)
 	    dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0),
-	               flags & ~TFF_EXPR_IN_PARENS);
+		       flags & ~TFF_EXPR_IN_PARENS);
 	  else
 	    dump_expr (fold (cp_build_binary_op
 			     (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)),
 			      integer_one_node)),
-	               flags & ~TFF_EXPR_IN_PARENS);
+		       flags & ~TFF_EXPR_IN_PARENS);
 	}
-      print_right_bracket (scratch_buffer);
+      pp_cxx_right_bracket (cxx_pp);
       dump_type_suffix (TREE_TYPE (t), flags);
       break;
 
@@ -758,10 +661,10 @@ dump_type_suffix (tree t, int flags)
       break;
 
     default:
-      sorry_for_unsupported_tree (t);
+      pp_unsupported_tree (cxx_pp, t);
     case ERROR_MARK:
       /* Don't mark it here, we should have already done in
-         dump_type_prefix.  */
+	 dump_type_prefix.  */
       break;
     }
 }
@@ -776,9 +679,9 @@ dump_global_iord (tree t)
   else if (DECL_GLOBAL_DTOR_P (t))
     p = "destructors";
   else
-    abort ();
+    gcc_unreachable ();
 
-  output_printf (scratch_buffer, "(static %s for %s)", p, input_filename);
+  pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename);
 }
 
 static void
@@ -786,15 +689,15 @@ dump_simple_decl (tree t, tree type, int flags)
 {
   if (flags & TFF_DECL_SPECIFIERS)
     {
-      if (dump_type_prefix (type, flags) != none)
-        output_add_space (scratch_buffer);
+      dump_type_prefix (type, flags);
+      pp_maybe_space (cxx_pp);
     }
   if (!DECL_INITIAL (t) || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX)
     dump_scope (CP_DECL_CONTEXT (t), flags);
   if (DECL_NAME (t))
     dump_decl (DECL_NAME (t), flags);
   else
-    print_identifier (scratch_buffer, "<anonymous>");
+    pp_identifier (cxx_pp, "<anonymous>");
   if (flags & TFF_DECL_SPECIFIERS)
     dump_type_suffix (type, flags);
 }
@@ -810,64 +713,65 @@ dump_decl (tree t, int flags)
   switch (TREE_CODE (t))
     {
     case TYPE_DECL:
-      {
-	/* Don't say 'typedef class A' */
-        if (DECL_ARTIFICIAL (t))
-	  {
-	    if ((flags & TFF_DECL_SPECIFIERS)
-	        && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
-	      /* Say `class T' not just `T'.  */
-	      output_add_string (scratch_buffer, "class ");
+      /* Don't say 'typedef class A' */
+      if (DECL_ARTIFICIAL (t))
+	{
+	  if ((flags & TFF_DECL_SPECIFIERS)
+	      && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
+	    /* Say `class T' not just `T'.  */
+	    pp_cxx_identifier (cxx_pp, "class");
 
-	    dump_type (TREE_TYPE (t), flags);
-	    break;
-	  }
-      }
+	  dump_type (TREE_TYPE (t), flags);
+	  break;
+	}
       if (flags & TFF_DECL_SPECIFIERS)
-	output_add_string (scratch_buffer, "typedef ");
+	pp_cxx_identifier (cxx_pp, "typedef");
       dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
 			? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
-	                flags);
+			flags);
       break;
 
     case VAR_DECL:
       if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
 	{
-	  output_add_string (scratch_buffer, "vtable for ");
-	  my_friendly_assert (TYPE_P (DECL_CONTEXT (t)), 20010720);
+	  pp_string (cxx_pp, "vtable for ");
+	  gcc_assert (TYPE_P (DECL_CONTEXT (t)));
 	  dump_type (DECL_CONTEXT (t), flags);
 	  break;
 	}
-      /* else fall through */
+      /* Else fall through.  */
     case FIELD_DECL:
     case PARM_DECL:
       dump_simple_decl (t, TREE_TYPE (t), flags);
       break;
 
     case RESULT_DECL:
-      output_add_string (scratch_buffer, "<return value> ");
+      pp_string (cxx_pp, "<return value> ");
       dump_simple_decl (t, TREE_TYPE (t), flags);
       break;
 
     case NAMESPACE_DECL:
-      dump_scope (CP_DECL_CONTEXT (t), flags);
-      if (DECL_NAME (t) == anonymous_namespace_name)
-	print_identifier (scratch_buffer, "<unnamed>");
+      if (flags & TFF_DECL_SPECIFIERS)
+	pp_cxx_declaration (cxx_pp, t);
       else
-	print_tree_identifier (scratch_buffer, DECL_NAME (t));
+	{
+	  dump_scope (CP_DECL_CONTEXT (t), flags);
+	  if (DECL_NAME (t) == NULL_TREE)
+	    pp_identifier (cxx_pp, "<unnamed>");
+	  else
+	    pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
+	}
       break;
 
     case SCOPE_REF:
-      dump_decl (TREE_OPERAND (t, 0), flags & ~TFF_DECL_SPECIFIERS);
-      print_scope_operator (scratch_buffer); 
-      dump_decl (TREE_OPERAND (t, 1), flags);
+      pp_expression (cxx_pp, t);
       break;
 
     case ARRAY_REF:
       dump_decl (TREE_OPERAND (t, 0), flags);
-      print_left_bracket (scratch_buffer);
+      pp_cxx_left_bracket (cxx_pp);
       dump_decl (TREE_OPERAND (t, 1), flags);
-      print_right_bracket (scratch_buffer);
+      pp_cxx_right_bracket (cxx_pp);
       break;
 
       /* So that we can do dump_decl on an aggr type.  */
@@ -879,13 +783,13 @@ dump_decl (tree t, int flags)
 
     case BIT_NOT_EXPR:
       /* This is a pseudo destructor call which has not been folded into
-         a PSEUDO_DTOR_EXPR yet.  */
-      output_add_character (scratch_buffer, '~');
+	 a PSEUDO_DTOR_EXPR yet.  */
+      pp_cxx_complement (cxx_pp);
       dump_type (TREE_OPERAND (t, 0), flags);
       break;
 
     case TYPE_EXPR:
-      abort ();
+      gcc_unreachable ();
       break;
 
       /* These special cases are duplicated here so that other functions
@@ -893,13 +797,13 @@ dump_decl (tree t, int flags)
     case IDENTIFIER_NODE:
       if (IDENTIFIER_TYPENAME_P (t))
 	{
-	  output_add_string (scratch_buffer, "operator ");
+	  pp_cxx_identifier (cxx_pp, "operator");
 	  /* Not exactly IDENTIFIER_TYPE_VALUE.  */
 	  dump_type (TREE_TYPE (t), flags);
 	  break;
 	}
       else
-	print_tree_identifier (scratch_buffer, t);
+	pp_cxx_tree_identifier (cxx_pp, t);
       break;
 
     case OVERLOAD:
@@ -909,29 +813,29 @@ dump_decl (tree t, int flags)
 	  if (DECL_CLASS_SCOPE_P (t))
 	    {
 	      dump_type (DECL_CONTEXT (t), flags);
-	      output_add_string (scratch_buffer, "::");
+	      pp_cxx_colon_colon (cxx_pp);
 	    }
 	  else if (DECL_CONTEXT (t))
 	    {
 	      dump_decl (DECL_CONTEXT (t), flags);
-	      output_add_string (scratch_buffer, "::");
+	      pp_cxx_colon_colon (cxx_pp);
 	    }
 	  dump_decl (DECL_NAME (t), flags);
 	  break;
 	}
-      
+
       /* If there's only one function, just treat it like an ordinary
 	 FUNCTION_DECL.  */
       t = OVL_CURRENT (t);
       /* Fall through.  */
 
     case FUNCTION_DECL:
-      if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
+      if (! DECL_LANG_SPECIFIC (t))
+	pp_identifier (cxx_pp, "<built-in>");
+      else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
 	dump_global_iord (t);
-      else if (! DECL_LANG_SPECIFIC (t))
-	print_identifier (scratch_buffer, "<internal>");
       else
-        dump_function_decl (t, flags);
+	dump_function_decl (t, flags);
       break;
 
     case TEMPLATE_DECL:
@@ -940,28 +844,20 @@ dump_decl (tree t, int flags)
 
     case TEMPLATE_ID_EXPR:
       {
-	tree args;
 	tree name = TREE_OPERAND (t, 0);
+
 	if (is_overloaded_fn (name))
 	  name = DECL_NAME (get_first_fn (name));
 	dump_decl (name, flags);
-	print_template_argument_list_start (scratch_buffer);
-	for (args = TREE_OPERAND (t, 1); args; args = TREE_CHAIN (args))
-	  {
-	    dump_template_argument (TREE_VALUE (args), flags);
-	    if (TREE_CHAIN (args))
-	      separate_with_comma (scratch_buffer);
-	  }
-	print_template_argument_list_end (scratch_buffer);
+	pp_cxx_begin_template_argument_list (cxx_pp);
+	if (TREE_OPERAND (t, 1))
+	  dump_template_argument_list (TREE_OPERAND (t, 1), flags);
+	pp_cxx_end_template_argument_list (cxx_pp);
       }
       break;
 
-    case LOOKUP_EXPR:
-      dump_decl (TREE_OPERAND (t, 0), flags);
-      break;
-
     case LABEL_DECL:
-      print_tree_identifier (scratch_buffer, DECL_NAME (t));
+      pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
       break;
 
     case CONST_DECL:
@@ -974,13 +870,13 @@ dump_decl (tree t, int flags)
       else if (DECL_INITIAL (t))
 	dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
       else
-	print_identifier (scratch_buffer, "<enumerator>");
+	pp_identifier (cxx_pp, "<enumerator>");
       break;
 
     case USING_DECL:
-      output_add_string (scratch_buffer, "using ");
-      dump_type (DECL_INITIAL (t), flags);
-      print_scope_operator (scratch_buffer);
+      pp_cxx_identifier (cxx_pp, "using");
+      dump_type (USING_DECL_SCOPE (t), flags);
+      pp_cxx_colon_colon (cxx_pp);
       dump_decl (DECL_NAME (t), flags);
       break;
 
@@ -988,12 +884,23 @@ dump_decl (tree t, int flags)
       dump_decl (BASELINK_FUNCTIONS (t), flags);
       break;
 
+    case NON_DEPENDENT_EXPR:
+      dump_expr (t, flags);
+      break;
+
+    case TEMPLATE_TYPE_PARM:
+      if (flags & TFF_DECL_SPECIFIERS)
+	pp_cxx_declaration (cxx_pp, t);
+      else
+	pp_type_id (cxx_pp, t);
+      break;
+
     default:
-      sorry_for_unsupported_tree (t);
-      /* Fallthrough to error.  */
+      pp_unsupported_tree (cxx_pp, t);
+      /* Fall through to error.  */
 
     case ERROR_MARK:
-      print_identifier (scratch_buffer, "<declaration error>");
+      pp_identifier (cxx_pp, "<declaration error>");
       break;
     }
 }
@@ -1011,54 +918,57 @@ dump_template_decl (tree t, int flags)
   if (flags & TFF_TEMPLATE_HEADER)
     {
       for (parms = orig_parms = nreverse (orig_parms);
-           parms;
-           parms = TREE_CHAIN (parms))
-        {
+	   parms;
+	   parms = TREE_CHAIN (parms))
+	{
 	  tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
-          int len = TREE_VEC_LENGTH (inner_parms);
+	  int len = TREE_VEC_LENGTH (inner_parms);
 
-          output_add_string (scratch_buffer, "template<");
+	  pp_cxx_identifier (cxx_pp, "template");
+	  pp_cxx_begin_template_argument_list (cxx_pp);
 
 	  /* If we've shown the template prefix, we'd better show the
 	     parameters' and decl's type too.  */
 	    flags |= TFF_DECL_SPECIFIERS;
 
-          for (i = 0; i < len; i++)
-            {
-              if (i)
-                separate_with_comma (scratch_buffer);
-              dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
-            }
-          print_template_argument_list_end (scratch_buffer);
-          output_add_space (scratch_buffer);
-        }
+	  for (i = 0; i < len; i++)
+	    {
+	      if (i)
+		pp_separate_with_comma (cxx_pp);
+	      dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
+	    }
+	  pp_cxx_end_template_argument_list (cxx_pp);
+	  pp_cxx_whitespace (cxx_pp);
+	}
       nreverse(orig_parms);
 
       if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
 	/* Say `template<arg> class TT' not just `template<arg> TT'.  */
-	output_add_string (scratch_buffer, "class ");
+	pp_cxx_identifier (cxx_pp, "class");
     }
 
   if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
     dump_type (TREE_TYPE (t),
-               ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
-                | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
+	       ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
+		| (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
   else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
     dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
-  else if (TREE_TYPE (t) == NULL_TREE)
-    abort ();
   else
-    switch (NEXT_CODE (t))
     {
-      case METHOD_TYPE:
-      case FUNCTION_TYPE:
-        dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
-        break;
-      default:
-        /* This case can occur with some invalid code.  */
-        dump_type (TREE_TYPE (t),
-                   (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
-                   | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0));
+      gcc_assert (TREE_TYPE (t));
+      switch (NEXT_CODE (t))
+	{
+	case METHOD_TYPE:
+	case FUNCTION_TYPE:
+	  dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
+	  break;
+	default:
+	  /* This case can occur with some invalid code.  */
+	  dump_type (TREE_TYPE (t),
+		     (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
+		     | (flags & TFF_DECL_SPECIFIERS
+			? TFF_CLASS_KEY_OR_ENUM : 0));
+	}
     }
 }
 
@@ -1099,48 +1009,51 @@ dump_function_decl (tree t, int flags)
 
   if (DECL_CLASS_SCOPE_P (t))
     cname = DECL_CONTEXT (t);
-  /* this is for partially instantiated template methods */
+  /* This is for partially instantiated template methods.  */
   else if (TREE_CODE (fntype) == METHOD_TYPE)
     cname = TREE_TYPE (TREE_VALUE (parmtypes));
 
   if (!(flags & TFF_DECL_SPECIFIERS))
     /* OK */;
   else if (DECL_STATIC_FUNCTION_P (t))
-    print_identifier (scratch_buffer, "static ");
+    pp_cxx_identifier (cxx_pp, "static");
   else if (DECL_VIRTUAL_P (t))
-    print_identifier (scratch_buffer, "virtual ");
+    pp_cxx_identifier (cxx_pp, "virtual");
 
   /* Print the return type?  */
   if (show_return)
     show_return = !DECL_CONV_FN_P (t)  && !DECL_CONSTRUCTOR_P (t)
-                  && !DECL_DESTRUCTOR_P (t);
+		  && !DECL_DESTRUCTOR_P (t);
   if (show_return)
-    {
-      dump_type_prefix (TREE_TYPE (fntype), flags);
-      output_add_space (scratch_buffer);
-    }
+    dump_type_prefix (TREE_TYPE (fntype), flags);
 
   /* Print the function name.  */
   if (cname)
     {
       dump_type (cname, flags);
-      print_scope_operator (scratch_buffer);
+      pp_cxx_colon_colon (cxx_pp);
     }
   else
     dump_scope (CP_DECL_CONTEXT (t), flags);
 
   dump_function_name (t, flags);
 
-  if (1)
+  if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
     {
       dump_parameters (parmtypes, flags);
 
       if (TREE_CODE (fntype) == METHOD_TYPE)
-	dump_qualifiers (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))),
-			 before);
+	{
+	  pp_base (cxx_pp)->padding = pp_before;
+	  pp_cxx_cv_qualifier_seq
+	    (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
+	}
 
       if (flags & TFF_EXCEPTION_SPECIFICATION)
-	dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
+	{
+	  pp_base (cxx_pp)->padding = pp_before;
+	  dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
+	}
 
       if (show_return)
 	dump_type_suffix (TREE_TYPE (fntype), flags);
@@ -1149,9 +1062,12 @@ dump_function_decl (tree t, int flags)
   /* If T is a template instantiation, dump the parameter binding.  */
   if (template_parms != NULL_TREE && template_args != NULL_TREE)
     {
-      output_add_string (scratch_buffer, " [with ");
+      pp_cxx_whitespace (cxx_pp);
+      pp_cxx_left_bracket (cxx_pp);
+      pp_cxx_identifier (cxx_pp, "with");
+      pp_cxx_whitespace (cxx_pp);
       dump_template_bindings (template_parms, template_args);
-      print_right_bracket (scratch_buffer);
+      pp_cxx_right_bracket (cxx_pp);
     }
 }
 
@@ -1164,29 +1080,31 @@ dump_parameters (tree parmtypes, int flags)
 {
   int first;
 
-  print_left_paren (scratch_buffer);
+  pp_cxx_left_paren (cxx_pp);
 
   for (first = 1; parmtypes != void_list_node;
        parmtypes = TREE_CHAIN (parmtypes))
     {
       if (!first)
-        separate_with_comma (scratch_buffer);
+	pp_separate_with_comma (cxx_pp);
       first = 0;
       if (!parmtypes)
-        {
-          print_identifier (scratch_buffer, "...");
-          break;
-        }
+	{
+	  pp_cxx_identifier (cxx_pp, "...");
+	  break;
+	}
       dump_type (TREE_VALUE (parmtypes), flags);
 
       if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
-        {
-          output_add_string (scratch_buffer, " = ");
-          dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
-        }
+	{
+	  pp_cxx_whitespace (cxx_pp);
+	  pp_equal (cxx_pp);
+	  pp_cxx_whitespace (cxx_pp);
+	  dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
+	}
     }
 
-  print_right_paren (scratch_buffer);
+  pp_cxx_right_paren (cxx_pp);
 }
 
 /* Print an exception specification. T is the exception specification.  */
@@ -1196,17 +1114,19 @@ dump_exception_spec (tree t, int flags)
 {
   if (t)
     {
-      output_add_string (scratch_buffer, " throw (");
+      pp_cxx_identifier (cxx_pp, "throw");
+      pp_cxx_whitespace (cxx_pp);
+      pp_cxx_left_paren (cxx_pp);
       if (TREE_VALUE (t) != NULL_TREE)
-        while (1)
-          {
-            dump_type (TREE_VALUE (t), flags);
-            t = TREE_CHAIN (t);
-            if (!t)
-              break;
-            separate_with_comma (scratch_buffer);
-          }
-      print_right_paren (scratch_buffer);
+	while (1)
+	  {
+	    dump_type (TREE_VALUE (t), flags);
+	    t = TREE_CHAIN (t);
+	    if (!t)
+	      break;
+	    pp_separate_with_comma (cxx_pp);
+	  }
+      pp_cxx_right_paren (cxx_pp);
     }
 }
 
@@ -1218,6 +1138,17 @@ dump_function_name (tree t, int flags)
 {
   tree name = DECL_NAME (t);
 
+  /* We can get here with a decl that was synthesized by language-
+     independent machinery (e.g. coverage.c) in which case it won't
+     have a lang_specific structure attached and DECL_CONSTRUCTOR_P
+     will crash.  In this case it is safe just to print out the
+     literal name.  */
+  if (!DECL_LANG_SPECIFIC (t))
+    {
+      pp_cxx_tree_identifier (cxx_pp, name);
+      return;
+    }
+
   if (TREE_CODE (t) == TEMPLATE_DECL)
     t = DECL_TEMPLATE_RESULT (t);
 
@@ -1228,7 +1159,7 @@ dump_function_name (tree t, int flags)
 
   if (DECL_DESTRUCTOR_P (t))
     {
-      output_add_character (scratch_buffer, '~');
+      pp_cxx_complement (cxx_pp);
       dump_decl (name, TFF_PLAIN_IDENTIFIER);
     }
   else if (DECL_CONV_FN_P (t))
@@ -1239,19 +1170,17 @@ 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.  */
-      output_add_string (scratch_buffer, "operator ");
+      pp_cxx_identifier (cxx_pp, "operator");
       dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
     }
   else if (IDENTIFIER_OPNAME_P (name))
-    print_tree_identifier (scratch_buffer, name);
+    pp_cxx_tree_identifier (cxx_pp, name);
   else
     dump_decl (name, flags);
 
-  if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
+  if (DECL_TEMPLATE_INFO (t)
       && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
-      && (DECL_TEMPLATE_SPECIALIZATION (t)
-	  || TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
-	  || DECL_TEMPLATE_SPECIALIZATION (DECL_TI_TEMPLATE (t))
+      && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
 	  || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
     dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
 }
@@ -1270,48 +1199,31 @@ dump_template_parms (tree info, int primary, int flags)
   if (primary && flags & TFF_TEMPLATE_NAME)
     return;
   flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
-  print_template_argument_list_start (scratch_buffer);
+  pp_cxx_begin_template_argument_list (cxx_pp);
 
   /* Be careful only to print things when we have them, so as not
 	 to crash producing error messages.  */
   if (args && !primary)
     {
-      int len = 0;
-      int ix = 0;
-      int need_comma = 0;
-
-      if (TREE_CODE (args) == TREE_VEC)
-        {
-          if (TREE_VEC_LENGTH (args) > 0
-	      && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
-	    args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
-
-          len = TREE_VEC_LENGTH (args);
-        }
-      else if (TREE_CODE (args) == TREE_LIST)
-        len = -1;
-      while (ix != len && args)
-        {
-          tree arg;
-          if (len >= 0)
-            {
-              arg = TREE_VEC_ELT (args, ix);
-              ix++;
-            }
-          else
-            {
-              arg = TREE_VALUE (args);
-              args = TREE_CHAIN (args);
-            }
-          if (need_comma)
-            separate_with_comma (scratch_buffer);
-          
-          if (!arg)
-            print_identifier (scratch_buffer, "<template parameter error>");
-          else
-            dump_template_argument (arg, flags);
-          need_comma = 1;
-        }
+      int len, ix;
+
+      if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
+	args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
+
+      len = TREE_VEC_LENGTH (args);
+
+      for (ix = 0; ix != len; ix++)
+	{
+	  tree arg = TREE_VEC_ELT (args, ix);
+
+	  if (ix)
+	    pp_separate_with_comma (cxx_pp);
+
+	  if (!arg)
+	    pp_identifier (cxx_pp, "<template parameter error>");
+	  else
+	    dump_template_argument (arg, flags);
+	}
     }
   else if (primary)
     {
@@ -1323,76 +1235,49 @@ dump_template_parms (tree info, int primary, int flags)
       len = parms ? TREE_VEC_LENGTH (parms) : 0;
 
       for (ix = 0; ix != len; ix++)
-        {
-          tree parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
+	{
+	  tree parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
 
-          if (ix)
-            separate_with_comma (scratch_buffer);
+	  if (ix)
+	    pp_separate_with_comma (cxx_pp);
 
-          dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
-        }
+	  dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
+	}
     }
-  print_template_argument_list_end (scratch_buffer);
+  pp_cxx_end_template_argument_list (cxx_pp);
 }
 
+/* Print out a list of initializers (subr of dump_expr).  */
+
 static void
-dump_char (int c)
+dump_expr_list (tree l, int flags)
 {
-  switch (c)
+  while (l)
     {
-    case TARGET_NEWLINE:
-      output_add_string (scratch_buffer, "\\n");
-      break;
-    case TARGET_TAB:
-      output_add_string (scratch_buffer, "\\t");
-      break;
-    case TARGET_VT:
-      output_add_string (scratch_buffer, "\\v");
-      break;
-    case TARGET_BS:
-      output_add_string (scratch_buffer, "\\b");
-      break;
-    case TARGET_CR:
-      output_add_string (scratch_buffer, "\\r");
-      break;
-    case TARGET_FF:
-      output_add_string (scratch_buffer, "\\f");
-      break;
-    case TARGET_BELL:
-      output_add_string (scratch_buffer, "\\a");
-      break;
-    case '\\':
-      output_add_string (scratch_buffer, "\\\\");
-      break;
-    case '\'':
-      output_add_string (scratch_buffer, "\\'");
-      break;
-    case '\"':
-      output_add_string (scratch_buffer, "\\\"");
-      break;
-    default:
-      if (ISPRINT (c))
-	output_add_character (scratch_buffer, c);
-      else
-        output_formatted_scalar (scratch_buffer, "\\%03o", (unsigned) c);
-      break;
+      dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
+      l = TREE_CHAIN (l);
+      if (l)
+	pp_separate_with_comma (cxx_pp);
     }
 }
 
-/* Print out a list of initializers (subr of dump_expr) */
+/* Print out a vector of initializers (subr of dump_expr).  */
 
 static void
-dump_expr_list (tree l, int flags)
+dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
 {
-  while (l)
+  unsigned HOST_WIDE_INT idx;
+  tree value;
+
+  FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
     {
-      dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
-      l = TREE_CHAIN (l);
-      if (l)
-	separate_with_comma (scratch_buffer);
+      dump_expr (value, flags | TFF_EXPR_IN_PARENS);
+      if (idx != VEC_length (constructor_elt, v) - 1)
+	pp_separate_with_comma (cxx_pp);
     }
 }
 
+
 /* Print out an expression E under control of FLAGS.  */
 
 static void
@@ -1400,7 +1285,7 @@ dump_expr (tree t, int flags)
 {
   if (t == 0)
     return;
-  
+
   switch (TREE_CODE (t))
     {
     case VAR_DECL:
@@ -1410,146 +1295,64 @@ dump_expr (tree t, int flags)
     case FUNCTION_DECL:
     case TEMPLATE_DECL:
     case NAMESPACE_DECL:
+    case LABEL_DECL:
     case OVERLOAD:
     case IDENTIFIER_NODE:
-      dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
+      dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
       break;
 
-    case INTEGER_CST:
-      {
-	tree type = TREE_TYPE (t);
-	my_friendly_assert (type != 0, 81);
-
-	/* If it's an enum, output its tag, rather than its value.  */
-	if (TREE_CODE (type) == ENUMERAL_TYPE)
-	  {
-	    tree values = TYPE_VALUES (type);
-
-	    for (; values;
-	         values = TREE_CHAIN (values))
-	      if (tree_int_cst_equal (TREE_VALUE (values), t))
-	        break;
-
-	    if (values)
-	      print_tree_identifier (scratch_buffer, TREE_PURPOSE (values));
-	    else
-	      {
-                /* Value must have been cast.  */
-                print_left_paren (scratch_buffer);
-                dump_type (type, flags);
-                print_right_paren (scratch_buffer);
-                goto do_int;
-	      }
-	  }
-	else if (type == boolean_type_node)
-	  {
-	    if (t == boolean_false_node || integer_zerop (t))
-	      print_identifier (scratch_buffer, "false");
-	    else if (t == boolean_true_node)
-	      print_identifier (scratch_buffer, "true");
-	  }
-	else if (type == char_type_node)
-	  {
-	    output_add_character (scratch_buffer, '\'');
-	    if (host_integerp (t, TREE_UNSIGNED (type)))
-	      dump_char (tree_low_cst (t, TREE_UNSIGNED (type)));
-	    else
-	      output_printf (scratch_buffer, "\\x%x",
-			     (unsigned int) TREE_INT_CST_LOW (t));
-	    output_add_character (scratch_buffer, '\'');
-	  }
-	else
-	  {
-	    do_int:
-	    if (! host_integerp (t, 0))
-	      {
-	        tree val = t;
-
-	        if (tree_int_cst_sgn (val) < 0)
-	          {
-		    output_add_character (scratch_buffer, '-');
-		    val = build_int_2 (-TREE_INT_CST_LOW (val),
-				       ~TREE_INT_CST_HIGH (val)
-	                               + !TREE_INT_CST_LOW (val));
-	          }
-		sprintf (scratch_buffer->digit_buffer,
-                         HOST_WIDE_INT_PRINT_DOUBLE_HEX,
-			 TREE_INT_CST_HIGH (val), TREE_INT_CST_LOW (val));
-		output_add_string
-                  (scratch_buffer, scratch_buffer->digit_buffer);
-	      }
-	    else
-	      output_host_wide_integer (scratch_buffer, TREE_INT_CST_LOW (t));
-	  }
-      }
+    case STRING_CST:
+      if (PAREN_STRING_LITERAL_P (t))
+	pp_cxx_left_paren (cxx_pp);
+      pp_c_constant (pp_c_base (cxx_pp), t);
+      if (PAREN_STRING_LITERAL_P (t))
+	pp_cxx_right_paren (cxx_pp);
       break;
 
+    case INTEGER_CST:
     case REAL_CST:
-      real_to_decimal (scratch_buffer->digit_buffer, &TREE_REAL_CST (t),
-		       sizeof (scratch_buffer->digit_buffer), 0, 1);
-      output_add_string (scratch_buffer, scratch_buffer->digit_buffer);
+       pp_c_constant (pp_c_base (cxx_pp), t);
       break;
 
-    case PTRMEM_CST:
-      output_add_character (scratch_buffer, '&');
-      dump_type (PTRMEM_CST_CLASS (t), flags);
-      print_scope_operator (scratch_buffer);
-      print_tree_identifier
-        (scratch_buffer, DECL_NAME (PTRMEM_CST_MEMBER (t)));
+    case THROW_EXPR:
+      pp_cxx_identifier (cxx_pp, "throw");
+      dump_expr (TREE_OPERAND (t, 0), flags);
       break;
 
-    case STRING_CST:
-      {
-	const char *p = TREE_STRING_POINTER (t);
-	int len = TREE_STRING_LENGTH (t) - 1;
-	int i;
-
-	output_add_character (scratch_buffer, '\"');
-	for (i = 0; i < len; i++)
-	  dump_char (p[i]);
-	output_add_character (scratch_buffer, '\"');
-      }
+    case PTRMEM_CST:
+      pp_ampersand (cxx_pp);
+      dump_type (PTRMEM_CST_CLASS (t), flags);
+      pp_cxx_colon_colon (cxx_pp);
+      pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
       break;
 
     case COMPOUND_EXPR:
-      print_left_paren (scratch_buffer);
-      /* Within templates, a COMPOUND_EXPR has only one operand,
-         containing a TREE_LIST of the two operands.  */
-      if (TREE_CODE (TREE_OPERAND (t, 0)) == TREE_LIST)
-      {
-        if (TREE_OPERAND (t, 1))
-          abort();
-        dump_expr_list (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
-      }
-      else
-      {
-        dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
-        separate_with_comma (scratch_buffer);
-        dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
-      }
-      print_right_paren (scratch_buffer);
+      pp_cxx_left_paren (cxx_pp);
+      dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
+      pp_separate_with_comma (cxx_pp);
+      dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
+      pp_cxx_right_paren (cxx_pp);
       break;
 
     case COND_EXPR:
-      print_left_paren (scratch_buffer);
+      pp_cxx_left_paren (cxx_pp);
       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
-      output_add_string (scratch_buffer, " ? ");
+      pp_string (cxx_pp, " ? ");
       dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
-      output_add_string (scratch_buffer, " : ");
+      pp_string (cxx_pp, " : ");
       dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
-      print_right_paren (scratch_buffer);
+      pp_cxx_right_paren (cxx_pp);
       break;
 
     case SAVE_EXPR:
       if (TREE_HAS_CONSTRUCTOR (t))
 	{
-	  output_add_string (scratch_buffer, "new ");
+	  pp_cxx_identifier (cxx_pp, "new");
+	  pp_cxx_whitespace (cxx_pp);
 	  dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
 	}
       else
-	{
-	  dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
-	}
+	dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
       break;
 
     case AGGR_INIT_EXPR:
@@ -1562,18 +1365,17 @@ dump_expr (tree t, int flags)
 	if (fn && TREE_CODE (fn) == FUNCTION_DECL)
 	  {
 	    if (DECL_CONSTRUCTOR_P (fn))
-	      print_tree_identifier
-                (scratch_buffer, TYPE_IDENTIFIER (TREE_TYPE (t)));
+	      dump_type (DECL_CONTEXT (fn), flags);
 	    else
 	      dump_decl (fn, 0);
 	  }
 	else
 	  dump_expr (TREE_OPERAND (t, 0), 0);
       }
-      print_left_paren (scratch_buffer);
+      pp_cxx_left_paren (cxx_pp);
       if (TREE_OPERAND (t, 1))
 	dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
-      print_right_paren (scratch_buffer);
+      pp_cxx_right_paren (cxx_pp);
       break;
 
     case CALL_EXPR:
@@ -1590,20 +1392,20 @@ dump_expr (tree t, int flags)
 	    if (TREE_CODE (ob) == ADDR_EXPR)
 	      {
 		dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
-		output_add_character (scratch_buffer, '.');
+		pp_dot (cxx_pp);
 	      }
 	    else if (TREE_CODE (ob) != PARM_DECL
 		     || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
 	      {
 		dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
-		output_add_string (scratch_buffer, "->");
+		pp_arrow (cxx_pp);
 	      }
 	    args = TREE_CHAIN (args);
 	  }
 	dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
-	print_left_paren (scratch_buffer);
+	pp_cxx_left_paren (cxx_pp);
 	dump_expr_list (args, flags);
-	print_right_paren (scratch_buffer);
+	pp_cxx_right_paren (cxx_pp);
       }
       break;
 
@@ -1612,24 +1414,25 @@ dump_expr (tree t, int flags)
 	tree type = TREE_OPERAND (t, 1);
 	tree init = TREE_OPERAND (t, 2);
 	if (NEW_EXPR_USE_GLOBAL (t))
-	  print_scope_operator (scratch_buffer);
-	output_add_string (scratch_buffer, "new ");
+	  pp_cxx_colon_colon (cxx_pp);
+	pp_cxx_identifier (cxx_pp, "new");
 	if (TREE_OPERAND (t, 0))
 	  {
-	    print_left_paren (scratch_buffer);
+	    pp_cxx_left_paren (cxx_pp);
 	    dump_expr_list (TREE_OPERAND (t, 0), flags);
-	    output_add_string (scratch_buffer, ") ");
+	    pp_cxx_right_paren (cxx_pp);
+	    pp_cxx_whitespace (cxx_pp);
 	  }
 	if (TREE_CODE (type) == ARRAY_REF)
 	  type = build_cplus_array_type
 	    (TREE_OPERAND (type, 0),
-	     build_index_type (fold (build (MINUS_EXPR, integer_type_node,
+	     build_index_type (fold_build2 (MINUS_EXPR, integer_type_node,
 					    TREE_OPERAND (type, 1),
-					    integer_one_node))));
+					    integer_one_node)));
 	dump_type (type, flags);
 	if (init)
 	  {
-	    print_left_paren (scratch_buffer);
+	    pp_cxx_left_paren (cxx_pp);
 	    if (TREE_CODE (init) == TREE_LIST)
 	      dump_expr_list (init, flags);
 	    else if (init == void_zero_node)
@@ -1638,7 +1441,7 @@ dump_expr (tree t, int flags)
 	      ;
 	    else
 	      dump_expr (init, flags);
-	    print_right_paren (scratch_buffer);
+	    pp_cxx_right_paren (cxx_pp);
 	  }
       }
       break;
@@ -1667,7 +1470,6 @@ dump_expr (tree t, int flags)
     case BIT_IOR_EXPR:
     case BIT_XOR_EXPR:
     case BIT_AND_EXPR:
-    case BIT_ANDTC_EXPR:
     case TRUTH_ANDIF_EXPR:
     case TRUTH_ORIF_EXPR:
     case LT_EXPR:
@@ -1683,6 +1485,7 @@ dump_expr (tree t, int flags)
     case CEIL_DIV_EXPR:
     case FLOOR_DIV_EXPR:
     case ROUND_DIV_EXPR:
+    case RDIV_EXPR:
       dump_binary_op ("/", t, flags);
       break;
 
@@ -1699,16 +1502,17 @@ dump_expr (tree t, int flags)
 	  {
 	    ob = TREE_OPERAND (ob, 0);
 	    if (TREE_CODE (ob) != PARM_DECL
-		|| strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
+		|| (DECL_NAME (ob)
+		    && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
 	      {
 		dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
-		output_add_string (scratch_buffer, "->");
+		pp_cxx_arrow (cxx_pp);
 	      }
 	  }
 	else
 	  {
 	    dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
-	    output_add_character (scratch_buffer, '.');
+	    pp_cxx_dot (cxx_pp);
 	  }
 	dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
       }
@@ -1716,21 +1520,13 @@ dump_expr (tree t, int flags)
 
     case ARRAY_REF:
       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
-      print_left_bracket (scratch_buffer);
+      pp_cxx_left_bracket (cxx_pp);
       dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
-      print_right_bracket (scratch_buffer);
+      pp_cxx_right_bracket (cxx_pp);
       break;
 
-    case CONVERT_EXPR:
-      if (TREE_TYPE (t) && VOID_TYPE_P (TREE_TYPE (t)))
-	{
-	  print_left_paren (scratch_buffer);
-	  dump_type (TREE_TYPE (t), flags);
-	  print_right_paren (scratch_buffer);
-	  dump_expr (TREE_OPERAND (t, 0), flags);
-	}
-      else
-	dump_unary_op ("+", t, flags);
+    case UNARY_PLUS_EXPR:
+      dump_unary_op ("+", t, flags);
       break;
 
     case ADDR_EXPR:
@@ -1742,6 +1538,8 @@ dump_expr (tree t, int flags)
 	  || (TREE_TYPE (t)
 	      && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
 	dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
+      else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
+	dump_unary_op ("&&", t, flags);
       else
 	dump_unary_op ("&", t, flags);
       break;
@@ -1750,11 +1548,11 @@ dump_expr (tree t, int flags)
       if (TREE_HAS_CONSTRUCTOR (t))
 	{
 	  t = TREE_OPERAND (t, 0);
-	  my_friendly_assert (TREE_CODE (t) == CALL_EXPR, 237);
+	  gcc_assert (TREE_CODE (t) == CALL_EXPR);
 	  dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
-	  print_left_paren (scratch_buffer);
+	  pp_cxx_left_paren (cxx_pp);
 	  dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
-	  print_right_paren (scratch_buffer);
+	  pp_cxx_right_paren (cxx_pp);
 	}
       else
 	{
@@ -1777,11 +1575,10 @@ dump_expr (tree t, int flags)
 
     case POSTDECREMENT_EXPR:
     case POSTINCREMENT_EXPR:
-      print_left_paren (scratch_buffer);
+      pp_cxx_left_paren (cxx_pp);
       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
-      print_identifier
-        (scratch_buffer, operator_name_info[(int)TREE_CODE (t)].name);
-      print_right_paren (scratch_buffer);
+      pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
+      pp_cxx_right_paren (cxx_pp);
       break;
 
     case NON_LVALUE_EXPR:
@@ -1798,25 +1595,40 @@ dump_expr (tree t, int flags)
 	  if (TREE_CODE (next) == FUNCTION_TYPE)
 	    {
 	      if (flags & TFF_EXPR_IN_PARENS)
-	        print_left_paren (scratch_buffer);
-	      output_add_character (scratch_buffer, '*');
+		pp_cxx_left_paren (cxx_pp);
+	      pp_cxx_star (cxx_pp);
 	      dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
 	      if (flags & TFF_EXPR_IN_PARENS)
-	        print_right_paren (scratch_buffer);
+		pp_cxx_right_paren (cxx_pp);
 	      break;
 	    }
-	  /* else FALLTHRU */
+	  /* Else fall through.  */
 	}
       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
       break;
 
     case NOP_EXPR:
-      dump_expr (TREE_OPERAND (t, 0), flags);
-      break;
+    case CONVERT_EXPR:
+      {
+	tree op = TREE_OPERAND (t, 0);
 
-    case EXPR_WITH_FILE_LOCATION:
-      dump_expr (EXPR_WFL_NODE (t), flags);
-      break;
+	if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
+	  {
+	    /* It is a cast, but we cannot tell whether it is a
+	       reinterpret or static cast. Use the C style notation.  */
+	    if (flags & TFF_EXPR_IN_PARENS)
+	      pp_cxx_left_paren (cxx_pp);
+	    pp_cxx_left_paren (cxx_pp);
+	    dump_type (TREE_TYPE (t), flags);
+	    pp_cxx_right_paren (cxx_pp);
+	    dump_expr (op, flags | TFF_EXPR_IN_PARENS);
+	    if (flags & TFF_EXPR_IN_PARENS)
+	      pp_cxx_right_paren (cxx_pp);
+	  }
+	else
+	  dump_expr (op, flags);
+	break;
+      }
 
     case CONSTRUCTOR:
       if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
@@ -1826,9 +1638,12 @@ dump_expr (tree t, int flags)
 	  if (integer_zerop (idx))
 	    {
 	      /* A NULL pointer-to-member constant.  */
-	      output_add_string (scratch_buffer, "((");
+	      pp_cxx_left_paren (cxx_pp);
+	      pp_cxx_left_paren (cxx_pp);
 	      dump_type (TREE_TYPE (t), flags);
-	      output_add_string (scratch_buffer, ") 0)");
+	      pp_cxx_right_paren (cxx_pp);
+	      pp_character (cxx_pp, '0');
+	      pp_cxx_right_paren (cxx_pp);
 	      break;
 	    }
 	  else if (host_integerp (idx, 0))
@@ -1838,7 +1653,7 @@ dump_expr (tree t, int flags)
 
 	      t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
 	      t = TYPE_METHOD_BASETYPE (t);
-	      virtuals = TYPE_BINFO_VIRTUALS (TYPE_MAIN_VARIANT (t));
+	      virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
 
 	      n = tree_low_cst (idx, 0);
 
@@ -1854,24 +1669,24 @@ dump_expr (tree t, int flags)
 	      if (virtuals)
 		{
 		  dump_expr (BV_FN (virtuals),
-	                     flags | TFF_EXPR_IN_PARENS);
+			     flags | TFF_EXPR_IN_PARENS);
 		  break;
 		}
 	    }
 	}
-      if (TREE_TYPE (t) && !CONSTRUCTOR_ELTS (t))
+      if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
 	{
 	  dump_type (TREE_TYPE (t), 0);
-	  output_add_character (scratch_buffer, '(');
-	  output_add_character (scratch_buffer, ')');
+	  pp_cxx_left_paren (cxx_pp);
+	  pp_cxx_right_paren (cxx_pp);
 	}
       else
 	{
-	  output_add_character (scratch_buffer, '{');
-	  dump_expr_list (CONSTRUCTOR_ELTS (t), flags);
-	  output_add_character (scratch_buffer, '}');
+	  pp_cxx_left_brace (cxx_pp);
+	  dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
+	  pp_cxx_right_brace (cxx_pp);
 	}
-      
+
       break;
 
     case OFFSET_REF:
@@ -1884,7 +1699,7 @@ dump_expr (tree t, int flags)
 	      /* A::f */
 	      dump_expr (t, flags | TFF_EXPR_IN_PARENS);
 	    else if (BASELINK_P (t))
-	      dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)), 
+	      dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
 			 flags | TFF_EXPR_IN_PARENS);
 	    else
 	      dump_decl (t, flags);
@@ -1894,12 +1709,14 @@ dump_expr (tree t, int flags)
 	    if (TREE_CODE (ob) == INDIRECT_REF)
 	      {
 		dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
-		output_add_string (scratch_buffer, "->*");
+		pp_cxx_arrow (cxx_pp);
+		pp_cxx_star (cxx_pp);
 	      }
 	    else
 	      {
 		dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
-		output_add_string (scratch_buffer, ".*");
+		pp_cxx_dot (cxx_pp);
+		pp_cxx_star (cxx_pp);
 	      }
 	    dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
 	  }
@@ -1911,9 +1728,7 @@ dump_expr (tree t, int flags)
       break;
 
     case SCOPE_REF:
-      dump_type (TREE_OPERAND (t, 0), flags);
-      print_scope_operator (scratch_buffer);
-      dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
+      pp_expression (cxx_pp, t);
       break;
 
     case CAST_EXPR:
@@ -1921,65 +1736,73 @@ dump_expr (tree t, int flags)
 	  || TREE_CHAIN (TREE_OPERAND (t, 0)))
 	{
 	  dump_type (TREE_TYPE (t), flags);
-	  print_left_paren (scratch_buffer);
+	  pp_cxx_left_paren (cxx_pp);
 	  dump_expr_list (TREE_OPERAND (t, 0), flags);
-	  print_right_paren (scratch_buffer);
+	  pp_cxx_right_paren (cxx_pp);
 	}
       else
 	{
-	  print_left_paren (scratch_buffer);
+	  pp_cxx_left_paren (cxx_pp);
 	  dump_type (TREE_TYPE (t), flags);
-          output_add_string (scratch_buffer, ")(");
+	  pp_cxx_right_paren (cxx_pp);
+	  pp_cxx_left_paren (cxx_pp);
 	  dump_expr_list (TREE_OPERAND (t, 0), flags);
-	  print_right_paren (scratch_buffer);
+	  pp_cxx_right_paren (cxx_pp);
 	}
       break;
 
     case STATIC_CAST_EXPR:
-      output_add_string (scratch_buffer, "static_cast<");
+      pp_cxx_identifier (cxx_pp, "static_cast");
       goto cast;
     case REINTERPRET_CAST_EXPR:
-      output_add_string (scratch_buffer, "reinterpret_cast<");
+      pp_cxx_identifier (cxx_pp, "reinterpret_cast");
       goto cast;
     case CONST_CAST_EXPR:
-      output_add_string (scratch_buffer, "const_cast<");
+      pp_cxx_identifier (cxx_pp, "const_cast");
       goto cast;
     case DYNAMIC_CAST_EXPR:
-      output_add_string (scratch_buffer, "dynamic_cast<");
+      pp_cxx_identifier (cxx_pp, "dynamic_cast");
     cast:
+      pp_cxx_begin_template_argument_list (cxx_pp);
       dump_type (TREE_TYPE (t), flags);
-      output_add_string (scratch_buffer, ">(");
+      pp_cxx_end_template_argument_list (cxx_pp);
+      pp_cxx_left_paren (cxx_pp);
       dump_expr (TREE_OPERAND (t, 0), flags);
-      print_right_paren (scratch_buffer);
-      break;
-
-    case LOOKUP_EXPR:
-      print_tree_identifier (scratch_buffer, TREE_OPERAND (t, 0));
+      pp_cxx_right_paren (cxx_pp);
       break;
 
     case ARROW_EXPR:
       dump_expr (TREE_OPERAND (t, 0), flags);
-      output_add_string (scratch_buffer, "->");
+      pp_cxx_arrow (cxx_pp);
       break;
 
     case SIZEOF_EXPR:
     case ALIGNOF_EXPR:
       if (TREE_CODE (t) == SIZEOF_EXPR)
-	output_add_string (scratch_buffer, "sizeof (");
+	pp_cxx_identifier (cxx_pp, "sizeof");
       else
 	{
-	  my_friendly_assert (TREE_CODE (t) == ALIGNOF_EXPR, 0);
-	  output_add_string (scratch_buffer, "__alignof__ (");
+	  gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
+	  pp_cxx_identifier (cxx_pp, "__alignof__");
 	}
+      pp_cxx_whitespace (cxx_pp);
+      pp_cxx_left_paren (cxx_pp);
       if (TYPE_P (TREE_OPERAND (t, 0)))
 	dump_type (TREE_OPERAND (t, 0), flags);
       else
-        dump_expr (TREE_OPERAND (t, 0), flags);
-      print_right_paren (scratch_buffer);
+	dump_expr (TREE_OPERAND (t, 0), flags);
+      pp_cxx_right_paren (cxx_pp);
+      break;
+
+    case REALPART_EXPR:
+    case IMAGPART_EXPR:
+      pp_cxx_identifier (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:
-      print_identifier (scratch_buffer, "<unparsed>");
+      pp_identifier (cxx_pp, "<unparsed>");
       break;
 
     case TRY_CATCH_EXPR:
@@ -1990,9 +1813,10 @@ dump_expr (tree t, int flags)
 
     case PSEUDO_DTOR_EXPR:
       dump_expr (TREE_OPERAND (t, 2), flags);
-      output_add_character (scratch_buffer, '.');
+      pp_cxx_dot (cxx_pp);
       dump_type (TREE_OPERAND (t, 0), flags);
-      output_add_string (scratch_buffer, "::~");
+      pp_cxx_colon_colon (cxx_pp);
+      pp_cxx_complement (cxx_pp);
       dump_type (TREE_OPERAND (t, 1), flags);
       break;
 
@@ -2000,44 +1824,48 @@ dump_expr (tree t, int flags)
       dump_decl (t, flags);
       break;
 
+    case BIND_EXPR:
     case STMT_EXPR:
+    case STATEMENT_LIST:
       /* We don't yet have a way of dumping statements in a
 	 human-readable format.  */
-      output_add_string (scratch_buffer, "({...})");
-      break;
-
-    case BIND_EXPR:
-      output_add_character (scratch_buffer, '{');
-      dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
-      output_add_character (scratch_buffer, '}');
+      pp_string (cxx_pp, "({...})");
       break;
 
     case LOOP_EXPR:
-      output_add_string (scratch_buffer, "while (1) { ");
+      pp_string (cxx_pp, "while (1) { ");
       dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
-      output_add_character (scratch_buffer, '}');
+      pp_cxx_right_brace (cxx_pp);
       break;
 
     case EXIT_EXPR:
-      output_add_string (scratch_buffer, "if (");
+      pp_string (cxx_pp, "if (");
       dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
-      output_add_string (scratch_buffer, ") break; ");
+      pp_string (cxx_pp, ") break; ");
       break;
 
     case BASELINK:
       dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
       break;
 
-      /* else fall through */
+    case EMPTY_CLASS_EXPR:
+      dump_type (TREE_TYPE (t), flags);
+      pp_cxx_left_paren (cxx_pp);
+      pp_cxx_right_paren (cxx_pp);
+      break;
+
+    case NON_DEPENDENT_EXPR:
+      dump_expr (TREE_OPERAND (t, 0), flags);
+      break;
 
       /*  This list is incomplete, but should suffice for now.
 	  It is very important that `sorry' does not call
 	  `report_error_function'.  That could cause an infinite loop.  */
     default:
-      sorry_for_unsupported_tree (t);
+      pp_unsupported_tree (cxx_pp, t);
       /* fall through to ERROR_MARK...  */
     case ERROR_MARK:
-      print_identifier (scratch_buffer, "<expression error>");
+      pp_identifier (cxx_pp, "<expression error>");
       break;
     }
 }
@@ -2045,70 +1873,65 @@ dump_expr (tree t, int flags)
 static void
 dump_binary_op (const char *opstring, tree t, int flags)
 {
-  print_left_paren (scratch_buffer);
+  pp_cxx_left_paren (cxx_pp);
   dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
-  output_add_space (scratch_buffer);
+  pp_cxx_whitespace (cxx_pp);
   if (opstring)
-    print_identifier (scratch_buffer, opstring);
+    pp_cxx_identifier (cxx_pp, opstring);
   else
-    print_identifier (scratch_buffer, "<unknown operator>");
-  output_add_space (scratch_buffer);
+    pp_identifier (cxx_pp, "<unknown operator>");
+  pp_cxx_whitespace (cxx_pp);
   dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
-  print_right_paren (scratch_buffer);
+  pp_cxx_right_paren (cxx_pp);
 }
 
 static void
 dump_unary_op (const char *opstring, tree t, int flags)
 {
   if (flags & TFF_EXPR_IN_PARENS)
-    print_left_paren (scratch_buffer);
-  print_identifier (scratch_buffer, opstring);
+    pp_cxx_left_paren (cxx_pp);
+  pp_cxx_identifier (cxx_pp, opstring);
   dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
   if (flags & TFF_EXPR_IN_PARENS)
-    print_right_paren (scratch_buffer);
+    pp_cxx_right_paren (cxx_pp);
 }
 
+static void
+reinit_cxx_pp (void)
+{
+  pp_clear_output_area (cxx_pp);
+  pp_base (cxx_pp)->padding = pp_none;
+  pp_indentation (cxx_pp) = 0;
+  pp_needs_newline (cxx_pp) = false;
+  cxx_pp->enclosing_scope = 0;
+}
+
+
 /* Exported interface to stringifying types, exprs and decls under TFF_*
    control.  */
 
 const char *
 type_as_string (tree typ, int flags)
 {
-  reinit_global_formatting_buffer ();
-
+  reinit_cxx_pp ();
   dump_type (typ, flags);
-
-  return output_finalize_message (scratch_buffer);
+  return pp_formatted_text (cxx_pp);
 }
 
 const char *
 expr_as_string (tree decl, int flags)
 {
-  reinit_global_formatting_buffer ();
-
+  reinit_cxx_pp ();
   dump_expr (decl, flags);
-
-  return output_finalize_message (scratch_buffer);
+  return pp_formatted_text (cxx_pp);
 }
 
 const char *
 decl_as_string (tree decl, int flags)
 {
-  reinit_global_formatting_buffer ();
-
+  reinit_cxx_pp ();
   dump_decl (decl, flags);
-
-  return output_finalize_message (scratch_buffer);
-}
-
-const char *
-context_as_string (tree context, int flags)
-{
-  reinit_global_formatting_buffer ();
-
-  dump_scope (context, flags);
-
-  return output_finalize_message (scratch_buffer);
+  return pp_formatted_text (cxx_pp);
 }
 
 /* Generate the three forms of printable names for cxx_printable_name.  */
@@ -2119,12 +1942,11 @@ lang_decl_name (tree decl, int v)
   if (v >= 2)
     return decl_as_string (decl, TFF_DECL_SPECIFIERS);
 
-  reinit_global_formatting_buffer ();
-
+  reinit_cxx_pp ();
   if (v == 1 && DECL_CLASS_SCOPE_P (decl))
     {
       dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
-      print_scope_operator (scratch_buffer);
+      pp_cxx_colon_colon (cxx_pp);
     }
 
   if (TREE_CODE (decl) == FUNCTION_DECL)
@@ -2132,9 +1954,11 @@ lang_decl_name (tree decl, int v)
   else
     dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
 
-  return output_finalize_message (scratch_buffer);
+  return pp_formatted_text (cxx_pp);
 }
 
+/* Return the location of a tree passed to %+ formats.  */
+
 static location_t
 location_of (tree t)
 {
@@ -2144,7 +1968,7 @@ location_of (tree t)
     t = TYPE_MAIN_DECL (t);
   else if (TREE_CODE (t) == OVERLOAD)
     t = OVL_FUNCTION (t);
-  
+
   return DECL_SOURCE_LOCATION (t);
 }
 
@@ -2161,26 +1985,22 @@ decl_to_string (tree decl, int verbose)
       || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
     flags = TFF_CLASS_KEY_OR_ENUM;
   if (verbose)
-    flags |= TFF_DECL_SPECIFIERS | TFF_FUNCTION_DEFAULT_ARGUMENTS;
+    flags |= TFF_DECL_SPECIFIERS;
   else if (TREE_CODE (decl) == FUNCTION_DECL)
     flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
   flags |= TFF_TEMPLATE_HEADER;
 
-  reinit_global_formatting_buffer ();
-
+  reinit_cxx_pp ();
   dump_decl (decl, flags);
-
-  return output_finalize_message (scratch_buffer);
+  return pp_formatted_text (cxx_pp);
 }
 
 static const char *
 expr_to_string (tree decl)
 {
-  reinit_global_formatting_buffer ();
-
+  reinit_cxx_pp ();
   dump_expr (decl, 0);
-
-  return output_finalize_message (scratch_buffer);
+  return pp_formatted_text (cxx_pp);
 }
 
 static const char *
@@ -2191,11 +2011,9 @@ fndecl_to_string (tree fndecl, int verbose)
   flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS;
   if (verbose)
     flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
-  reinit_global_formatting_buffer ();
-
+  reinit_cxx_pp ();
   dump_decl (fndecl, flags);
-
-  return output_finalize_message (scratch_buffer);
+  return pp_formatted_text (cxx_pp);
 }
 
 
@@ -2220,9 +2038,9 @@ language_to_string (enum languages c)
       return "Java";
 
     default:
-      abort ();
-      return 0;
+      gcc_unreachable ();
     }
+  return 0;
 }
 
 /* Return the proper printed version of a parameter to a C++ function.  */
@@ -2230,46 +2048,38 @@ language_to_string (enum languages c)
 static const char *
 parm_to_string (int p)
 {
+  reinit_cxx_pp ();
   if (p < 0)
-    output_add_string (scratch_buffer, "'this'");
+    pp_string (cxx_pp, "'this'");
   else
-    output_decimal (scratch_buffer, p + 1);
-
-  return output_finalize_message (scratch_buffer);
+    pp_decimal_int (cxx_pp, p + 1);
+  return pp_formatted_text (cxx_pp);
 }
 
 static const char *
 op_to_string (enum tree_code p)
 {
-  tree id;
-
-  id = operator_name_info[(int) p].identifier;
+  tree id = operator_name_info[(int) p].identifier;
   return id ? IDENTIFIER_POINTER (id) : "<unknown>";
 }
 
 static const char *
 type_to_string (tree typ, int verbose)
 {
-  int flags;
-
-  flags = 0;
+  int flags = 0;
   if (verbose)
     flags |= TFF_CLASS_KEY_OR_ENUM;
   flags |= TFF_TEMPLATE_HEADER;
 
-  reinit_global_formatting_buffer ();
-
+  reinit_cxx_pp ();
   dump_type (typ, flags);
-
-  return output_finalize_message (scratch_buffer);
+  return pp_formatted_text (cxx_pp);
 }
 
 static const char *
 assop_to_string (enum tree_code p)
 {
-  tree id;
-
-  id = assignment_operator_name_info[(int) p].identifier;
+  tree id = assignment_operator_name_info[(int) p].identifier;
   return id ? IDENTIFIER_POINTER (id) : "{unknown}";
 }
 
@@ -2286,27 +2096,26 @@ args_to_string (tree p, int verbose)
   if (TYPE_P (TREE_VALUE (p)))
     return type_as_string (p, flags);
 
-  reinit_global_formatting_buffer ();
+  reinit_cxx_pp ();
   for (; p; p = TREE_CHAIN (p))
     {
       if (TREE_VALUE (p) == null_node)
-	print_identifier (scratch_buffer, "NULL");
+	pp_cxx_identifier (cxx_pp, "NULL");
       else
 	dump_type (error_type (TREE_VALUE (p)), flags);
       if (TREE_CHAIN (p))
-	separate_with_comma (scratch_buffer);
+	pp_separate_with_comma (cxx_pp);
     }
-  return output_finalize_message (scratch_buffer);
+  return pp_formatted_text (cxx_pp);
 }
 
 static const char *
 cv_to_string (tree p, int v)
 {
-  reinit_global_formatting_buffer ();
-
-  dump_qualifiers (p, v ? before : none);
-
-  return output_finalize_message (scratch_buffer);
+  reinit_cxx_pp ();
+  pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
+  pp_cxx_cv_qualifier_seq (cxx_pp, p);
+  return pp_formatted_text (cxx_pp);
 }
 
 /* Langhook for print_error_function.  */
@@ -2314,53 +2123,52 @@ void
 cxx_print_error_function (diagnostic_context *context, const char *file)
 {
   lhd_print_error_function (context, file);
-  output_set_prefix (&context->buffer, file);
+  pp_base_set_prefix (context->printer, file);
   maybe_print_instantiation_context (context);
 }
 
 static void
 cp_diagnostic_starter (diagnostic_context *context,
-                       diagnostic_info *diagnostic)
+		       diagnostic_info *diagnostic)
 {
   diagnostic_report_current_module (context);
   cp_print_error_function (context, diagnostic);
   maybe_print_instantiation_context (context);
-  output_set_prefix (&context->buffer, diagnostic_build_prefix (diagnostic));
+  pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
 }
 
 static void
 cp_diagnostic_finalizer (diagnostic_context *context,
-                         diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
+			 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
 {
-  output_destroy_prefix (&context->buffer);
+  pp_base_destroy_prefix (context->printer);
 }
 
 /* Print current function onto BUFFER, in the process of reporting
    a diagnostic message.  Called from cp_diagnostic_starter.  */
 static void
 cp_print_error_function (diagnostic_context *context,
-                         diagnostic_info *diagnostic)
+			 diagnostic_info *diagnostic)
 {
   if (diagnostic_last_function_changed (context))
     {
-      const char *old_prefix = output_prefix (&context->buffer);
-      char *new_prefix = diagnostic->location.file
-        ? file_name_as_prefix (diagnostic->location.file)
-        : NULL;
+      const char *old_prefix = context->printer->prefix;
+      const char *file = LOCATION_FILE (diagnostic->location);
+      char *new_prefix = file ? file_name_as_prefix (file) : NULL;
 
-      output_set_prefix (&context->buffer, new_prefix);
+      pp_base_set_prefix (context->printer, new_prefix);
 
       if (current_function_decl == NULL)
-        output_add_string (&context->buffer, "At global scope:");
+	pp_base_string (context->printer, "At global scope:");
       else
-        output_printf (&context->buffer, "In %s `%s':",
-                       function_category (current_function_decl),
-                       cxx_printable_name (current_function_decl, 2));
-      output_add_newline (&context->buffer);
+	pp_printf (context->printer, "In %s %qs:",
+		   function_category (current_function_decl),
+		   cxx_printable_name (current_function_decl, 2));
+      pp_base_newline (context->printer);
 
       diagnostic_set_last_function (context);
-      output_destroy_prefix (&context->buffer);
-      context->buffer.state.prefix = old_prefix;
+      pp_base_destroy_prefix (context->printer);
+      context->printer->prefix = old_prefix;
     }
 }
 
@@ -2371,15 +2179,15 @@ function_category (tree fn)
   if (DECL_FUNCTION_MEMBER_P (fn))
     {
       if (DECL_STATIC_FUNCTION_P (fn))
-        return "static member function";
+	return "static member function";
       else if (DECL_COPY_CONSTRUCTOR_P (fn))
-        return "copy constructor";
+	return "copy constructor";
       else if (DECL_CONSTRUCTOR_P (fn))
-        return "constructor";
+	return "constructor";
       else if (DECL_DESTRUCTOR_P (fn))
-        return "destructor";
+	return "destructor";
       else
-        return "member function";
+	return "member function";
     }
   else
     return "function";
@@ -2392,7 +2200,7 @@ print_instantiation_full_context (diagnostic_context *context)
 {
   tree p = current_instantiation ();
   location_t location = input_location;
-  
+
   if (p)
     {
       if (current_function_decl != TINST_DECL (p)
@@ -2404,15 +2212,15 @@ print_instantiation_full_context (diagnostic_context *context)
       else
 	{
 	  if (current_function_decl == TINST_DECL (p))
-	    /* Avoid redundancy with the the "In function" line.  */;
+	    /* Avoid redundancy with the "In function" line.  */;
 	  else
-	    output_verbatim (&context->buffer,
-                             "%s: In instantiation of `%s':\n", location.file,
-                             decl_as_string (TINST_DECL (p),
-                                             TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
+	    pp_verbatim (context->printer,
+			 "%s: In instantiation of %qs:\n",
+			 LOCATION_FILE (location),
+			 decl_as_string (TINST_DECL (p),
+					 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
 
-	  location.line = TINST_LINE (p);
-	  location.file = TINST_FILE (p);
+	  location = TINST_LOCATION (p);
 	  p = TREE_CHAIN (p);
 	}
     }
@@ -2423,20 +2231,23 @@ print_instantiation_full_context (diagnostic_context *context)
 /* Same as above but less verbose.  */
 static void
 print_instantiation_partial_context (diagnostic_context *context,
-                                     tree t, location_t loc)
+				     tree t, location_t loc)
 {
-  for (; t; t = TREE_CHAIN (t))
+  expanded_location xloc;
+  for (; ; t = TREE_CHAIN (t))
     {
-      output_verbatim
-        (&context->buffer, "%s:%d:   instantiated from `%s'\n",
-	 loc.file, loc.line,
-         decl_as_string (TINST_DECL (t),
-			 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
-      loc.line = TINST_LINE (t);
-      loc.file = TINST_FILE (t);
+      xloc = expand_location (loc);
+      if (t == NULL_TREE)
+	break;
+      pp_verbatim (context->printer, "%s:%d:   instantiated from %qs\n",
+		   xloc.file, xloc.line,
+		   decl_as_string (TINST_DECL (t),
+				   TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
+      loc = TINST_LOCATION (t);
     }
-  output_verbatim (&context->buffer, "%s:%d:   instantiated from here\n",
-		   loc.file, loc.line);
+  pp_verbatim (context->printer, "%s:%d:   instantiated from here",
+	       xloc.file, xloc.line);
+  pp_base_newline (context->printer);
 }
 
 /* Called from cp_thing to print the template context for an error.  */
@@ -2473,169 +2284,79 @@ print_instantiation_context (void)
    %T   type.
    %V   cv-qualifier.  */
 static bool
-cp_printer (output_buffer *buffer, text_info *text)
+cp_printer (pretty_printer *pp, text_info *text, const char *spec,
+	    int precision, bool wide, bool set_locus, bool verbose)
 {
-  int verbose = 0;
   const char *result;
-#define next_tree    va_arg (*text->args_ptr, tree)
+  tree t = NULL;
+#define next_tree    (t = va_arg (*text->args_ptr, tree))
 #define next_tcode   va_arg (*text->args_ptr, enum tree_code)
 #define next_lang    va_arg (*text->args_ptr, enum languages)
 #define next_int     va_arg (*text->args_ptr, int)
 
-  if (*text->format_spec == '+')
-    ++text->format_spec;
-  if (*text->format_spec == '#')
-    {
-      verbose = 1;
-      ++text->format_spec;
-    }
+  if (precision != 0 || wide)
+    return false;
+
+  if (text->locus == NULL)
+    set_locus = false;
 
-  switch (*text->format_spec)
+  switch (*spec)
     {
     case 'A': result = args_to_string (next_tree, verbose);	break;
-    case 'C': result = code_to_string (next_tcode);	        break;
+    case 'C': result = code_to_string (next_tcode);		break;
     case 'D': result = decl_to_string (next_tree, verbose);	break;
-    case 'E': result = expr_to_string (next_tree);      	break;
+    case 'E': result = expr_to_string (next_tree);		break;
     case 'F': result = fndecl_to_string (next_tree, verbose);	break;
-    case 'L': result = language_to_string (next_lang);          break;
-    case 'O': result = op_to_string (next_tcode);       	break;
-    case 'P': result = parm_to_string (next_int);	        break;
-    case 'Q': result = assop_to_string (next_tcode);	        break;
+    case 'L': result = language_to_string (next_lang);		break;
+    case 'O': result = op_to_string (next_tcode);		break;
+    case 'P': result = parm_to_string (next_int);		break;
+    case 'Q': result = assop_to_string (next_tcode);		break;
     case 'T': result = type_to_string (next_tree, verbose);	break;
     case 'V': result = cv_to_string (next_tree, verbose);	break;
- 
+
     default:
       return false;
     }
 
-  output_add_string (buffer, result);
+  pp_base_string (pp, result);
+  if (set_locus && t != NULL)
+    *text->locus = location_of (t);
   return true;
 #undef next_tree
 #undef next_tcode
 #undef next_lang
 #undef next_int
 }
-
-static void
-print_non_consecutive_character (output_buffer *buffer, int c)
-{
-  const char *p = output_last_position (buffer);
-
-  if (p != NULL && *p == c)
-    output_add_space (buffer);
-  output_add_character (buffer, c);
-}
-
-/* These are temporary wrapper functions which handle the historic
-   behavior of cp_*_at.  */
-
-static tree
-locate_error (const char *msgid, va_list ap)
-{
-  tree here = 0, t;
-  int plus = 0;
-  const char *f;
-
-  for (f = msgid; *f; f++)
-    {
-      plus = 0;
-      if (*f == '%')
-	{
-	  f++;
-	  if (*f == '+')
-	    f++, plus = 1;
-	  if (*f == '#')
-	    f++;
-
-	  switch (*f)
-	    {
-	      /* Just ignore these possibilities.  */
-	    case '%':						break;
-	    case 'P':
-	    case 'd':	(void) va_arg (ap, int);		break;
-	    case 's':	(void) va_arg (ap, char *);		break;
-	    case 'L':	(void) va_arg (ap, enum languages);	break;
-	    case 'C':
-	    case 'O':
-	    case 'Q':	(void) va_arg (ap, enum tree_code);	break;
-
-	      /* These take a tree, which may be where the error is
-		 located.  */
-	    case 'A':
-	    case 'D':
-	    case 'E':
-	    case 'F':
-	    case 'T':
-	    case 'V':
-	      t = va_arg (ap, tree);
-	      if (!here || plus)
-		here = t;
-	      break;
-
-	    default:
-	      errorcount = 0;  /* damn ICE suppression */
-	      internal_error ("unexpected letter `%c' in locate_error\n", *f);
-	    }
-	}
-    }
-
-  if (here == 0)
-    here = va_arg (ap, tree);
-
-  return here;
-}
-
-
-void
-cp_error_at (const char *msgid, ...)
-{
-  tree here;
-  diagnostic_info diagnostic;
-  va_list ap;
-
-  va_start (ap, msgid);
-  here = locate_error (msgid, ap);
-  va_end (ap);
-
-  va_start (ap, msgid);
-  diagnostic_set_info (&diagnostic, msgid, &ap,
-                       location_of (here), DK_ERROR);
-  report_diagnostic (&diagnostic);
-  va_end (ap);
-}
-
-void
-cp_warning_at (const char *msgid, ...)
-{
-  tree here;
-  diagnostic_info diagnostic;
-  va_list ap;
-
-  va_start (ap, msgid);
-  here = locate_error (msgid, ap);
-  va_end (ap);
-
-  va_start (ap, msgid);
-  diagnostic_set_info (&diagnostic, msgid, &ap,
-                       location_of (here), DK_WARNING);
-  report_diagnostic (&diagnostic);
-  va_end (ap);
-}
+
+/* Callback from cpp_error for PFILE to print diagnostics arising from
+   interpreting strings.  The diagnostic is of type LEVEL; MSG is the
+   translated message and AP the arguments.  */
 
 void
-cp_pedwarn_at (const char *msgid, ...)
+cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
+	      const char *msg, va_list *ap)
 {
-  tree here;
   diagnostic_info diagnostic;
-  va_list ap;
-
-  va_start (ap, msgid);
-  here = locate_error (msgid, ap);
-  va_end (ap);
-
-  va_start (ap, msgid);
-  diagnostic_set_info (&diagnostic, msgid, &ap,
-                       location_of (here), pedantic_error_kind());
+  diagnostic_t dlevel;
+  switch (level)
+    {
+    case CPP_DL_WARNING:
+    case CPP_DL_WARNING_SYSHDR:
+      dlevel = DK_WARNING;
+      break;
+    case CPP_DL_PEDWARN:
+      dlevel = pedantic_error_kind ();
+      break;
+    case CPP_DL_ERROR:
+      dlevel = DK_ERROR;
+      break;
+    case CPP_DL_ICE:
+      dlevel = DK_ICE;
+      break;
+    default:
+      gcc_unreachable ();
+    }
+  diagnostic_set_info_translated (&diagnostic, msg, ap,
+				  input_location, dlevel);
   report_diagnostic (&diagnostic);
-  va_end (ap);
 }