From 73bbafe5785c1bcf6ee98c650d91dd78382ee5eb Mon Sep 17 00:00:00 2001 From: Gabriel Dos Reis Date: Sun, 27 Jun 2004 15:20:41 +0000 Subject: [PATCH] error.c (pp_template_argument_list_start): Remove. * error.c (pp_template_argument_list_start): Remove. (pp_template_argument_list_end): Likewise. (pp_separate_with_comma): Use pp_cxx_separate_with. (reinit_global_formatting_buffer): Remove. (pp_non_consecutive_character): Likewise. (dump_scope): Use pp_cxx_colon_colon. (dump_template_parameter): Use pp_cxx_identifier, pp_cxx_tree_identifier and pp_cxx_whitespace. (dump_templat_bindings): Replace use of pp_string with sequence of pp_cxx_whitespace and pp_equal. (dump_type): Use pp_cxx_identifier, pp_cxx_tree_identifier, pp_cxx_colon_colon, pp_cxx_whitespace throughout. Don't set padding here. (dump_aggr_type): Use pp_cxx_identifier amd pp_cxx_tree_identifier. (dump_type_prefix): Don't set padding. Use pp_cxx_whitespace, pp_cxx_left_parent, pp_cxx_colon_colon and pp_cxx_star troughout. (dump_type_suffix): Use pp_cxx_right_paren, pp_cxx_left_bracket, pp_cxx_right_bracket, pp_cxx_identifier throughout, (dump_decl): Likewise. (dump_template_decl): Likewise. (dump_function_decl): Likewise. Set padding as appropriate. (dump_parameters): Use pp_cxx_left_paren, pp_cxx_identifier and pp_cxx_right_paren. (dump_exception_spec): Likewise. (dump_function_name): Use pp_cxx_tree_identifier and pp_cxx_identifier. (dump_template_parms): Use pp_cxx_begin_template_argument_list and pp_cxx_end_template_argument_list. (dump_expr): Use pp_cxx_left_paren, pp_cxx_right_paren, pp_cxx_colon_colon, pp_cxx_identifier, pp_cxx_tree_identifier and pp_cxx_whitespace throughout. (dump_binary_op): Use pp_cxx_whitespace, pp_cxx_left_paren and pp_cxx_right_paren. (dump_unary_op): Likewise. (reinit_cxx_pp): New function. (type_as_string); Use it. (expr_as_string): Likewise. (decl_as_string); Likewise. (context_as_string): Likewise. (lang_decl_name): Likewise. (decl_to_string): Likewise. (expr_to_string): Likewise. (parm_to_string): Likewise. (type_to_string): Likewise. (args_to_string): Likewise. (cv_to_string): Likewise. From-SVN: r83732 --- gcc/cp/ChangeLog | 49 +++++++ gcc/cp/error.c | 409 ++++++++++++++++++++++++++++--------------------------- 2 files changed, 259 insertions(+), 199 deletions(-) diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 77aeeb0..92eb2c7 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,52 @@ +2004-06-27 Gabriel Dos Reis + + * error.c (pp_template_argument_list_start): Remove. + (pp_template_argument_list_end): Likewise. + (pp_separate_with_comma): Use pp_cxx_separate_with. + (reinit_global_formatting_buffer): Remove. + (pp_non_consecutive_character): Likewise. + (dump_scope): Use pp_cxx_colon_colon. + (dump_template_parameter): Use pp_cxx_identifier, + pp_cxx_tree_identifier and pp_cxx_whitespace. + (dump_templat_bindings): Replace use of pp_string with sequence + of pp_cxx_whitespace and pp_equal. + (dump_type): Use pp_cxx_identifier, pp_cxx_tree_identifier, + pp_cxx_colon_colon, pp_cxx_whitespace throughout. Don't set + padding here. + (dump_aggr_type): Use pp_cxx_identifier amd pp_cxx_tree_identifier. + (dump_type_prefix): Don't set padding. Use pp_cxx_whitespace, + pp_cxx_left_parent, pp_cxx_colon_colon and pp_cxx_star troughout. + (dump_type_suffix): Use pp_cxx_right_paren, pp_cxx_left_bracket, + pp_cxx_right_bracket, pp_cxx_identifier throughout, + (dump_decl): Likewise. + (dump_template_decl): Likewise. + (dump_function_decl): Likewise. Set padding as appropriate. + (dump_parameters): Use pp_cxx_left_paren, pp_cxx_identifier and + pp_cxx_right_paren. + (dump_exception_spec): Likewise. + (dump_function_name): Use pp_cxx_tree_identifier and + pp_cxx_identifier. + (dump_template_parms): Use pp_cxx_begin_template_argument_list and + pp_cxx_end_template_argument_list. + (dump_expr): Use pp_cxx_left_paren, pp_cxx_right_paren, + pp_cxx_colon_colon, pp_cxx_identifier, pp_cxx_tree_identifier and + pp_cxx_whitespace throughout. + (dump_binary_op): Use pp_cxx_whitespace, pp_cxx_left_paren and + pp_cxx_right_paren. + (dump_unary_op): Likewise. + (reinit_cxx_pp): New function. + (type_as_string); Use it. + (expr_as_string): Likewise. + (decl_as_string); Likewise. + (context_as_string): Likewise. + (lang_decl_name): Likewise. + (decl_to_string): Likewise. + (expr_to_string): Likewise. + (parm_to_string): Likewise. + (type_to_string): Likewise. + (args_to_string): Likewise. + (cv_to_string): Likewise. + 2004-06-26 Mark Mitchell * cp-tree.h (cp_cv_quals): New type. diff --git a/gcc/cp/error.c b/gcc/cp/error.c index 6e18650..81bba56 100644 --- a/gcc/cp/error.c +++ b/gcc/cp/error.c @@ -32,11 +32,7 @@ Boston, MA 02111-1307, USA. */ #include "langhooks-def.h" #include "cxx-pretty-print.h" -#define pp_template_argument_list_start(PP) \ - pp_non_consecutive_character (PP, '<') -#define pp_template_argument_list_end(PP) \ - pp_non_consecutive_character (PP, '>') -#define pp_separate_with_comma(PP) pp_string (PP, ", ") +#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 @@ -46,9 +42,6 @@ static cxx_pretty_printer scratch_pretty_printer; # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T))) -#define reinit_global_formatting_buffer() \ - pp_clear_output_area (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); @@ -95,7 +88,6 @@ static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *); static void cp_print_error_function (diagnostic_context *, diagnostic_info *); static bool cp_printer (pretty_printer *, text_info *); -static void pp_non_consecutive_character (cxx_pretty_printer *, int); static tree locate_error (const char *, va_list); static location_t location_of (tree); @@ -125,18 +117,18 @@ dump_scope (tree scope, int flags) if (scope != global_namespace) { dump_decl (scope, f); - pp_colon_colon (cxx_pp); + pp_cxx_colon_colon (cxx_pp); } } else if (AGGREGATE_TYPE_P (scope)) { dump_type (scope, f); - pp_colon_colon (cxx_pp); + pp_cxx_colon_colon (cxx_pp); } else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL) { dump_function_decl (scope, f); - pp_colon_colon (cxx_pp); + pp_cxx_colon_colon (cxx_pp); } } @@ -182,15 +174,12 @@ dump_template_parameter (tree parm, int flags) { if (flags & TFF_DECL_SPECIFIERS) { - pp_identifier (cxx_pp, "class"); + pp_cxx_identifier (cxx_pp, "class"); if (DECL_NAME (p)) - { - pp_space (cxx_pp); - pp_tree_identifier (cxx_pp, DECL_NAME (p)); - } + pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p)); } else if (DECL_NAME (p)) - pp_tree_identifier (cxx_pp, DECL_NAME (p)); + pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p)); else pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p)); } @@ -199,7 +188,9 @@ dump_template_parameter (tree parm, int flags) if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE) { - pp_string (cxx_pp, " = "); + 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); else @@ -238,7 +229,9 @@ dump_template_bindings (tree parms, tree args) if (need_comma) pp_separate_with_comma (cxx_pp); dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER); - pp_string (cxx_pp, " = "); + pp_cxx_whitespace (cxx_pp); + pp_equal (cxx_pp); + pp_cxx_whitespace (cxx_pp); if (arg) dump_template_argument (arg, TFF_PLAIN_IDENTIFIER); else @@ -276,7 +269,7 @@ dump_type (tree t, int flags) break; case IDENTIFIER_NODE: - pp_tree_identifier (cxx_pp, t); + pp_cxx_tree_identifier (cxx_pp, t); break; case TREE_VEC: @@ -309,14 +302,13 @@ dump_type (tree t, int flags) case BOOLEAN_TYPE: case COMPLEX_TYPE: case VECTOR_TYPE: - pp_base (cxx_pp)->padding = pp_none; pp_type_specifier_seq (cxx_pp, t); break; case TEMPLATE_TEMPLATE_PARM: /* For parameters inside template signature. */ if (TYPE_IDENTIFIER (t)) - pp_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t)); + pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t)); else pp_cxx_canonical_template_parameter (cxx_pp, t); break; @@ -324,17 +316,17 @@ dump_type (tree t, int flags) case BOUND_TEMPLATE_TEMPLATE_PARM: { tree args = TYPE_TI_ARGS (t); - pp_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t)); - pp_template_argument_list_start (cxx_pp); + pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t)); + pp_cxx_begin_template_argument_list (cxx_pp); dump_template_argument_list (args, flags); - pp_template_argument_list_end (cxx_pp); + pp_cxx_end_template_argument_list (cxx_pp); } break; case TEMPLATE_TYPE_PARM: pp_cxx_cv_qualifier_seq (cxx_pp, t); if (TYPE_IDENTIFIER (t)) - pp_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t)); + pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t)); else pp_cxx_canonical_template_parameter (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t)); @@ -356,21 +348,23 @@ dump_type (tree t, int flags) } case TYPENAME_TYPE: pp_cxx_cv_qualifier_seq (cxx_pp, t); - pp_string (cxx_pp, "typename "); + pp_cxx_identifier (cxx_pp, "typename"); dump_typename (t, flags); break; case UNBOUND_CLASS_TEMPLATE: dump_type (TYPE_CONTEXT (t), flags); - pp_colon_colon (cxx_pp); - pp_identifier (cxx_pp, "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: - pp_string (cxx_pp, "__typeof ("); + 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_right_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); break; default: @@ -395,7 +389,7 @@ dump_typename (tree t, int flags) dump_typename (ctx, flags); else dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM); - pp_colon_colon (cxx_pp); + pp_cxx_colon_colon (cxx_pp); dump_decl (TYPENAME_TYPE_FULLNAME (t), flags); } @@ -428,10 +422,7 @@ dump_aggr_type (tree t, int flags) pp_cxx_cv_qualifier_seq (cxx_pp, t); if (flags & TFF_CLASS_KEY_OR_ENUM) - { - pp_identifier (cxx_pp, variety); - pp_space (cxx_pp); - } + pp_cxx_identifier (cxx_pp, variety); if (flags & TFF_CHASE_TYPEDEF) t = TYPE_MAIN_VARIANT (t); @@ -469,7 +460,7 @@ dump_aggr_type (tree t, int flags) pp_printf (pp_base (cxx_pp), "", variety); } else - pp_tree_identifier (cxx_pp, name); + pp_cxx_tree_identifier (cxx_pp, name); if (tmplate) dump_template_parms (TYPE_TEMPLATE_INFO (t), !CLASSTYPE_USE_TEMPLATE (t), @@ -490,8 +481,6 @@ dump_aggr_type (tree t, int flags) static void dump_type_prefix (tree t, int flags) { - pp_base (cxx_pp)->padding = pp_none; - if (TYPE_PTRMEMFUNC_P (t)) { t = TYPE_PTRMEMFUNC_FN_TYPE (t); @@ -508,8 +497,8 @@ dump_type_prefix (tree t, int flags) dump_type_prefix (sub, flags); if (TREE_CODE (sub) == ARRAY_TYPE) { - pp_space (cxx_pp); - pp_left_paren (cxx_pp); + 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; @@ -524,9 +513,9 @@ dump_type_prefix (tree t, int flags) { pp_maybe_space (cxx_pp); dump_type (TYPE_OFFSET_BASETYPE (t), flags); - pp_colon_colon (cxx_pp); + pp_cxx_colon_colon (cxx_pp); } - pp_star (cxx_pp); + pp_cxx_star (cxx_pp); pp_cxx_cv_qualifier_seq (cxx_pp, t); break; @@ -535,15 +524,15 @@ dump_type_prefix (tree t, int flags) case FUNCTION_TYPE: dump_type_prefix (TREE_TYPE (t), flags); pp_maybe_space (cxx_pp); - pp_left_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); break; case METHOD_TYPE: dump_type_prefix (TREE_TYPE (t), flags); pp_maybe_space (cxx_pp); - pp_left_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags); - pp_colon_colon (cxx_pp); + pp_cxx_colon_colon (cxx_pp); break; case ARRAY_TYPE: @@ -597,7 +586,7 @@ dump_type_suffix (tree t, int flags) case REFERENCE_TYPE: case OFFSET_TYPE: if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE) - pp_right_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); dump_type_suffix (TREE_TYPE (t), flags); break; @@ -606,7 +595,7 @@ dump_type_suffix (tree t, int flags) case METHOD_TYPE: { tree arg; - pp_right_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); arg = TYPE_ARG_TYPES (t); if (TREE_CODE (t) == METHOD_TYPE) arg = TREE_CHAIN (arg); @@ -624,7 +613,7 @@ dump_type_suffix (tree t, int flags) } case ARRAY_TYPE: - pp_left_bracket (cxx_pp); + pp_cxx_left_bracket (cxx_pp); if (TYPE_DOMAIN (t)) { if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0)) @@ -639,7 +628,7 @@ dump_type_suffix (tree t, int flags) integer_one_node)), flags & ~TFF_EXPR_IN_PARENS); } - pp_right_bracket (cxx_pp); + pp_cxx_right_bracket (cxx_pp); dump_type_suffix (TREE_TYPE (t), flags); break; @@ -724,14 +713,14 @@ dump_decl (tree t, int flags) if ((flags & TFF_DECL_SPECIFIERS) && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM) /* Say `class T' not just `T'. */ - pp_string (cxx_pp, "class "); + pp_cxx_identifier (cxx_pp, "class"); dump_type (TREE_TYPE (t), flags); break; } } if (flags & TFF_DECL_SPECIFIERS) - pp_string (cxx_pp, "typedef "); + pp_cxx_identifier (cxx_pp, "typedef"); dump_simple_decl (t, DECL_ORIGINAL_TYPE (t) ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags); @@ -766,7 +755,7 @@ dump_decl (tree t, int flags) if (DECL_NAME (t) == NULL_TREE) pp_identifier (cxx_pp, ""); else - pp_tree_identifier (cxx_pp, DECL_NAME (t)); + pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t)); } break; @@ -778,9 +767,9 @@ dump_decl (tree t, int flags) case ARRAY_REF: dump_decl (TREE_OPERAND (t, 0), flags); - pp_left_bracket (cxx_pp); + pp_cxx_left_bracket (cxx_pp); dump_decl (TREE_OPERAND (t, 1), flags); - pp_right_bracket (cxx_pp); + pp_cxx_right_bracket (cxx_pp); break; /* So that we can do dump_decl on an aggr type. */ @@ -793,7 +782,7 @@ 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. */ - pp_complement (cxx_pp); + pp_cxx_complement (cxx_pp); dump_type (TREE_OPERAND (t, 0), flags); break; @@ -806,13 +795,13 @@ dump_decl (tree t, int flags) case IDENTIFIER_NODE: if (IDENTIFIER_TYPENAME_P (t)) { - pp_string (cxx_pp, "operator "); + pp_cxx_identifier (cxx_pp, "operator"); /* Not exactly IDENTIFIER_TYPE_VALUE. */ dump_type (TREE_TYPE (t), flags); break; } else - pp_tree_identifier (cxx_pp, t); + pp_cxx_tree_identifier (cxx_pp, t); break; case OVERLOAD: @@ -822,12 +811,12 @@ dump_decl (tree t, int flags) if (DECL_CLASS_SCOPE_P (t)) { dump_type (DECL_CONTEXT (t), flags); - pp_colon_colon (cxx_pp); + pp_cxx_colon_colon (cxx_pp); } else if (DECL_CONTEXT (t)) { dump_decl (DECL_CONTEXT (t), flags); - pp_colon_colon (cxx_pp); + pp_cxx_colon_colon (cxx_pp); } dump_decl (DECL_NAME (t), flags); break; @@ -858,15 +847,15 @@ dump_decl (tree t, int flags) if (is_overloaded_fn (name)) name = DECL_NAME (get_first_fn (name)); dump_decl (name, flags); - pp_template_argument_list_start (cxx_pp); + pp_cxx_begin_template_argument_list (cxx_pp); if (TREE_OPERAND (t, 1)) dump_template_argument_list (TREE_OPERAND (t, 1), flags); - pp_template_argument_list_end (cxx_pp); + pp_cxx_end_template_argument_list (cxx_pp); } break; case LABEL_DECL: - pp_tree_identifier (cxx_pp, DECL_NAME (t)); + pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t)); break; case CONST_DECL: @@ -883,9 +872,9 @@ dump_decl (tree t, int flags) break; case USING_DECL: - pp_string (cxx_pp, "using "); + pp_cxx_identifier (cxx_pp, "using"); dump_type (DECL_INITIAL (t), flags); - pp_colon_colon (cxx_pp); + pp_cxx_colon_colon (cxx_pp); dump_decl (DECL_NAME (t), flags); break; @@ -933,7 +922,8 @@ dump_template_decl (tree t, int flags) tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms); int len = TREE_VEC_LENGTH (inner_parms); - pp_string (cxx_pp, "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. */ @@ -945,14 +935,14 @@ dump_template_decl (tree t, int flags) pp_separate_with_comma (cxx_pp); dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags); } - pp_template_argument_list_end (cxx_pp); - pp_space (cxx_pp); + 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 class TT' not just `template TT'. */ - pp_string (cxx_pp, "class "); + pp_cxx_identifier (cxx_pp, "class"); } if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL) @@ -1022,25 +1012,22 @@ dump_function_decl (tree t, int flags) if (!(flags & TFF_DECL_SPECIFIERS)) /* OK */; else if (DECL_STATIC_FUNCTION_P (t)) - pp_identifier (cxx_pp, "static "); + pp_cxx_identifier (cxx_pp, "static"); else if (DECL_VIRTUAL_P (t)) - pp_identifier (cxx_pp, "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); if (show_return) - { - dump_type_prefix (TREE_TYPE (fntype), flags); - pp_space (cxx_pp); - } + dump_type_prefix (TREE_TYPE (fntype), flags); /* Print the function name. */ if (cname) { dump_type (cname, flags); - pp_colon_colon (cxx_pp); + pp_cxx_colon_colon (cxx_pp); } else dump_scope (CP_DECL_CONTEXT (t), flags); @@ -1052,11 +1039,17 @@ dump_function_decl (tree t, int flags) dump_parameters (parmtypes, flags); if (TREE_CODE (fntype) == METHOD_TYPE) - pp_cxx_cv_qualifier_seq - (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)))); + { + 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); @@ -1065,9 +1058,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) { - pp_string (cxx_pp, " [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); - pp_right_bracket (cxx_pp); + pp_cxx_right_bracket (cxx_pp); } } @@ -1080,7 +1076,7 @@ dump_parameters (tree parmtypes, int flags) { int first; - pp_left_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); for (first = 1; parmtypes != void_list_node; parmtypes = TREE_CHAIN (parmtypes)) @@ -1090,19 +1086,21 @@ dump_parameters (tree parmtypes, int flags) first = 0; if (!parmtypes) { - pp_identifier (cxx_pp, "..."); + pp_cxx_identifier (cxx_pp, "..."); break; } dump_type (TREE_VALUE (parmtypes), flags); if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes)) { - pp_string (cxx_pp, " = "); + pp_cxx_whitespace (cxx_pp); + pp_equal (cxx_pp); + pp_cxx_whitespace (cxx_pp); dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS); } } - pp_right_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); } /* Print an exception specification. T is the exception specification. */ @@ -1112,7 +1110,9 @@ dump_exception_spec (tree t, int flags) { if (t) { - pp_string (cxx_pp, " 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) { @@ -1122,7 +1122,7 @@ dump_exception_spec (tree t, int flags) break; pp_separate_with_comma (cxx_pp); } - pp_right_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); } } @@ -1141,7 +1141,7 @@ dump_function_name (tree t, int flags) literal name. */ if (!DECL_LANG_SPECIFIC (t)) { - pp_tree_identifier (cxx_pp, name); + pp_cxx_tree_identifier (cxx_pp, name); return; } @@ -1155,7 +1155,7 @@ dump_function_name (tree t, int flags) if (DECL_DESTRUCTOR_P (t)) { - pp_complement (cxx_pp); + pp_cxx_complement (cxx_pp); dump_decl (name, TFF_PLAIN_IDENTIFIER); } else if (DECL_CONV_FN_P (t)) @@ -1166,11 +1166,11 @@ dump_function_name (tree t, int flags) declarations, both will have the same name, yet the types will be different, hence the TREE_TYPE field of the first name will be clobbered by the second. */ - pp_string (cxx_pp, "operator "); + pp_cxx_identifier (cxx_pp, "operator"); dump_type (TREE_TYPE (TREE_TYPE (t)), flags); } else if (IDENTIFIER_OPNAME_P (name)) - pp_tree_identifier (cxx_pp, name); + pp_cxx_tree_identifier (cxx_pp, name); else dump_decl (name, flags); @@ -1197,7 +1197,7 @@ 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); - pp_template_argument_list_start (cxx_pp); + 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. */ @@ -1242,7 +1242,7 @@ dump_template_parms (tree info, int primary, int flags) dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS); } } - pp_template_argument_list_end (cxx_pp); + pp_cxx_end_template_argument_list (cxx_pp); } /* Print out a list of initializers (subr of dump_expr). */ @@ -1288,39 +1288,40 @@ dump_expr (tree t, int flags) break; case THROW_EXPR: - pp_identifier (cxx_pp, "throw"); + pp_cxx_identifier (cxx_pp, "throw"); dump_expr (TREE_OPERAND (t, 0), flags); break; case PTRMEM_CST: pp_ampersand (cxx_pp); dump_type (PTRMEM_CST_CLASS (t), flags); - pp_colon_colon (cxx_pp); - pp_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t))); + pp_cxx_colon_colon (cxx_pp); + pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t))); break; case COMPOUND_EXPR: - pp_left_paren (cxx_pp); + 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_right_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); break; case COND_EXPR: - pp_left_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); pp_string (cxx_pp, " ? "); dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); pp_string (cxx_pp, " : "); dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS); - pp_right_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); break; case SAVE_EXPR: if (TREE_HAS_CONSTRUCTOR (t)) { - pp_string (cxx_pp, "new "); + pp_cxx_identifier (cxx_pp, "new"); + pp_cxx_whitespace (cxx_pp); dump_type (TREE_TYPE (TREE_TYPE (t)), flags); } else @@ -1337,17 +1338,17 @@ dump_expr (tree t, int flags) if (fn && TREE_CODE (fn) == FUNCTION_DECL) { if (DECL_CONSTRUCTOR_P (fn)) - pp_tree_identifier (cxx_pp, TYPE_IDENTIFIER (TREE_TYPE (t))); + pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (TREE_TYPE (t))); else dump_decl (fn, 0); } else dump_expr (TREE_OPERAND (t, 0), 0); } - pp_left_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); if (TREE_OPERAND (t, 1)) dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags); - pp_right_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); break; case CALL_EXPR: @@ -1375,9 +1376,9 @@ dump_expr (tree t, int flags) args = TREE_CHAIN (args); } dump_expr (fn, flags | TFF_EXPR_IN_PARENS); - pp_left_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); dump_expr_list (args, flags); - pp_right_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); } break; @@ -1386,13 +1387,14 @@ dump_expr (tree t, int flags) tree type = TREE_OPERAND (t, 1); tree init = TREE_OPERAND (t, 2); if (NEW_EXPR_USE_GLOBAL (t)) - pp_colon_colon (cxx_pp); - pp_string (cxx_pp, "new "); + pp_cxx_colon_colon (cxx_pp); + pp_cxx_identifier (cxx_pp, "new"); if (TREE_OPERAND (t, 0)) { - pp_left_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); dump_expr_list (TREE_OPERAND (t, 0), flags); - pp_string (cxx_pp, ") "); + pp_cxx_right_paren (cxx_pp); + pp_cxx_whitespace (cxx_pp); } if (TREE_CODE (type) == ARRAY_REF) type = build_cplus_array_type @@ -1403,7 +1405,7 @@ dump_expr (tree t, int flags) dump_type (type, flags); if (init) { - pp_left_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); if (TREE_CODE (init) == TREE_LIST) dump_expr_list (init, flags); else if (init == void_zero_node) @@ -1412,7 +1414,7 @@ dump_expr (tree t, int flags) ; else dump_expr (init, flags); - pp_right_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); } } break; @@ -1475,13 +1477,13 @@ dump_expr (tree t, int flags) || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")) { dump_expr (ob, flags | TFF_EXPR_IN_PARENS); - pp_arrow (cxx_pp); + pp_cxx_arrow (cxx_pp); } } else { dump_expr (ob, flags | TFF_EXPR_IN_PARENS); - pp_dot (cxx_pp); + pp_cxx_dot (cxx_pp); } dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS); } @@ -1489,17 +1491,17 @@ dump_expr (tree t, int flags) case ARRAY_REF: dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); - pp_left_bracket (cxx_pp); + pp_cxx_left_bracket (cxx_pp); dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); - pp_right_bracket (cxx_pp); + pp_cxx_right_bracket (cxx_pp); break; case CONVERT_EXPR: if (TREE_TYPE (t) && VOID_TYPE_P (TREE_TYPE (t))) { - pp_left_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); dump_type (TREE_TYPE (t), flags); - pp_right_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); dump_expr (TREE_OPERAND (t, 0), flags); } else @@ -1525,9 +1527,9 @@ dump_expr (tree t, int flags) t = TREE_OPERAND (t, 0); my_friendly_assert (TREE_CODE (t) == CALL_EXPR, 237); dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); - pp_left_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags); - pp_right_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); } else { @@ -1550,10 +1552,10 @@ dump_expr (tree t, int flags) case POSTDECREMENT_EXPR: case POSTINCREMENT_EXPR: - pp_left_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); - pp_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name); - pp_right_paren (cxx_pp); + pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name); + pp_cxx_right_paren (cxx_pp); break; case NON_LVALUE_EXPR: @@ -1570,11 +1572,11 @@ dump_expr (tree t, int flags) if (TREE_CODE (next) == FUNCTION_TYPE) { if (flags & TFF_EXPR_IN_PARENS) - pp_left_paren (cxx_pp); - pp_star (cxx_pp); + 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) - pp_right_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); break; } /* Else fall through. */ @@ -1591,13 +1593,13 @@ dump_expr (tree t, int flags) /* 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_left_paren (cxx_pp); - pp_left_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); dump_type (TREE_TYPE (t), flags); - pp_right_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); dump_expr (op, flags | TFF_EXPR_IN_PARENS); if (flags & TFF_EXPR_IN_PARENS) - pp_right_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); } else dump_expr (op, flags); @@ -1612,11 +1614,12 @@ dump_expr (tree t, int flags) if (integer_zerop (idx)) { /* A NULL pointer-to-member constant. */ - pp_left_paren (cxx_pp); - pp_left_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); dump_type (TREE_TYPE (t), flags); - pp_right_paren (cxx_pp); - pp_string (cxx_pp, ")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)) @@ -1650,14 +1653,14 @@ dump_expr (tree t, int flags) if (TREE_TYPE (t) && !CONSTRUCTOR_ELTS (t)) { dump_type (TREE_TYPE (t), 0); - pp_left_paren (cxx_pp); - pp_right_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); } else { - pp_left_brace (cxx_pp); + pp_cxx_left_brace (cxx_pp); dump_expr_list (CONSTRUCTOR_ELTS (t), flags); - pp_right_brace (cxx_pp); + pp_cxx_right_brace (cxx_pp); } break; @@ -1682,12 +1685,14 @@ dump_expr (tree t, int flags) if (TREE_CODE (ob) == INDIRECT_REF) { dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS); - pp_string (cxx_pp, "->*"); + pp_cxx_arrow (cxx_pp); + pp_cxx_star (cxx_pp); } else { dump_expr (ob, flags | TFF_EXPR_IN_PARENS); - pp_string (cxx_pp, ".*"); + pp_cxx_dot (cxx_pp); + pp_cxx_star (cxx_pp); } dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); } @@ -1700,7 +1705,7 @@ dump_expr (tree t, int flags) case SCOPE_REF: dump_type (TREE_OPERAND (t, 0), flags); - pp_colon_colon (cxx_pp); + pp_cxx_colon_colon (cxx_pp); dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); break; @@ -1709,63 +1714,68 @@ dump_expr (tree t, int flags) || TREE_CHAIN (TREE_OPERAND (t, 0))) { dump_type (TREE_TYPE (t), flags); - pp_left_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); dump_expr_list (TREE_OPERAND (t, 0), flags); - pp_right_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); } else { - pp_left_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); dump_type (TREE_TYPE (t), flags); - pp_string (cxx_pp, ")("); + pp_cxx_right_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); dump_expr_list (TREE_OPERAND (t, 0), flags); - pp_right_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); } break; case STATIC_CAST_EXPR: - pp_string (cxx_pp, "static_cast<"); + pp_cxx_identifier (cxx_pp, "static_cast"); goto cast; case REINTERPRET_CAST_EXPR: - pp_string (cxx_pp, "reinterpret_cast<"); + pp_cxx_identifier (cxx_pp, "reinterpret_cast"); goto cast; case CONST_CAST_EXPR: - pp_string (cxx_pp, "const_cast<"); + pp_cxx_identifier (cxx_pp, "const_cast"); goto cast; case DYNAMIC_CAST_EXPR: - pp_string (cxx_pp, "dynamic_cast<"); + pp_cxx_identifier (cxx_pp, "dynamic_cast"); cast: + pp_cxx_begin_template_argument_list (cxx_pp); dump_type (TREE_TYPE (t), flags); - pp_string (cxx_pp, ">("); + pp_cxx_end_template_argument_list (cxx_pp); + pp_cxx_left_paren (cxx_pp); dump_expr (TREE_OPERAND (t, 0), flags); - pp_right_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); break; case ARROW_EXPR: dump_expr (TREE_OPERAND (t, 0), flags); - pp_arrow (cxx_pp); + pp_cxx_arrow (cxx_pp); break; case SIZEOF_EXPR: case ALIGNOF_EXPR: if (TREE_CODE (t) == SIZEOF_EXPR) - pp_string (cxx_pp, "sizeof ("); + pp_cxx_identifier (cxx_pp, "sizeof"); else { my_friendly_assert (TREE_CODE (t) == ALIGNOF_EXPR, 0); - pp_string (cxx_pp, "__alignof__ ("); + 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); - pp_right_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); break; case REALPART_EXPR: case IMAGPART_EXPR: - pp_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name); - pp_space (cxx_pp); + 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; @@ -1781,10 +1791,10 @@ dump_expr (tree t, int flags) case PSEUDO_DTOR_EXPR: dump_expr (TREE_OPERAND (t, 2), flags); - pp_dot (cxx_pp); + pp_cxx_dot (cxx_pp); dump_type (TREE_OPERAND (t, 0), flags); - pp_colon_colon (cxx_pp); - pp_complement (cxx_pp); + pp_cxx_colon_colon (cxx_pp); + pp_cxx_complement (cxx_pp); dump_type (TREE_OPERAND (t, 1), flags); break; @@ -1799,15 +1809,15 @@ dump_expr (tree t, int flags) break; case BIND_EXPR: - pp_left_brace (cxx_pp); + pp_cxx_left_brace (cxx_pp); dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS); - pp_right_brace (cxx_pp); + pp_cxx_right_brace (cxx_pp); break; case LOOP_EXPR: pp_string (cxx_pp, "while (1) { "); dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); - pp_right_brace (cxx_pp); + pp_cxx_right_brace (cxx_pp); break; case EXIT_EXPR: @@ -1822,8 +1832,8 @@ dump_expr (tree t, int flags) case EMPTY_CLASS_EXPR: dump_type (TREE_TYPE (t), flags); - pp_left_paren (cxx_pp); - pp_right_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); break; case NON_DEPENDENT_EXPR: @@ -1845,36 +1855,47 @@ dump_expr (tree t, int flags) static void dump_binary_op (const char *opstring, tree t, int flags) { - pp_left_paren (cxx_pp); + pp_cxx_left_paren (cxx_pp); dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); - pp_space (cxx_pp); + pp_cxx_whitespace (cxx_pp); if (opstring) - pp_identifier (cxx_pp, opstring); + pp_cxx_identifier (cxx_pp, opstring); else pp_identifier (cxx_pp, ""); - pp_space (cxx_pp); + pp_cxx_whitespace (cxx_pp); dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); - pp_right_paren (cxx_pp); + pp_cxx_right_paren (cxx_pp); } static void dump_unary_op (const char *opstring, tree t, int flags) { if (flags & TFF_EXPR_IN_PARENS) - pp_left_paren (cxx_pp); - pp_identifier (cxx_pp, 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) - pp_right_paren (cxx_pp); + 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) { - pp_clear_output_area (cxx_pp); + reinit_cxx_pp (); dump_type (typ, flags); return pp_formatted_text (cxx_pp); } @@ -1882,7 +1903,7 @@ type_as_string (tree typ, int flags) const char * expr_as_string (tree decl, int flags) { - pp_clear_output_area (cxx_pp); + reinit_cxx_pp (); dump_expr (decl, flags); return pp_formatted_text (cxx_pp); } @@ -1890,7 +1911,7 @@ expr_as_string (tree decl, int flags) const char * decl_as_string (tree decl, int flags) { - pp_clear_output_area (cxx_pp); + reinit_cxx_pp (); dump_decl (decl, flags); return pp_formatted_text (cxx_pp); } @@ -1898,7 +1919,7 @@ decl_as_string (tree decl, int flags) const char * context_as_string (tree context, int flags) { - pp_clear_output_area (cxx_pp); + reinit_cxx_pp (); dump_scope (context, flags); return pp_formatted_text (cxx_pp); } @@ -1911,11 +1932,11 @@ lang_decl_name (tree decl, int v) if (v >= 2) return decl_as_string (decl, TFF_DECL_SPECIFIERS); - pp_clear_output_area (cxx_pp); + reinit_cxx_pp (); if (v == 1 && DECL_CLASS_SCOPE_P (decl)) { dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER); - pp_colon_colon (cxx_pp); + pp_cxx_colon_colon (cxx_pp); } if (TREE_CODE (decl) == FUNCTION_DECL) @@ -1957,7 +1978,7 @@ decl_to_string (tree decl, int verbose) flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE; flags |= TFF_TEMPLATE_HEADER; - pp_clear_output_area (cxx_pp); + reinit_cxx_pp (); dump_decl (decl, flags); return pp_formatted_text (cxx_pp); } @@ -1965,7 +1986,7 @@ decl_to_string (tree decl, int verbose) static const char * expr_to_string (tree decl) { - pp_clear_output_area (cxx_pp); + reinit_cxx_pp (); dump_expr (decl, 0); return pp_formatted_text (cxx_pp); } @@ -1978,7 +1999,7 @@ fndecl_to_string (tree fndecl, int verbose) flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS; if (verbose) flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS; - pp_clear_output_area (cxx_pp); + reinit_cxx_pp (); dump_decl (fndecl, flags); return pp_formatted_text (cxx_pp); } @@ -2015,7 +2036,7 @@ language_to_string (enum languages c) static const char * parm_to_string (int p) { - pp_clear_output_area (cxx_pp); + reinit_cxx_pp (); if (p < 0) pp_string (cxx_pp, "'this'"); else @@ -2038,7 +2059,7 @@ type_to_string (tree typ, int verbose) flags |= TFF_CLASS_KEY_OR_ENUM; flags |= TFF_TEMPLATE_HEADER; - pp_clear_output_area (cxx_pp); + reinit_cxx_pp (); dump_type (typ, flags); return pp_formatted_text (cxx_pp); } @@ -2063,11 +2084,11 @@ args_to_string (tree p, int verbose) if (TYPE_P (TREE_VALUE (p))) return type_as_string (p, flags); - pp_clear_output_area (cxx_pp); + reinit_cxx_pp (); for (; p; p = TREE_CHAIN (p)) { if (TREE_VALUE (p) == null_node) - pp_identifier (cxx_pp, "NULL"); + pp_cxx_identifier (cxx_pp, "NULL"); else dump_type (error_type (TREE_VALUE (p)), flags); if (TREE_CHAIN (p)) @@ -2079,7 +2100,7 @@ args_to_string (tree p, int verbose) static const char * cv_to_string (tree p, int v) { - pp_clear_output_area (cxx_pp); + 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); @@ -2289,16 +2310,6 @@ cp_printer (pretty_printer *pp, text_info *text) #undef next_int } -static void -pp_non_consecutive_character (cxx_pretty_printer *pp, int c) -{ - const char *p = pp_last_position_in_text (pp); - - if (p != NULL && *p == c) - pp_space (pp); - pp_character (pp, c); -} - /* These are temporary wrapper functions which handle the historic behavior of cp_*_at. */ -- 2.7.4