pretty-print.h (pp_bar_bar): New.

	* pretty-print.h (pp_bar_bar): New.
	(pp_ampersand_ampersand): Likewise.
	(pp_less_equal): Likewise.
	(pp_greater_equal): Likewise.
	* gimple-pretty-print.c (dump_ternary_rhs): Use specialized pretty
	printer functions instead of pp_string or operators and punctuators.
	(dump_gimple_call): Likewise.
	(dump_gimple_omp_for): Likewise.
	(dump_gimple_transaction): Likewise.
	(dump_gimple_phi): Likewise.
	(pp_gimple_stmt_1): Likewise.
	* sched-vis.c (print_insn): Likewise.
	* tree-mudflap.c (mf_varname_tree): Likewise.
	* tree-pretty-print.c (dump_block_node): Likewise.
	(dump_generic_node): Likewise.

c-family/
	* c-ada-spec.c (pp_ada_tree_identifier): Use specialized pretty
	printer functions instead of pp_string or operators and punctuators.
	(dump_generic_ada_node): Likewise.
	* c-pretty-print.c (pp_c_type_specifier): Likewise.
	(pp_c_relational_expression): Likewise.
	(pp_c_logical_or_expression): Likewise.

cp/
	* error.c (dump_type_prefix): Use specialized pretty printer
	functions instead of pp_string or operators and punctuators.
	(dump_decl): Likewise.
	(dump_expr): Likewise.

From-SVN: r201474

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index dbac14039bef0224115fb7e7b3f1091e6393c746..a9f75d5df34455b9289672408d1c858a94681fd8 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,21 @@
+2013-08-03  Gabriel Dos Reis  <gdr@integrable-solutions.net>
+
+       * pretty-print.h (pp_bar_bar): New.
+       (pp_ampersand_ampersand): Likewise.
+       (pp_less_equal): Likewise.
+       (pp_greater_equal): Likewise.
+       * gimple-pretty-print.c (dump_ternary_rhs): Use specialized pretty
+       printer functions instead of pp_string or operators and punctuators.
+       (dump_gimple_call): Likewise.
+       (dump_gimple_omp_for): Likewise.
+       (dump_gimple_transaction): Likewise.
+       (dump_gimple_phi): Likewise.
+       (pp_gimple_stmt_1): Likewise.
+       * sched-vis.c (print_insn): Likewise.
+       * tree-mudflap.c (mf_varname_tree): Likewise.
+       * tree-pretty-print.c (dump_block_node): Likewise.
+       (dump_generic_node): Likewise.
+
 2013-08-02  Jan Hubicka  <jh@suse.cz>
 
        * lto-cgraph.c (compute_ltrans_boundary): Add abstract origins into

diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog
index d3b930611c4e88fc7732fbdaf4059f4a611d6ff6..019ee80736a878d29967e3e365bb632b8f8db900 100644 (file)
--- a/gcc/c-family/ChangeLog
+++ b/gcc/c-family/ChangeLog
@@ -1,3 +1,12 @@
+2013-08-03  Gabriel Dos Reis  <gdr@integrable-solutions.net>
+
+       * c-ada-spec.c (pp_ada_tree_identifier): Use specialized pretty
+       printer functions instead of pp_string or operators and punctuators.
+       (dump_generic_ada_node): Likewise.
+       * c-pretty-print.c (pp_c_type_specifier): Likewise.
+       (pp_c_relational_expression): Likewise.
+       (pp_c_logical_or_expression): Likewise.
+
 2013-08-03  Gabriel Dos Reis  <gdr@integrable-solutions.net>
 
        * c-ada-spec.c (print_ada_macros): Use specialized pretty printer

diff --git a/gcc/c-family/c-ada-spec.c b/gcc/c-family/c-ada-spec.c
index 1d0fcd2058f2c8ba38db4cb6761bab86ec475dbb..8670b94e9f9f58da5ba0411f2d2b497fe65b0ddc 100644 (file)
--- a/gcc/c-family/c-ada-spec.c
+++ b/gcc/c-family/c-ada-spec.c
@@ -1266,7 +1266,7 @@ pp_ada_tree_identifier (pretty_printer *buffer, tree node, tree type,
                 {
                   pp_string (buffer, "Class_");
                   pp_string (buffer, s);
-                  pp_string (buffer, ".");
+                  pp_dot (buffer);
                 }
 
             }
@@ -1626,7 +1626,7 @@ dump_sloc (pretty_printer *buffer, tree node)
   if (xloc.file)
     {
       pp_string (buffer, xloc.file);
-      pp_string (buffer, ":");
+      pp_colon (buffer);
       pp_decimal_int (buffer, xloc.line);
     }
 }
@@ -1886,14 +1886,14 @@ dump_generic_ada_node (pretty_printer *buffer, tree node, tree type,
              bool first = true;
              spc += INDENT_INCR;
              newline_and_indent (buffer, spc - 1);
-             pp_string (buffer, "(");
+             pp_left_paren (buffer);
              for (; value; value = TREE_CHAIN (value))
                {
                  if (first)
                    first = false;
                  else
                    {
-                     pp_string (buffer, ",");
+                     pp_comma (buffer);
                      newline_and_indent (buffer, spc);
                    }
 
@@ -1907,7 +1907,7 @@ dump_generic_ada_node (pretty_printer *buffer, tree node, tree type,
              dump_generic_ada_node
                (buffer, DECL_NAME (type) ? type : TYPE_NAME (node), type,
                 cpp_check, spc, 0, true);
-             pp_string (buffer, ")");
+             pp_right_paren (buffer);
            }
          else
            {
@@ -2032,7 +2032,7 @@ dump_generic_ada_node (pretty_printer *buffer, tree node, tree type,
                pp_string (buffer, "pragma Convention (C, ");
                dump_generic_ada_node
                  (buffer, type, 0, cpp_check, spc, false, true);
-               pp_string (buffer, ")");
+               pp_right_paren (buffer);
              }
        }
       else

diff --git a/gcc/c-family/c-pretty-print.c b/gcc/c-family/c-pretty-print.c
index 375f6dc907361936a526c3a7a1877d85af8c42c6..0a71ecee6e1c93a12a09a63821947b7af296a038 100644 (file)
--- a/gcc/c-family/c-pretty-print.c
+++ b/gcc/c-family/c-pretty-print.c
@@ -370,7 +370,7 @@ pp_c_type_specifier (c_pretty_printer *pp, tree t)
              pp_c_type_specifier (pp, t);
              if (TYPE_PRECISION (t) != prec)
                {
-                 pp_string (pp, ":");
+                 pp_colon (pp);
                  pp_decimal_int (pp, prec);
                }
            }
@@ -393,7 +393,7 @@ pp_c_type_specifier (c_pretty_printer *pp, tree t)
                  gcc_unreachable ();
                }
              pp_decimal_int (pp, prec);
-             pp_string (pp, ">");
+             pp_greater (pp);
            }
        }
       break;
@@ -1920,9 +1920,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_string (pp, "<=");
+       pp_less_equal (pp);
       else if (code == GE_EXPR)
-       pp_string (pp, ">=");
+       pp_greater_equal (pp);
       pp_c_whitespace (pp);
       pp_c_shift_expression (pp, TREE_OPERAND (e, 1));
       break;
@@ -2032,7 +2032,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_string (pp, "&&");
+      pp_ampersand_ampersand (pp);
       pp_c_whitespace (pp);
       pp_c_inclusive_or_expression (pp, TREE_OPERAND (e, 1));
     }
@@ -2052,7 +2052,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_string (pp, "||");
+      pp_bar_bar (pp);
       pp_c_whitespace (pp);
       pp_c_logical_and_expression (pp, TREE_OPERAND (e, 1));
     }

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 5587ac1eb968d4c0cafe49a442353c4495d4ee57..7a3de0bd3da6911aab1429672a8b4163ef8fc9f1 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,10 @@
+2013-08-03  Gabriel Dos Reis  <gdr@integrable-solutions.net>
+
+       * error.c (dump_type_prefix): Use specialized pretty printer
+       functions instead of pp_string or operators and punctuators.
+       (dump_decl): Likewise.
+       (dump_expr): Likewise.
+
 2013-08-03  Jason Merrill  <jason@redhat.com>
 
        DR 1286

diff --git a/gcc/cp/error.c b/gcc/cp/error.c
index a7fc9cc13f6815c6bafdf0ac86a449c3444c9e67..887a6ee064759cd11294effaed7443c6c31fdca1 100644 (file)
--- a/gcc/cp/error.c
+++ b/gcc/cp/error.c
@@ -714,7 +714,7 @@ dump_type_prefix (tree t, int flags)
        else if (TREE_CODE (t) == REFERENCE_TYPE)
        {
          if (TYPE_REF_IS_RVALUE (t))
-           pp_string (cxx_pp, "&&");
+           pp_ampersand_ampersand (cxx_pp);
          else
            pp_ampersand (cxx_pp);
        }
@@ -1060,7 +1060,7 @@ dump_decl (tree t, int flags)
 
     case SCOPE_REF:
       dump_type (TREE_OPERAND (t, 0), flags);
-      pp_string (cxx_pp, "::");
+      pp_colon_colon (cxx_pp);
       dump_decl (TREE_OPERAND (t, 1), TFF_UNQUALIFIED_NAME);
       break;
 
@@ -1075,9 +1075,9 @@ dump_decl (tree t, int flags)
       dump_decl (ARRAY_NOTATION_ARRAY (t), flags | TFF_EXPR_IN_PARENS);
       pp_cxx_left_bracket (cxx_pp);
       dump_decl (ARRAY_NOTATION_START (t), flags | TFF_EXPR_IN_PARENS);
-      pp_string (cxx_pp, ":");
+      pp_colon (cxx_pp);
       dump_decl (ARRAY_NOTATION_LENGTH (t), flags | TFF_EXPR_IN_PARENS);
-      pp_string (cxx_pp, ":");
+      pp_colon (cxx_pp);
       dump_decl (ARRAY_NOTATION_STRIDE (t), flags | TFF_EXPR_IN_PARENS);
       pp_cxx_right_bracket (cxx_pp);
       break;
@@ -2072,9 +2072,9 @@ dump_expr (tree t, int flags)
       dump_expr (ARRAY_NOTATION_ARRAY (t), flags | TFF_EXPR_IN_PARENS);
       pp_cxx_left_bracket (cxx_pp);
       dump_expr (ARRAY_NOTATION_START (t), flags | TFF_EXPR_IN_PARENS);
-      pp_string (cxx_pp, ":");
+      pp_colon (cxx_pp);
       dump_expr (ARRAY_NOTATION_LENGTH (t), flags | TFF_EXPR_IN_PARENS);
-      pp_string (cxx_pp, ":");
+      pp_colon (cxx_pp);
       dump_expr (ARRAY_NOTATION_STRIDE (t), flags | TFF_EXPR_IN_PARENS);
       pp_cxx_right_bracket (cxx_pp);
       break;

diff --git a/gcc/gimple-pretty-print.c b/gcc/gimple-pretty-print.c
index 6f53932e18175bd0fb45455ba20c3fa65a87f164..436553a988e3a10d483adc5747f12e86fdac4730 100644 (file)
--- a/gcc/gimple-pretty-print.c
+++ b/gcc/gimple-pretty-print.c
@@ -436,7 +436,7 @@ dump_ternary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
       pp_string (buffer, ", ");
       dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
-      pp_string (buffer, ">");
+      pp_greater (buffer);
       break;
     
     case VEC_PERM_EXPR:
@@ -446,7 +446,7 @@ dump_ternary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
       pp_string (buffer, ", ");
       dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
-      pp_string (buffer, ">");
+      pp_greater (buffer);
       break;
 
     case REALIGN_LOAD_EXPR:
@@ -456,7 +456,7 @@ dump_ternary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
       pp_string (buffer, ", ");
       dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
-      pp_string (buffer, ">");
+      pp_greater (buffer);
       break;
 
     case COND_EXPR:
@@ -474,7 +474,7 @@ dump_ternary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
       pp_string (buffer, ", ");
       dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
-      pp_string (buffer, ">");
+      pp_greater (buffer);
       break;
 
     default:
@@ -757,7 +757,7 @@ dump_gimple_call (pretty_printer *buffer, gimple gs, int spc, int flags)
       if (props & PR_READONLY)
        pp_string (buffer, "readOnly ");
 
-      pp_string (buffer, "]");
+      pp_right_bracket (buffer);
     }
 }
 
@@ -1145,10 +1145,10 @@ dump_gimple_omp_for (pretty_printer *buffer, gimple gs, int spc, int flags)
              pp_greater (buffer);
              break;
            case LE_EXPR:
-             pp_string (buffer, "<=");
+             pp_less_equal (buffer);
              break;
            case GE_EXPR:
-             pp_string (buffer, ">=");
+             pp_greater_equal (buffer);
              break;
            default:
              gcc_unreachable ();
@@ -1420,7 +1420,7 @@ dump_gimple_transaction (pretty_printer *buffer, gimple gs, int spc, int flags)
                }
              if (subcode)
                pp_printf (buffer, "0x%x ", subcode);
-             pp_string (buffer, "]");
+             pp_right_bracket (buffer);
            }
        }
 
@@ -1641,7 +1641,7 @@ dump_gimple_phi (pretty_printer *buffer, gimple phi, int spc, int flags)
              pp_string (buffer, " : ");
            }
          pp_decimal_int (buffer, xloc.line);
-         pp_string (buffer, ":");
+         pp_colon (buffer);
          pp_decimal_int (buffer, xloc.column);
          pp_string (buffer, "] ");
        }
@@ -1881,7 +1881,7 @@ pp_gimple_stmt_1 (pretty_printer *buffer, gimple gs, int spc, int flags)
          pp_string (buffer, " : ");
        }
       pp_decimal_int (buffer, xloc.line);
-      pp_string (buffer, ":");
+      pp_colon (buffer);
       pp_decimal_int (buffer, xloc.column);
       pp_string (buffer, "] ");
     }

diff --git a/gcc/pretty-print.h b/gcc/pretty-print.h
index f72c23598106f2462995b9620aafb8aaf4ae9062..71489e6ad70bb43147dfd7ef7a3a66b8422038ea 100644 (file)
--- a/gcc/pretty-print.h
+++ b/gcc/pretty-print.h
@@ -246,10 +246,14 @@ pp_base_get_prefix (const pretty_printer *pp) { return pp->prefix; }
 #define pp_equal(PP)            pp_character (PP, '=')
 #define pp_question(PP)         pp_character (PP, '?')
 #define pp_bar(PP)              pp_character (PP, '|')
+#define pp_bar_bar(PP)          pp_string (PP, "||")
 #define pp_carret(PP)           pp_character (PP, '^')
 #define pp_ampersand(PP)        pp_character (PP, '&')
+#define pp_ampersand_ampersand(PP) pp_string (PP, "&&")
 #define pp_less(PP)             pp_character (PP, '<')
+#define pp_less_equal(PP)       pp_string (PP, "<=")
 #define pp_greater(PP)          pp_character (PP, '>')
+#define pp_greater_equal(PP)    pp_string (PP, ">=")
 #define pp_plus(PP)             pp_character (PP, '+')
 #define pp_minus(PP)            pp_character (PP, '-')
 #define pp_star(PP)             pp_character (PP, '*')

diff --git a/gcc/sched-vis.c b/gcc/sched-vis.c
index d11a3858378bd550494e7c4ca9f0ea204c3bead6..3211eafa7984b26c91d97d2397cc993a37d91901 100644 (file)
--- a/gcc/sched-vis.c
+++ b/gcc/sched-vis.c
@@ -690,7 +690,7 @@ print_insn (pretty_printer *pp, const_rtx x, int verbose)
     case JUMP_TABLE_DATA:
       pp_string (pp, "jump_table_data{\n");
       print_pattern (pp, PATTERN (x), verbose);
-      pp_string (pp, "}");
+      pp_right_brace (pp);
       break;
     case BARRIER:
       pp_string (pp, "barrier");

diff --git a/gcc/tree-mudflap.c b/gcc/tree-mudflap.c
index b250bfefadb33aa3cea75c99e26940544baaccfd..ae51e6c6748c62d1f06526e1f4b66f2393f98396 100644 (file)
--- a/gcc/tree-mudflap.c
+++ b/gcc/tree-mudflap.c
@@ -138,12 +138,12 @@ mf_varname_tree (tree decl)
 
     if (sourceline != 0)
       {
-        pp_string (buf, ":");
+        pp_colon (buf);
         pp_decimal_int (buf, sourceline);
 
         if (sourcecolumn != 0)
           {
-            pp_string (buf, ":");
+            pp_colon (buf);
             pp_decimal_int (buf, sourcecolumn);
           }
       }
@@ -165,7 +165,7 @@ mf_varname_tree (tree decl)
       pp_string (buf, ") ");
     }
   else
-    pp_string (buf, " ");
+    pp_space (buf);
 
   /* Add <variable-declaration>, possibly demangled.  */
   {

diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c
index d31d97fd1646f8ddeb192e3007464bd1e4a1b0e6..99927b8808f653b1c85658155f9a9aa280b26c8c 100644 (file)
--- a/gcc/tree-pretty-print.c
+++ b/gcc/tree-pretty-print.c
@@ -519,7 +519,7 @@ dump_block_node (pretty_printer *buffer, tree block, int spc, int flags)
       for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
        {
          dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);
-         pp_string (buffer, " ");
+         pp_space (buffer);
        }
       newline_and_indent (buffer, spc + 2);
     }
@@ -530,7 +530,7 @@ dump_block_node (pretty_printer *buffer, tree block, int spc, int flags)
       for (t = BLOCK_CHAIN (block); t; t = BLOCK_CHAIN (t))
        {
          dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);
-         pp_string (buffer, " ");
+         pp_space (buffer);
        }
       newline_and_indent (buffer, spc + 2);
     }
@@ -541,7 +541,7 @@ dump_block_node (pretty_printer *buffer, tree block, int spc, int flags)
       for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))
        {
          dump_generic_node (buffer, t, 0, flags, false);
-         pp_string (buffer, " ");
+         pp_space (buffer);
        }
       newline_and_indent (buffer, spc + 2);
     }
@@ -555,7 +555,7 @@ dump_block_node (pretty_printer *buffer, tree block, int spc, int flags)
       FOR_EACH_VEC_ELT (*nlv, i, t)
        {
          dump_generic_node (buffer, t, 0, flags, false);
-         pp_string (buffer, " ");
+         pp_space (buffer);
        }
       newline_and_indent (buffer, spc + 2);
     }
@@ -582,7 +582,7 @@ dump_block_node (pretty_printer *buffer, tree block, int spc, int flags)
       for (t = BLOCK_FRAGMENT_CHAIN (block); t; t = BLOCK_FRAGMENT_CHAIN (t))
        {
          dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);
-         pp_string (buffer, " ");
+         pp_space (buffer);
        }
       newline_and_indent (buffer, spc + 2);
     }
@@ -757,7 +757,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
                                        ? "<unnamed-unsigned:"
                                        : "<unnamed-signed:"));
                    pp_decimal_int (buffer, TYPE_PRECISION (node));
-                   pp_string (buffer, ">");
+                   pp_greater (buffer);
                  }
              }
            else if (TREE_CODE (node) == COMPLEX_TYPE)
@@ -769,14 +769,14 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
              {
                pp_string (buffer, "<float:");
                pp_decimal_int (buffer, TYPE_PRECISION (node));
-               pp_string (buffer, ">");
+               pp_greater (buffer);
              }
            else if (TREE_CODE (node) == FIXED_POINT_TYPE)
              {
                pp_string (buffer, "<fixed-point-");
                pp_string (buffer, TYPE_SATURATING (node) ? "sat:" : "nonsat:");
                pp_decimal_int (buffer, TYPE_PRECISION (node));
-               pp_string (buffer, ">");
+               pp_greater (buffer);
              }
            else if (TREE_CODE (node) == VOID_TYPE)
              pp_string (buffer, "void");
@@ -832,7 +832,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
            {
              pp_string (buffer, " <address-space-");
              pp_decimal_int (buffer, TYPE_ADDR_SPACE (node));
-             pp_string (buffer, ">");
+             pp_greater (buffer);
            }
 
          if (TYPE_REF_CAN_ALIAS_ALL (node))
@@ -868,7 +868,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
          {
            if (TREE_CODE (TREE_OPERAND (node, 0)) != ADDR_EXPR)
              {
-               pp_string (buffer, "*");
+               pp_star (buffer);
                dump_generic_node (buffer, TREE_OPERAND (node, 0),
                                   spc, flags, false);
              }
@@ -882,11 +882,11 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
            tree ptype;
 
            pp_string (buffer, "MEM[");
-           pp_string (buffer, "(");
+           pp_left_paren (buffer);
            ptype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node, 1)));
            dump_generic_node (buffer, ptype,
                               spc, flags | TDF_SLIM, false);
-           pp_string (buffer, ")");
+           pp_right_paren (buffer);
            dump_generic_node (buffer, TREE_OPERAND (node, 0),
                               spc, flags, false);
            if (!integer_zerop (TREE_OPERAND (node, 1)))
@@ -895,7 +895,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
                dump_generic_node (buffer, TREE_OPERAND (node, 1),
                                   spc, flags, false);
              }
-           pp_string (buffer, "]");
+           pp_right_bracket (buffer);
          }
        break;
       }
@@ -954,7 +954,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
            pp_string (buffer, "offset: ");
            dump_generic_node (buffer, tmp, spc, flags, false);
          }
-       pp_string (buffer, "]");
+       pp_right_bracket (buffer);
       }
       break;
 
@@ -1102,7 +1102,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
       pp_string (buffer, ", ");
       dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);
-      pp_string (buffer, ")");
+      pp_right_paren (buffer);
       break;
 
     case STRING_CST:
@@ -1137,7 +1137,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
                            flags);
          else
            pp_string (buffer, "<null method basetype>");
-         pp_string (buffer, "::");
+         pp_colon_colon (buffer);
        }
       if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
        dump_decl_name (buffer, TYPE_NAME (node), flags);
@@ -1263,7 +1263,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
       pp_string (buffer, ", ");
       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
-      pp_string (buffer, ">");
+      pp_greater (buffer);
       break;
 
     case ARRAY_REF:
@@ -1801,64 +1801,64 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
       pp_string (buffer, ", ");
       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
-      pp_string (buffer, ">");
+      pp_greater (buffer);
       break;
 
     case CONJ_EXPR:
       pp_string (buffer, "CONJ_EXPR <");
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
-      pp_string (buffer, ">");
+      pp_greater (buffer);
       break;
 
     case REALPART_EXPR:
       pp_string (buffer, "REALPART_EXPR <");
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
-      pp_string (buffer, ">");
+      pp_greater (buffer);
       break;
 
     case IMAGPART_EXPR:
       pp_string (buffer, "IMAGPART_EXPR <");
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
-      pp_string (buffer, ">");
+      pp_greater (buffer);
       break;
 
     case VA_ARG_EXPR:
       pp_string (buffer, "VA_ARG_EXPR <");
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
-      pp_string (buffer, ">");
+      pp_greater (buffer);
       break;
 
     case TRY_FINALLY_EXPR:
     case TRY_CATCH_EXPR:
       pp_string (buffer, "try");
       newline_and_indent (buffer, spc+2);
-      pp_string (buffer, "{");
+      pp_left_brace (buffer);
       newline_and_indent (buffer, spc+4);
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
       newline_and_indent (buffer, spc+2);
-      pp_string (buffer, "}");
+      pp_right_brace (buffer);
       newline_and_indent (buffer, spc);
       pp_string (buffer,
                         (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
       newline_and_indent (buffer, spc+2);
-      pp_string (buffer, "{");
+      pp_left_brace (buffer);
       newline_and_indent (buffer, spc+4);
       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
       newline_and_indent (buffer, spc+2);
-      pp_string (buffer, "}");
+      pp_right_brace (buffer);
       is_expr = false;
       break;
 
     case CATCH_EXPR:
       pp_string (buffer, "catch (");
       dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
-      pp_string (buffer, ")");
+      pp_right_paren (buffer);
       newline_and_indent (buffer, spc+2);
-      pp_string (buffer, "{");
+      pp_left_brace (buffer);
       newline_and_indent (buffer, spc+4);
       dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
       newline_and_indent (buffer, spc+2);
-      pp_string (buffer, "}");
+      pp_right_brace (buffer);
       is_expr = false;
       break;
 
@@ -1867,11 +1867,11 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
       pp_string (buffer, ")>>>");
       newline_and_indent (buffer, spc+2);
-      pp_string (buffer, "{");
+      pp_left_brace (buffer);
       newline_and_indent (buffer, spc+4);
       dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
       newline_and_indent (buffer, spc+2);
-      pp_string (buffer, "}");
+      pp_right_brace (buffer);
       is_expr = false;
       break;
 
@@ -2006,7 +2006,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
          pp_colon (buffer);
          dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
        }
-      pp_string (buffer, ")");
+      pp_right_paren (buffer);
       break;
 
     case CASE_LABEL_EXPR:
@@ -2041,7 +2041,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       if (SSA_NAME_IDENTIFIER (node))
        dump_generic_node (buffer, SSA_NAME_IDENTIFIER (node),
                           spc, flags, false);
-      pp_string (buffer, "_");
+      pp_underscore (buffer);
       pp_decimal_int (buffer, SSA_NAME_VERSION (node));
       if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
        pp_string (buffer, "(ab)");
@@ -2054,7 +2054,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
       pp_string (buffer, ", ");
       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
-      pp_string (buffer, ">");
+      pp_greater (buffer);
       break;
 
     case ASSERT_EXPR:
@@ -2062,7 +2062,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);
       pp_string (buffer, ", ");
       dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);
-      pp_string (buffer, ">");
+      pp_greater (buffer);
       break;
 
     case SCEV_KNOWN:
@@ -2074,7 +2074,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       break;
 
     case POLYNOMIAL_CHREC:
-      pp_string (buffer, "{");
+      pp_left_brace (buffer);
       dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
       pp_string (buffer, ", +, ");
       dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
@@ -2090,7 +2090,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
       pp_string (buffer, ", ");
       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
-      pp_string (buffer, ">");
+      pp_greater (buffer);
       break;
 
     case VEC_COND_EXPR:
@@ -2206,7 +2206,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
              pp_string (buffer, "; ");
              dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INCR (node), i),
                                 spc, flags, false);
-             pp_string (buffer, ")");
+             pp_right_paren (buffer);
            }
          if (OMP_FOR_BODY (node))
            {
@@ -2935,7 +2935,7 @@ print_call_name (pretty_printer *buffer, tree node, int flags)
       goto again;
 
     case COND_EXPR:
-      pp_string (buffer, "(");
+      pp_left_paren (buffer);
       dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, flags, false);
       pp_string (buffer, ") ? ");
       dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, flags, false);