This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
C++ PATCH: Fix annoying space in formatting
- From: Gabriel Dos Reis <gdr at cs dot tamu dot edu>
- To: gcc-patches at gcc dot gnu dot org
- Date: 27 Jun 2004 10:24:53 -0500
- Subject: C++ PATCH: Fix annoying space in formatting
- Organization: Texas A&M University, Department of Computer Science
This boring patch fixes annoying whitespace issues when formatting
trees in error messages. The long term solution, of course, is to
rewrite cp/error.c in terms of the new pretty-printer. That will
happen. But for the moment, this is patch solves the immediate
issues. (One issue remain to be solved. That will happen later).
Regtested on an i686-pc-linux-gnu. No new regression. Applied to
mainline.
-- Gaby
Index: ChangeLog
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/ChangeLog,v
retrieving revision 1.4133
diff -p -r1.4133 ChangeLog
*** ChangeLog 27 Jun 2004 03:03:54 -0000 1.4133
--- ChangeLog 27 Jun 2004 15:20:02 -0000
***************
*** 1,3 ****
--- 1,52 ----
+ 2004-06-27 Gabriel Dos Reis <gdr@integrable-solutions.net>
+
+ * 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 <mark@codesourcery.com>
* cp-tree.h (cp_cv_quals): New type.
Index: error.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/error.c,v
retrieving revision 1.252
diff -p -r1.252 error.c
*** error.c 10 Jun 2004 18:28:52 -0000 1.252
--- error.c 27 Jun 2004 15:20:02 -0000
*************** Boston, MA 02111-1307, USA. */
*** 32,42 ****
#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, ", ")
/* The global buffer where we dump everything. It is there only for
transitional purpose. It is expected, in the near future, to be
--- 32,38 ----
#include "langhooks-def.h"
#include "cxx-pretty-print.h"
! #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
*************** static cxx_pretty_printer scratch_pretty
*** 46,54 ****
# 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);
--- 42,47 ----
*************** static void cp_diagnostic_finalizer (dia
*** 95,101 ****
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);
--- 88,93 ----
*************** dump_scope (tree scope, int flags)
*** 125,142 ****
if (scope != global_namespace)
{
dump_decl (scope, f);
! pp_colon_colon (cxx_pp);
}
}
else if (AGGREGATE_TYPE_P (scope))
{
dump_type (scope, f);
! pp_colon_colon (cxx_pp);
}
else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
{
dump_function_decl (scope, f);
! pp_colon_colon (cxx_pp);
}
}
--- 117,134 ----
if (scope != global_namespace)
{
dump_decl (scope, f);
! pp_cxx_colon_colon (cxx_pp);
}
}
else if (AGGREGATE_TYPE_P (scope))
{
dump_type (scope, f);
! pp_cxx_colon_colon (cxx_pp);
}
else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
{
dump_function_decl (scope, f);
! pp_cxx_colon_colon (cxx_pp);
}
}
*************** dump_template_parameter (tree parm, int
*** 182,196 ****
{
if (flags & TFF_DECL_SPECIFIERS)
{
! pp_identifier (cxx_pp, "class");
if (DECL_NAME (p))
! {
! pp_space (cxx_pp);
! pp_tree_identifier (cxx_pp, DECL_NAME (p));
! }
}
else if (DECL_NAME (p))
! pp_tree_identifier (cxx_pp, DECL_NAME (p));
else
pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
}
--- 174,185 ----
{
if (flags & TFF_DECL_SPECIFIERS)
{
! pp_cxx_identifier (cxx_pp, "class");
if (DECL_NAME (p))
! pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
}
else if (DECL_NAME (p))
! pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
else
pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
}
*************** dump_template_parameter (tree parm, int
*** 199,205 ****
if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
{
! pp_string (cxx_pp, " = ");
if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
else
--- 188,196 ----
if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
{
! 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
*************** dump_template_bindings (tree parms, tree
*** 238,244 ****
if (need_comma)
pp_separate_with_comma (cxx_pp);
dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
! pp_string (cxx_pp, " = ");
if (arg)
dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
else
--- 229,237 ----
if (need_comma)
pp_separate_with_comma (cxx_pp);
dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
! pp_cxx_whitespace (cxx_pp);
! pp_equal (cxx_pp);
! pp_cxx_whitespace (cxx_pp);
if (arg)
dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
else
*************** dump_type (tree t, int flags)
*** 276,282 ****
break;
case IDENTIFIER_NODE:
! pp_tree_identifier (cxx_pp, t);
break;
case TREE_VEC:
--- 269,275 ----
break;
case IDENTIFIER_NODE:
! pp_cxx_tree_identifier (cxx_pp, t);
break;
case TREE_VEC:
*************** dump_type (tree t, int flags)
*** 309,322 ****
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));
else
pp_cxx_canonical_template_parameter (cxx_pp, t);
break;
--- 302,314 ----
case BOOLEAN_TYPE:
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))
! pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
else
pp_cxx_canonical_template_parameter (cxx_pp, t);
break;
*************** dump_type (tree t, int flags)
*** 324,340 ****
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);
dump_template_argument_list (args, flags);
! pp_template_argument_list_end (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));
else
pp_cxx_canonical_template_parameter
(cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
--- 316,332 ----
case BOUND_TEMPLATE_TEMPLATE_PARM:
{
tree args = TYPE_TI_ARGS (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:
pp_cxx_cv_qualifier_seq (cxx_pp, t);
if (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));
*************** dump_type (tree t, int flags)
*** 356,376 ****
}
case TYPENAME_TYPE:
pp_cxx_cv_qualifier_seq (cxx_pp, t);
! pp_string (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 ");
dump_type (DECL_NAME (TYPE_NAME (t)), flags);
break;
case TYPEOF_TYPE:
! pp_string (cxx_pp, "__typeof (");
dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
! pp_right_paren (cxx_pp);
break;
default:
--- 348,370 ----
}
case TYPENAME_TYPE:
pp_cxx_cv_qualifier_seq (cxx_pp, t);
! pp_cxx_identifier (cxx_pp, "typename");
dump_typename (t, flags);
break;
case UNBOUND_CLASS_TEMPLATE:
dump_type (TYPE_CONTEXT (t), flags);
! 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_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:
*************** dump_typename (tree t, int flags)
*** 395,401 ****
dump_typename (ctx, flags);
else
dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
! pp_colon_colon (cxx_pp);
dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
}
--- 389,395 ----
dump_typename (ctx, flags);
else
dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
! pp_cxx_colon_colon (cxx_pp);
dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
}
*************** dump_aggr_type (tree t, int flags)
*** 428,437 ****
pp_cxx_cv_qualifier_seq (cxx_pp, t);
if (flags & TFF_CLASS_KEY_OR_ENUM)
! {
! pp_identifier (cxx_pp, variety);
! pp_space (cxx_pp);
! }
if (flags & TFF_CHASE_TYPEDEF)
t = TYPE_MAIN_VARIANT (t);
--- 422,428 ----
pp_cxx_cv_qualifier_seq (cxx_pp, t);
if (flags & TFF_CLASS_KEY_OR_ENUM)
! pp_cxx_identifier (cxx_pp, variety);
if (flags & TFF_CHASE_TYPEDEF)
t = TYPE_MAIN_VARIANT (t);
*************** dump_aggr_type (tree t, int flags)
*** 469,475 ****
pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety);
}
else
! pp_tree_identifier (cxx_pp, name);
if (tmplate)
dump_template_parms (TYPE_TEMPLATE_INFO (t),
!CLASSTYPE_USE_TEMPLATE (t),
--- 460,466 ----
pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety);
}
else
! pp_cxx_tree_identifier (cxx_pp, name);
if (tmplate)
dump_template_parms (TYPE_TEMPLATE_INFO (t),
!CLASSTYPE_USE_TEMPLATE (t),
*************** dump_aggr_type (tree t, int flags)
*** 490,497 ****
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);
--- 481,486 ----
*************** dump_type_prefix (tree t, int flags)
*** 508,515 ****
dump_type_prefix (sub, flags);
if (TREE_CODE (sub) == ARRAY_TYPE)
{
! pp_space (cxx_pp);
! pp_left_paren (cxx_pp);
}
pp_character (cxx_pp, "&*"[TREE_CODE (t) == POINTER_TYPE]);
pp_base (cxx_pp)->padding = pp_before;
--- 497,504 ----
dump_type_prefix (sub, flags);
if (TREE_CODE (sub) == ARRAY_TYPE)
{
! 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;
*************** dump_type_prefix (tree t, int flags)
*** 524,532 ****
{
pp_maybe_space (cxx_pp);
dump_type (TYPE_OFFSET_BASETYPE (t), flags);
! pp_colon_colon (cxx_pp);
}
! pp_star (cxx_pp);
pp_cxx_cv_qualifier_seq (cxx_pp, t);
break;
--- 513,521 ----
{
pp_maybe_space (cxx_pp);
dump_type (TYPE_OFFSET_BASETYPE (t), flags);
! pp_cxx_colon_colon (cxx_pp);
}
! pp_cxx_star (cxx_pp);
pp_cxx_cv_qualifier_seq (cxx_pp, t);
break;
*************** dump_type_prefix (tree t, int flags)
*** 535,549 ****
case FUNCTION_TYPE:
dump_type_prefix (TREE_TYPE (t), flags);
pp_maybe_space (cxx_pp);
! pp_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);
dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
! pp_colon_colon (cxx_pp);
break;
case ARRAY_TYPE:
--- 524,538 ----
case FUNCTION_TYPE:
dump_type_prefix (TREE_TYPE (t), flags);
pp_maybe_space (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_cxx_left_paren (cxx_pp);
dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
! pp_cxx_colon_colon (cxx_pp);
break;
case ARRAY_TYPE:
*************** dump_type_suffix (tree t, int flags)
*** 597,603 ****
case REFERENCE_TYPE:
case OFFSET_TYPE:
if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
! pp_right_paren (cxx_pp);
dump_type_suffix (TREE_TYPE (t), flags);
break;
--- 586,592 ----
case REFERENCE_TYPE:
case OFFSET_TYPE:
if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
! pp_cxx_right_paren (cxx_pp);
dump_type_suffix (TREE_TYPE (t), flags);
break;
*************** dump_type_suffix (tree t, int flags)
*** 606,612 ****
case METHOD_TYPE:
{
tree arg;
! pp_right_paren (cxx_pp);
arg = TYPE_ARG_TYPES (t);
if (TREE_CODE (t) == METHOD_TYPE)
arg = TREE_CHAIN (arg);
--- 595,601 ----
case METHOD_TYPE:
{
tree arg;
! pp_cxx_right_paren (cxx_pp);
arg = TYPE_ARG_TYPES (t);
if (TREE_CODE (t) == METHOD_TYPE)
arg = TREE_CHAIN (arg);
*************** dump_type_suffix (tree t, int flags)
*** 624,630 ****
}
case ARRAY_TYPE:
! pp_left_bracket (cxx_pp);
if (TYPE_DOMAIN (t))
{
if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0))
--- 613,619 ----
}
case ARRAY_TYPE:
! pp_cxx_left_bracket (cxx_pp);
if (TYPE_DOMAIN (t))
{
if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0))
*************** dump_type_suffix (tree t, int flags)
*** 639,645 ****
integer_one_node)),
flags & ~TFF_EXPR_IN_PARENS);
}
! pp_right_bracket (cxx_pp);
dump_type_suffix (TREE_TYPE (t), flags);
break;
--- 628,634 ----
integer_one_node)),
flags & ~TFF_EXPR_IN_PARENS);
}
! pp_cxx_right_bracket (cxx_pp);
dump_type_suffix (TREE_TYPE (t), flags);
break;
*************** dump_decl (tree t, int flags)
*** 724,737 ****
if ((flags & TFF_DECL_SPECIFIERS)
&& TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
/* Say `class T' not just `T'. */
! pp_string (cxx_pp, "class ");
dump_type (TREE_TYPE (t), flags);
break;
}
}
if (flags & TFF_DECL_SPECIFIERS)
! pp_string (cxx_pp, "typedef ");
dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
flags);
--- 713,726 ----
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;
}
}
if (flags & TFF_DECL_SPECIFIERS)
! pp_cxx_identifier (cxx_pp, "typedef");
dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
flags);
*************** dump_decl (tree t, int flags)
*** 766,772 ****
if (DECL_NAME (t) == NULL_TREE)
pp_identifier (cxx_pp, "<unnamed>");
else
! pp_tree_identifier (cxx_pp, DECL_NAME (t));
}
break;
--- 755,761 ----
if (DECL_NAME (t) == NULL_TREE)
pp_identifier (cxx_pp, "<unnamed>");
else
! pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
}
break;
*************** dump_decl (tree t, int flags)
*** 778,786 ****
case ARRAY_REF:
dump_decl (TREE_OPERAND (t, 0), flags);
! pp_left_bracket (cxx_pp);
dump_decl (TREE_OPERAND (t, 1), flags);
! pp_right_bracket (cxx_pp);
break;
/* So that we can do dump_decl on an aggr type. */
--- 767,775 ----
case ARRAY_REF:
dump_decl (TREE_OPERAND (t, 0), flags);
! pp_cxx_left_bracket (cxx_pp);
dump_decl (TREE_OPERAND (t, 1), flags);
! pp_cxx_right_bracket (cxx_pp);
break;
/* So that we can do dump_decl on an aggr type. */
*************** dump_decl (tree t, int flags)
*** 793,799 ****
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);
dump_type (TREE_OPERAND (t, 0), flags);
break;
--- 782,788 ----
case BIT_NOT_EXPR:
/* This is a pseudo destructor call which has not been folded into
a PSEUDO_DTOR_EXPR yet. */
! pp_cxx_complement (cxx_pp);
dump_type (TREE_OPERAND (t, 0), flags);
break;
*************** dump_decl (tree t, int flags)
*** 806,818 ****
case IDENTIFIER_NODE:
if (IDENTIFIER_TYPENAME_P (t))
{
! pp_string (cxx_pp, "operator ");
/* Not exactly IDENTIFIER_TYPE_VALUE. */
dump_type (TREE_TYPE (t), flags);
break;
}
else
! pp_tree_identifier (cxx_pp, t);
break;
case OVERLOAD:
--- 795,807 ----
case IDENTIFIER_NODE:
if (IDENTIFIER_TYPENAME_P (t))
{
! pp_cxx_identifier (cxx_pp, "operator");
/* Not exactly IDENTIFIER_TYPE_VALUE. */
dump_type (TREE_TYPE (t), flags);
break;
}
else
! pp_cxx_tree_identifier (cxx_pp, t);
break;
case OVERLOAD:
*************** dump_decl (tree t, int flags)
*** 822,833 ****
if (DECL_CLASS_SCOPE_P (t))
{
dump_type (DECL_CONTEXT (t), flags);
! pp_colon_colon (cxx_pp);
}
else if (DECL_CONTEXT (t))
{
dump_decl (DECL_CONTEXT (t), flags);
! pp_colon_colon (cxx_pp);
}
dump_decl (DECL_NAME (t), flags);
break;
--- 811,822 ----
if (DECL_CLASS_SCOPE_P (t))
{
dump_type (DECL_CONTEXT (t), flags);
! pp_cxx_colon_colon (cxx_pp);
}
else if (DECL_CONTEXT (t))
{
dump_decl (DECL_CONTEXT (t), flags);
! pp_cxx_colon_colon (cxx_pp);
}
dump_decl (DECL_NAME (t), flags);
break;
*************** dump_decl (tree t, int flags)
*** 858,872 ****
if (is_overloaded_fn (name))
name = DECL_NAME (get_first_fn (name));
dump_decl (name, flags);
! pp_template_argument_list_start (cxx_pp);
if (TREE_OPERAND (t, 1))
dump_template_argument_list (TREE_OPERAND (t, 1), flags);
! pp_template_argument_list_end (cxx_pp);
}
break;
case LABEL_DECL:
! pp_tree_identifier (cxx_pp, DECL_NAME (t));
break;
case CONST_DECL:
--- 847,861 ----
if (is_overloaded_fn (name))
name = DECL_NAME (get_first_fn (name));
dump_decl (name, flags);
! 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 LABEL_DECL:
! pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
break;
case CONST_DECL:
*************** dump_decl (tree t, int flags)
*** 883,891 ****
break;
case USING_DECL:
! pp_string (cxx_pp, "using ");
dump_type (DECL_INITIAL (t), flags);
! pp_colon_colon (cxx_pp);
dump_decl (DECL_NAME (t), flags);
break;
--- 872,880 ----
break;
case USING_DECL:
! pp_cxx_identifier (cxx_pp, "using");
dump_type (DECL_INITIAL (t), flags);
! pp_cxx_colon_colon (cxx_pp);
dump_decl (DECL_NAME (t), flags);
break;
*************** dump_template_decl (tree t, int flags)
*** 933,939 ****
tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
int len = TREE_VEC_LENGTH (inner_parms);
! pp_string (cxx_pp, "template<");
/* If we've shown the template prefix, we'd better show the
parameters' and decl's type too. */
--- 922,929 ----
tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
int len = TREE_VEC_LENGTH (inner_parms);
! 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. */
*************** dump_template_decl (tree t, int flags)
*** 945,958 ****
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);
}
nreverse(orig_parms);
if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
/* Say `template<arg> class TT' not just `template<arg> TT'. */
! pp_string (cxx_pp, "class ");
}
if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
--- 935,948 ----
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'. */
! pp_cxx_identifier (cxx_pp, "class");
}
if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
*************** dump_function_decl (tree t, int flags)
*** 1022,1046 ****
if (!(flags & TFF_DECL_SPECIFIERS))
/* OK */;
else if (DECL_STATIC_FUNCTION_P (t))
! pp_identifier (cxx_pp, "static ");
else if (DECL_VIRTUAL_P (t))
! pp_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);
! }
/* Print the function name. */
if (cname)
{
dump_type (cname, flags);
! pp_colon_colon (cxx_pp);
}
else
dump_scope (CP_DECL_CONTEXT (t), flags);
--- 1012,1033 ----
if (!(flags & TFF_DECL_SPECIFIERS))
/* OK */;
else if (DECL_STATIC_FUNCTION_P (t))
! pp_cxx_identifier (cxx_pp, "static");
else if (DECL_VIRTUAL_P (t))
! 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);
/* Print the function name. */
if (cname)
{
dump_type (cname, flags);
! pp_cxx_colon_colon (cxx_pp);
}
else
dump_scope (CP_DECL_CONTEXT (t), flags);
*************** dump_function_decl (tree t, int flags)
*** 1052,1062 ****
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))));
if (flags & TFF_EXCEPTION_SPECIFICATION)
! dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
if (show_return)
dump_type_suffix (TREE_TYPE (fntype), flags);
--- 1039,1055 ----
dump_parameters (parmtypes, flags);
if (TREE_CODE (fntype) == METHOD_TYPE)
! {
! 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)
! {
! 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);
*************** dump_function_decl (tree t, int flags)
*** 1065,1073 ****
/* If T is a template instantiation, dump the parameter binding. */
if (template_parms != NULL_TREE && template_args != NULL_TREE)
{
! pp_string (cxx_pp, " [with ");
dump_template_bindings (template_parms, template_args);
! pp_right_bracket (cxx_pp);
}
}
--- 1058,1069 ----
/* If T is a template instantiation, dump the parameter binding. */
if (template_parms != NULL_TREE && template_args != NULL_TREE)
{
! 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_cxx_right_bracket (cxx_pp);
}
}
*************** dump_parameters (tree parmtypes, int fla
*** 1080,1086 ****
{
int first;
! pp_left_paren (cxx_pp);
for (first = 1; parmtypes != void_list_node;
parmtypes = TREE_CHAIN (parmtypes))
--- 1076,1082 ----
{
int first;
! pp_cxx_left_paren (cxx_pp);
for (first = 1; parmtypes != void_list_node;
parmtypes = TREE_CHAIN (parmtypes))
*************** dump_parameters (tree parmtypes, int fla
*** 1090,1108 ****
first = 0;
if (!parmtypes)
{
! pp_identifier (cxx_pp, "...");
break;
}
dump_type (TREE_VALUE (parmtypes), flags);
if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
{
! pp_string (cxx_pp, " = ");
dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
}
}
! pp_right_paren (cxx_pp);
}
/* Print an exception specification. T is the exception specification. */
--- 1086,1106 ----
first = 0;
if (!parmtypes)
{
! pp_cxx_identifier (cxx_pp, "...");
break;
}
dump_type (TREE_VALUE (parmtypes), flags);
if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
{
! 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_cxx_right_paren (cxx_pp);
}
/* Print an exception specification. T is the exception specification. */
*************** dump_exception_spec (tree t, int flags)
*** 1112,1118 ****
{
if (t)
{
! pp_string (cxx_pp, " throw (");
if (TREE_VALUE (t) != NULL_TREE)
while (1)
{
--- 1110,1118 ----
{
if (t)
{
! 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_exception_spec (tree t, int flags)
*** 1122,1128 ****
break;
pp_separate_with_comma (cxx_pp);
}
! pp_right_paren (cxx_pp);
}
}
--- 1122,1128 ----
break;
pp_separate_with_comma (cxx_pp);
}
! pp_cxx_right_paren (cxx_pp);
}
}
*************** dump_function_name (tree t, int flags)
*** 1141,1147 ****
literal name. */
if (!DECL_LANG_SPECIFIC (t))
{
! pp_tree_identifier (cxx_pp, name);
return;
}
--- 1141,1147 ----
literal name. */
if (!DECL_LANG_SPECIFIC (t))
{
! pp_cxx_tree_identifier (cxx_pp, name);
return;
}
*************** dump_function_name (tree t, int flags)
*** 1155,1161 ****
if (DECL_DESTRUCTOR_P (t))
{
! pp_complement (cxx_pp);
dump_decl (name, TFF_PLAIN_IDENTIFIER);
}
else if (DECL_CONV_FN_P (t))
--- 1155,1161 ----
if (DECL_DESTRUCTOR_P (t))
{
! pp_cxx_complement (cxx_pp);
dump_decl (name, TFF_PLAIN_IDENTIFIER);
}
else if (DECL_CONV_FN_P (t))
*************** dump_function_name (tree t, int flags)
*** 1166,1176 ****
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 ");
dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
}
else if (IDENTIFIER_OPNAME_P (name))
! pp_tree_identifier (cxx_pp, name);
else
dump_decl (name, flags);
--- 1166,1176 ----
declarations, both will have the same name, yet
the types will be different, hence the TREE_TYPE field
of the first name will be clobbered by the second. */
! pp_cxx_identifier (cxx_pp, "operator");
dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
}
else if (IDENTIFIER_OPNAME_P (name))
! pp_cxx_tree_identifier (cxx_pp, name);
else
dump_decl (name, flags);
*************** dump_template_parms (tree info, int prim
*** 1197,1203 ****
if (primary && flags & TFF_TEMPLATE_NAME)
return;
flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
! pp_template_argument_list_start (cxx_pp);
/* Be careful only to print things when we have them, so as not
to crash producing error messages. */
--- 1197,1203 ----
if (primary && flags & TFF_TEMPLATE_NAME)
return;
flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
! 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. */
*************** dump_template_parms (tree info, int prim
*** 1242,1248 ****
dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
}
}
! pp_template_argument_list_end (cxx_pp);
}
/* Print out a list of initializers (subr of dump_expr). */
--- 1242,1248 ----
dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
}
}
! pp_cxx_end_template_argument_list (cxx_pp);
}
/* Print out a list of initializers (subr of dump_expr). */
*************** dump_expr (tree t, int flags)
*** 1288,1326 ****
break;
case THROW_EXPR:
! pp_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)));
break;
case COMPOUND_EXPR:
! pp_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);
break;
case COND_EXPR:
! pp_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);
break;
case SAVE_EXPR:
if (TREE_HAS_CONSTRUCTOR (t))
{
! pp_string (cxx_pp, "new ");
dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
}
else
--- 1288,1327 ----
break;
case THROW_EXPR:
! 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_cxx_colon_colon (cxx_pp);
! pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
break;
case COMPOUND_EXPR:
! 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:
! 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_cxx_right_paren (cxx_pp);
break;
case SAVE_EXPR:
if (TREE_HAS_CONSTRUCTOR (t))
{
! pp_cxx_identifier (cxx_pp, "new");
! pp_cxx_whitespace (cxx_pp);
dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
}
else
*************** dump_expr (tree t, int flags)
*** 1337,1353 ****
if (fn && TREE_CODE (fn) == FUNCTION_DECL)
{
if (DECL_CONSTRUCTOR_P (fn))
! pp_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);
if (TREE_OPERAND (t, 1))
dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
! pp_right_paren (cxx_pp);
break;
case CALL_EXPR:
--- 1338,1354 ----
if (fn && TREE_CODE (fn) == FUNCTION_DECL)
{
if (DECL_CONSTRUCTOR_P (fn))
! 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_cxx_left_paren (cxx_pp);
if (TREE_OPERAND (t, 1))
dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
! pp_cxx_right_paren (cxx_pp);
break;
case CALL_EXPR:
*************** dump_expr (tree t, int flags)
*** 1375,1383 ****
args = TREE_CHAIN (args);
}
dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
! pp_left_paren (cxx_pp);
dump_expr_list (args, flags);
! pp_right_paren (cxx_pp);
}
break;
--- 1376,1384 ----
args = TREE_CHAIN (args);
}
dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
! pp_cxx_left_paren (cxx_pp);
dump_expr_list (args, flags);
! pp_cxx_right_paren (cxx_pp);
}
break;
*************** dump_expr (tree t, int flags)
*** 1386,1398 ****
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 ");
if (TREE_OPERAND (t, 0))
{
! pp_left_paren (cxx_pp);
dump_expr_list (TREE_OPERAND (t, 0), flags);
! pp_string (cxx_pp, ") ");
}
if (TREE_CODE (type) == ARRAY_REF)
type = build_cplus_array_type
--- 1387,1400 ----
tree type = TREE_OPERAND (t, 1);
tree init = TREE_OPERAND (t, 2);
if (NEW_EXPR_USE_GLOBAL (t))
! pp_cxx_colon_colon (cxx_pp);
! pp_cxx_identifier (cxx_pp, "new");
if (TREE_OPERAND (t, 0))
{
! pp_cxx_left_paren (cxx_pp);
dump_expr_list (TREE_OPERAND (t, 0), flags);
! pp_cxx_right_paren (cxx_pp);
! pp_cxx_whitespace (cxx_pp);
}
if (TREE_CODE (type) == ARRAY_REF)
type = build_cplus_array_type
*************** dump_expr (tree t, int flags)
*** 1403,1409 ****
dump_type (type, flags);
if (init)
{
! pp_left_paren (cxx_pp);
if (TREE_CODE (init) == TREE_LIST)
dump_expr_list (init, flags);
else if (init == void_zero_node)
--- 1405,1411 ----
dump_type (type, flags);
if (init)
{
! pp_cxx_left_paren (cxx_pp);
if (TREE_CODE (init) == TREE_LIST)
dump_expr_list (init, flags);
else if (init == void_zero_node)
*************** dump_expr (tree t, int flags)
*** 1412,1418 ****
;
else
dump_expr (init, flags);
! pp_right_paren (cxx_pp);
}
}
break;
--- 1414,1420 ----
;
else
dump_expr (init, flags);
! pp_cxx_right_paren (cxx_pp);
}
}
break;
*************** dump_expr (tree t, int flags)
*** 1475,1487 ****
|| strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
{
dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
! pp_arrow (cxx_pp);
}
}
else
{
dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
! pp_dot (cxx_pp);
}
dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
}
--- 1477,1489 ----
|| strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
{
dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
! pp_cxx_arrow (cxx_pp);
}
}
else
{
dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
! pp_cxx_dot (cxx_pp);
}
dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
}
*************** dump_expr (tree t, int flags)
*** 1489,1505 ****
case ARRAY_REF:
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
! pp_left_bracket (cxx_pp);
dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
! pp_right_bracket (cxx_pp);
break;
case CONVERT_EXPR:
if (TREE_TYPE (t) && VOID_TYPE_P (TREE_TYPE (t)))
{
! pp_left_paren (cxx_pp);
dump_type (TREE_TYPE (t), flags);
! pp_right_paren (cxx_pp);
dump_expr (TREE_OPERAND (t, 0), flags);
}
else
--- 1491,1507 ----
case ARRAY_REF:
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
! pp_cxx_left_bracket (cxx_pp);
dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
! pp_cxx_right_bracket (cxx_pp);
break;
case CONVERT_EXPR:
if (TREE_TYPE (t) && VOID_TYPE_P (TREE_TYPE (t)))
{
! pp_cxx_left_paren (cxx_pp);
dump_type (TREE_TYPE (t), flags);
! pp_cxx_right_paren (cxx_pp);
dump_expr (TREE_OPERAND (t, 0), flags);
}
else
*************** dump_expr (tree t, int flags)
*** 1525,1533 ****
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);
dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
! pp_right_paren (cxx_pp);
}
else
{
--- 1527,1535 ----
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_cxx_left_paren (cxx_pp);
dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
! pp_cxx_right_paren (cxx_pp);
}
else
{
*************** dump_expr (tree t, int flags)
*** 1550,1559 ****
case POSTDECREMENT_EXPR:
case POSTINCREMENT_EXPR:
! pp_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);
break;
case NON_LVALUE_EXPR:
--- 1552,1561 ----
case POSTDECREMENT_EXPR:
case POSTINCREMENT_EXPR:
! pp_cxx_left_paren (cxx_pp);
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
! pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
! pp_cxx_right_paren (cxx_pp);
break;
case NON_LVALUE_EXPR:
*************** dump_expr (tree t, int flags)
*** 1570,1580 ****
if (TREE_CODE (next) == FUNCTION_TYPE)
{
if (flags & TFF_EXPR_IN_PARENS)
! pp_left_paren (cxx_pp);
! pp_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);
break;
}
/* Else fall through. */
--- 1572,1582 ----
if (TREE_CODE (next) == FUNCTION_TYPE)
{
if (flags & TFF_EXPR_IN_PARENS)
! 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_cxx_right_paren (cxx_pp);
break;
}
/* Else fall through. */
*************** dump_expr (tree t, int flags)
*** 1591,1603 ****
/* 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);
dump_type (TREE_TYPE (t), flags);
! pp_right_paren (cxx_pp);
dump_expr (op, flags | TFF_EXPR_IN_PARENS);
if (flags & TFF_EXPR_IN_PARENS)
! pp_right_paren (cxx_pp);
}
else
dump_expr (op, flags);
--- 1593,1605 ----
/* 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);
*************** dump_expr (tree t, int flags)
*** 1612,1622 ****
if (integer_zerop (idx))
{
/* A NULL pointer-to-member constant. */
! pp_left_paren (cxx_pp);
! pp_left_paren (cxx_pp);
dump_type (TREE_TYPE (t), flags);
! pp_right_paren (cxx_pp);
! pp_string (cxx_pp, ")0)");
break;
}
else if (host_integerp (idx, 0))
--- 1614,1625 ----
if (integer_zerop (idx))
{
/* A NULL pointer-to-member constant. */
! pp_cxx_left_paren (cxx_pp);
! pp_cxx_left_paren (cxx_pp);
dump_type (TREE_TYPE (t), flags);
! pp_cxx_right_paren (cxx_pp);
! pp_character (cxx_pp, '0');
! pp_cxx_right_paren (cxx_pp);
break;
}
else if (host_integerp (idx, 0))
*************** dump_expr (tree t, int flags)
*** 1650,1663 ****
if (TREE_TYPE (t) && !CONSTRUCTOR_ELTS (t))
{
dump_type (TREE_TYPE (t), 0);
! pp_left_paren (cxx_pp);
! pp_right_paren (cxx_pp);
}
else
{
! pp_left_brace (cxx_pp);
dump_expr_list (CONSTRUCTOR_ELTS (t), flags);
! pp_right_brace (cxx_pp);
}
break;
--- 1653,1666 ----
if (TREE_TYPE (t) && !CONSTRUCTOR_ELTS (t))
{
dump_type (TREE_TYPE (t), 0);
! pp_cxx_left_paren (cxx_pp);
! pp_cxx_right_paren (cxx_pp);
}
else
{
! pp_cxx_left_brace (cxx_pp);
dump_expr_list (CONSTRUCTOR_ELTS (t), flags);
! pp_cxx_right_brace (cxx_pp);
}
break;
*************** dump_expr (tree t, int flags)
*** 1682,1693 ****
if (TREE_CODE (ob) == INDIRECT_REF)
{
dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
! pp_string (cxx_pp, "->*");
}
else
{
dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
! pp_string (cxx_pp, ".*");
}
dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
}
--- 1685,1698 ----
if (TREE_CODE (ob) == INDIRECT_REF)
{
dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
! pp_cxx_arrow (cxx_pp);
! pp_cxx_star (cxx_pp);
}
else
{
dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
! pp_cxx_dot (cxx_pp);
! pp_cxx_star (cxx_pp);
}
dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
}
*************** dump_expr (tree t, int flags)
*** 1700,1706 ****
case SCOPE_REF:
dump_type (TREE_OPERAND (t, 0), flags);
! pp_colon_colon (cxx_pp);
dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
break;
--- 1705,1711 ----
case SCOPE_REF:
dump_type (TREE_OPERAND (t, 0), flags);
! pp_cxx_colon_colon (cxx_pp);
dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
break;
*************** dump_expr (tree t, int flags)
*** 1709,1771 ****
|| TREE_CHAIN (TREE_OPERAND (t, 0)))
{
dump_type (TREE_TYPE (t), flags);
! pp_left_paren (cxx_pp);
dump_expr_list (TREE_OPERAND (t, 0), flags);
! pp_right_paren (cxx_pp);
}
else
{
! pp_left_paren (cxx_pp);
dump_type (TREE_TYPE (t), flags);
! pp_string (cxx_pp, ")(");
dump_expr_list (TREE_OPERAND (t, 0), flags);
! pp_right_paren (cxx_pp);
}
break;
case STATIC_CAST_EXPR:
! pp_string (cxx_pp, "static_cast<");
goto cast;
case REINTERPRET_CAST_EXPR:
! pp_string (cxx_pp, "reinterpret_cast<");
goto cast;
case CONST_CAST_EXPR:
! pp_string (cxx_pp, "const_cast<");
goto cast;
case DYNAMIC_CAST_EXPR:
! pp_string (cxx_pp, "dynamic_cast<");
cast:
dump_type (TREE_TYPE (t), flags);
! pp_string (cxx_pp, ">(");
dump_expr (TREE_OPERAND (t, 0), flags);
! pp_right_paren (cxx_pp);
break;
case ARROW_EXPR:
dump_expr (TREE_OPERAND (t, 0), flags);
! pp_arrow (cxx_pp);
break;
case SIZEOF_EXPR:
case ALIGNOF_EXPR:
if (TREE_CODE (t) == SIZEOF_EXPR)
! pp_string (cxx_pp, "sizeof (");
else
{
my_friendly_assert (TREE_CODE (t) == ALIGNOF_EXPR, 0);
! pp_string (cxx_pp, "__alignof__ (");
}
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);
break;
case REALPART_EXPR:
case IMAGPART_EXPR:
! pp_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
! pp_space (cxx_pp);
dump_expr (TREE_OPERAND (t, 0), flags);
break;
--- 1714,1781 ----
|| TREE_CHAIN (TREE_OPERAND (t, 0)))
{
dump_type (TREE_TYPE (t), flags);
! pp_cxx_left_paren (cxx_pp);
dump_expr_list (TREE_OPERAND (t, 0), flags);
! pp_cxx_right_paren (cxx_pp);
}
else
{
! pp_cxx_left_paren (cxx_pp);
dump_type (TREE_TYPE (t), flags);
! pp_cxx_right_paren (cxx_pp);
! pp_cxx_left_paren (cxx_pp);
dump_expr_list (TREE_OPERAND (t, 0), flags);
! pp_cxx_right_paren (cxx_pp);
}
break;
case STATIC_CAST_EXPR:
! pp_cxx_identifier (cxx_pp, "static_cast");
goto cast;
case REINTERPRET_CAST_EXPR:
! pp_cxx_identifier (cxx_pp, "reinterpret_cast");
goto cast;
case CONST_CAST_EXPR:
! pp_cxx_identifier (cxx_pp, "const_cast");
goto cast;
case DYNAMIC_CAST_EXPR:
! pp_cxx_identifier (cxx_pp, "dynamic_cast");
cast:
+ pp_cxx_begin_template_argument_list (cxx_pp);
dump_type (TREE_TYPE (t), flags);
! pp_cxx_end_template_argument_list (cxx_pp);
! pp_cxx_left_paren (cxx_pp);
dump_expr (TREE_OPERAND (t, 0), flags);
! pp_cxx_right_paren (cxx_pp);
break;
case ARROW_EXPR:
dump_expr (TREE_OPERAND (t, 0), flags);
! pp_cxx_arrow (cxx_pp);
break;
case SIZEOF_EXPR:
case ALIGNOF_EXPR:
if (TREE_CODE (t) == SIZEOF_EXPR)
! pp_cxx_identifier (cxx_pp, "sizeof");
else
{
my_friendly_assert (TREE_CODE (t) == ALIGNOF_EXPR, 0);
! 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_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;
*************** dump_expr (tree t, int flags)
*** 1781,1790 ****
case PSEUDO_DTOR_EXPR:
dump_expr (TREE_OPERAND (t, 2), flags);
! pp_dot (cxx_pp);
dump_type (TREE_OPERAND (t, 0), flags);
! pp_colon_colon (cxx_pp);
! pp_complement (cxx_pp);
dump_type (TREE_OPERAND (t, 1), flags);
break;
--- 1791,1800 ----
case PSEUDO_DTOR_EXPR:
dump_expr (TREE_OPERAND (t, 2), flags);
! pp_cxx_dot (cxx_pp);
dump_type (TREE_OPERAND (t, 0), flags);
! pp_cxx_colon_colon (cxx_pp);
! pp_cxx_complement (cxx_pp);
dump_type (TREE_OPERAND (t, 1), flags);
break;
*************** dump_expr (tree t, int flags)
*** 1799,1813 ****
break;
case BIND_EXPR:
! pp_left_brace (cxx_pp);
dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
! pp_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);
break;
case EXIT_EXPR:
--- 1809,1823 ----
break;
case BIND_EXPR:
! pp_cxx_left_brace (cxx_pp);
dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
! 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_cxx_right_brace (cxx_pp);
break;
case EXIT_EXPR:
*************** dump_expr (tree t, int flags)
*** 1822,1829 ****
case EMPTY_CLASS_EXPR:
dump_type (TREE_TYPE (t), flags);
! pp_left_paren (cxx_pp);
! pp_right_paren (cxx_pp);
break;
case NON_DEPENDENT_EXPR:
--- 1832,1839 ----
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 t, int flags)
*** 1845,1880 ****
static void
dump_binary_op (const char *opstring, tree t, int flags)
{
! pp_left_paren (cxx_pp);
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
! pp_space (cxx_pp);
if (opstring)
! pp_identifier (cxx_pp, opstring);
else
pp_identifier (cxx_pp, "<unknown operator>");
! pp_space (cxx_pp);
dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
! pp_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);
dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
if (flags & TFF_EXPR_IN_PARENS)
! pp_right_paren (cxx_pp);
}
/* 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);
dump_type (typ, flags);
return pp_formatted_text (cxx_pp);
}
--- 1855,1901 ----
static void
dump_binary_op (const char *opstring, tree t, int flags)
{
! pp_cxx_left_paren (cxx_pp);
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
! pp_cxx_whitespace (cxx_pp);
if (opstring)
! pp_cxx_identifier (cxx_pp, opstring);
else
pp_identifier (cxx_pp, "<unknown operator>");
! pp_cxx_whitespace (cxx_pp);
dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
! pp_cxx_right_paren (cxx_pp);
}
static void
dump_unary_op (const char *opstring, tree t, int flags)
{
if (flags & TFF_EXPR_IN_PARENS)
! pp_cxx_left_paren (cxx_pp);
! pp_cxx_identifier (cxx_pp, opstring);
dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
if (flags & TFF_EXPR_IN_PARENS)
! 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_cxx_pp ();
dump_type (typ, flags);
return pp_formatted_text (cxx_pp);
}
*************** type_as_string (tree typ, int flags)
*** 1882,1888 ****
const char *
expr_as_string (tree decl, int flags)
{
! pp_clear_output_area (cxx_pp);
dump_expr (decl, flags);
return pp_formatted_text (cxx_pp);
}
--- 1903,1909 ----
const char *
expr_as_string (tree decl, int flags)
{
! reinit_cxx_pp ();
dump_expr (decl, flags);
return pp_formatted_text (cxx_pp);
}
*************** expr_as_string (tree decl, int flags)
*** 1890,1896 ****
const char *
decl_as_string (tree decl, int flags)
{
! pp_clear_output_area (cxx_pp);
dump_decl (decl, flags);
return pp_formatted_text (cxx_pp);
}
--- 1911,1917 ----
const char *
decl_as_string (tree decl, int flags)
{
! reinit_cxx_pp ();
dump_decl (decl, flags);
return pp_formatted_text (cxx_pp);
}
*************** decl_as_string (tree decl, int flags)
*** 1898,1904 ****
const char *
context_as_string (tree context, int flags)
{
! pp_clear_output_area (cxx_pp);
dump_scope (context, flags);
return pp_formatted_text (cxx_pp);
}
--- 1919,1925 ----
const char *
context_as_string (tree context, int flags)
{
! reinit_cxx_pp ();
dump_scope (context, flags);
return pp_formatted_text (cxx_pp);
}
*************** lang_decl_name (tree decl, int v)
*** 1911,1921 ****
if (v >= 2)
return decl_as_string (decl, TFF_DECL_SPECIFIERS);
! pp_clear_output_area (cxx_pp);
if (v == 1 && DECL_CLASS_SCOPE_P (decl))
{
dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
! pp_colon_colon (cxx_pp);
}
if (TREE_CODE (decl) == FUNCTION_DECL)
--- 1932,1942 ----
if (v >= 2)
return decl_as_string (decl, TFF_DECL_SPECIFIERS);
! reinit_cxx_pp ();
if (v == 1 && DECL_CLASS_SCOPE_P (decl))
{
dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
! pp_cxx_colon_colon (cxx_pp);
}
if (TREE_CODE (decl) == FUNCTION_DECL)
*************** decl_to_string (tree decl, int verbose)
*** 1957,1963 ****
flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
flags |= TFF_TEMPLATE_HEADER;
! pp_clear_output_area (cxx_pp);
dump_decl (decl, flags);
return pp_formatted_text (cxx_pp);
}
--- 1978,1984 ----
flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
flags |= TFF_TEMPLATE_HEADER;
! reinit_cxx_pp ();
dump_decl (decl, flags);
return pp_formatted_text (cxx_pp);
}
*************** decl_to_string (tree decl, int verbose)
*** 1965,1971 ****
static const char *
expr_to_string (tree decl)
{
! pp_clear_output_area (cxx_pp);
dump_expr (decl, 0);
return pp_formatted_text (cxx_pp);
}
--- 1986,1992 ----
static const char *
expr_to_string (tree decl)
{
! reinit_cxx_pp ();
dump_expr (decl, 0);
return pp_formatted_text (cxx_pp);
}
*************** fndecl_to_string (tree fndecl, int verbo
*** 1978,1984 ****
flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS;
if (verbose)
flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
! pp_clear_output_area (cxx_pp);
dump_decl (fndecl, flags);
return pp_formatted_text (cxx_pp);
}
--- 1999,2005 ----
flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS;
if (verbose)
flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
! reinit_cxx_pp ();
dump_decl (fndecl, flags);
return pp_formatted_text (cxx_pp);
}
*************** language_to_string (enum languages c)
*** 2015,2021 ****
static const char *
parm_to_string (int p)
{
! pp_clear_output_area (cxx_pp);
if (p < 0)
pp_string (cxx_pp, "'this'");
else
--- 2036,2042 ----
static const char *
parm_to_string (int p)
{
! reinit_cxx_pp ();
if (p < 0)
pp_string (cxx_pp, "'this'");
else
*************** type_to_string (tree typ, int verbose)
*** 2038,2044 ****
flags |= TFF_CLASS_KEY_OR_ENUM;
flags |= TFF_TEMPLATE_HEADER;
! pp_clear_output_area (cxx_pp);
dump_type (typ, flags);
return pp_formatted_text (cxx_pp);
}
--- 2059,2065 ----
flags |= TFF_CLASS_KEY_OR_ENUM;
flags |= TFF_TEMPLATE_HEADER;
! reinit_cxx_pp ();
dump_type (typ, flags);
return pp_formatted_text (cxx_pp);
}
*************** args_to_string (tree p, int verbose)
*** 2063,2073 ****
if (TYPE_P (TREE_VALUE (p)))
return type_as_string (p, flags);
! pp_clear_output_area (cxx_pp);
for (; p; p = TREE_CHAIN (p))
{
if (TREE_VALUE (p) == null_node)
! pp_identifier (cxx_pp, "NULL");
else
dump_type (error_type (TREE_VALUE (p)), flags);
if (TREE_CHAIN (p))
--- 2084,2094 ----
if (TYPE_P (TREE_VALUE (p)))
return type_as_string (p, flags);
! reinit_cxx_pp ();
for (; p; p = TREE_CHAIN (p))
{
if (TREE_VALUE (p) == null_node)
! pp_cxx_identifier (cxx_pp, "NULL");
else
dump_type (error_type (TREE_VALUE (p)), flags);
if (TREE_CHAIN (p))
*************** args_to_string (tree p, int verbose)
*** 2079,2085 ****
static const char *
cv_to_string (tree p, int v)
{
! pp_clear_output_area (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);
--- 2100,2106 ----
static const char *
cv_to_string (tree p, int v)
{
! 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);
*************** cp_printer (pretty_printer *pp, text_inf
*** 2289,2304 ****
#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. */
--- 2310,2315 ----