/* Call-backs for C++ error reporting.
This code is non-reentrant.
Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002,
- 2003 Free Software Foundation, Inc.
+ 2003, 2004 Free Software Foundation, Inc.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify
#include "langhooks-def.h"
#include "cxx-pretty-print.h"
-enum pad { none, before, after };
-
-#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
# define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
-#define reinit_global_formatting_buffer() \
- output_clear_message_text (scratch_buffer)
-
static const char *args_to_string (tree, int);
static const char *assop_to_string (enum tree_code);
static const char *code_to_string (enum tree_code);
static void dump_unary_op (const char *, tree, int);
static void dump_binary_op (const char *, tree, int);
static void dump_aggr_type (tree, int);
-static enum pad dump_type_prefix (tree, int);
+static void dump_type_prefix (tree, int);
static void dump_type_suffix (tree, int);
static void dump_function_name (tree, int);
static void dump_expr_list (tree, int);
static void dump_global_iord (tree);
-static enum pad dump_qualifiers (tree, enum pad);
static void dump_parameters (tree, int);
static void dump_exception_spec (tree, int);
-static const char *class_key_or_enum (tree);
static void dump_template_argument (tree, int);
static void dump_template_argument_list (tree, int);
static void dump_template_parameter (tree, int);
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);
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);
}
}
-/* Dump type qualifiers, providing padding as requested. Return an
- indication of whether we dumped something. */
-
-static enum pad
-dump_qualifiers (tree t, enum pad p)
-{
- static const int masks[] =
- {TYPE_QUAL_CONST, TYPE_QUAL_VOLATILE, TYPE_QUAL_RESTRICT};
- static const char *const names[] =
- {"const", "volatile", "__restrict"};
- int ix;
- int quals = TYPE_QUALS (t);
- int do_after = p == after;
-
- if (quals)
- {
- for (ix = 0; ix != 3; ix++)
- if (masks[ix] & quals)
- {
- if (p == before)
- pp_space (cxx_pp);
- p = before;
- pp_identifier (cxx_pp, names[ix]);
- }
- if (do_after)
- pp_space (cxx_pp);
- }
- else
- p = none;
- return p;
-}
-
/* Dump the template ARGument under control of FLAGS. */
static void
{
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));
}
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
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
break;
case IDENTIFIER_NODE:
- pp_tree_identifier (cxx_pp, t);
+ pp_cxx_tree_identifier (cxx_pp, t);
break;
- case TREE_VEC:
+ case TREE_BINFO:
dump_type (BINFO_TYPE (t), flags);
break;
? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
break;
}
- /* else fallthrough */
+ /* Else fall through. */
case TEMPLATE_DECL:
case NAMESPACE_DECL:
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;
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_cv_qualifier_seq (cxx_pp, t);
+ pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
+ pp_cxx_begin_template_argument_list (cxx_pp);
dump_template_argument_list (args, flags);
- pp_template_argument_list_end (cxx_pp);
+ pp_cxx_end_template_argument_list (cxx_pp);
}
break;
case TEMPLATE_TYPE_PARM:
- dump_qualifiers (t, after);
+ pp_cxx_cv_qualifier_seq (cxx_pp, t);
if (TYPE_IDENTIFIER (t))
- 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));
break;
}
case TYPENAME_TYPE:
- dump_qualifiers (t, after);
- pp_string (cxx_pp, "typename ");
+ pp_cxx_cv_qualifier_seq (cxx_pp, t);
+ pp_cxx_identifier (cxx_pp,
+ TYPENAME_IS_ENUM_P (t) ? "enum"
+ : TYPENAME_IS_CLASS_P (t) ? "class"
+ : "typename");
dump_typename (t, flags);
break;
case UNBOUND_CLASS_TEMPLATE:
dump_type (TYPE_CONTEXT (t), flags);
- 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 (");
- dump_expr (TYPE_FIELDS (t), flags & ~TFF_EXPR_IN_PARENS);
- pp_right_paren (cxx_pp);
+ 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 (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);
}
/* Return the name of the supplied aggregate, or enumeral type. */
-static const char *
-class_key_or_enum (tree t)
+const char *
+class_key_or_enum_as_string (tree t)
{
if (TREE_CODE (t) == ENUMERAL_TYPE)
return "enum";
dump_aggr_type (tree t, int flags)
{
tree name;
- const char *variety = class_key_or_enum (t);
+ const char *variety = class_key_or_enum_as_string (t);
int typdef = 0;
int tmplate = 0;
- dump_qualifiers (t, after);
+ pp_cxx_cv_qualifier_seq (cxx_pp, t);
if (flags & TFF_CLASS_KEY_OR_ENUM)
- {
- 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);
pp_printf (pp_base (cxx_pp), "<anonymous %s>", 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),
deal with prefix and suffix.
Arrays must also do this for DECL nodes, like int a[], and for things like
- int *[]&.
-
- Return indicates how you should pad an object name after this. I.e. you
- want to pad non-*, non-& cores, but not pad * or & types. */
+ int *[]&. */
-static enum pad
+static void
dump_type_prefix (tree t, int flags)
{
- enum pad padding = before;
-
if (TYPE_PTRMEMFUNC_P (t))
{
t = TYPE_PTRMEMFUNC_FN_TYPE (t);
{
tree sub = TREE_TYPE (t);
- padding = dump_type_prefix (sub, 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]);
- padding = dump_qualifiers (t, before);
+ pp_base (cxx_pp)->padding = pp_before;
+ pp_cxx_cv_qualifier_seq (cxx_pp, t);
}
break;
case OFFSET_TYPE:
offset_type:
- padding = dump_type_prefix (TREE_TYPE (t), flags);
+ dump_type_prefix (TREE_TYPE (t), flags);
if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
{
- if (padding != none)
- pp_space (cxx_pp);
+ pp_maybe_space (cxx_pp);
+ if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
+ pp_cxx_left_paren (cxx_pp);
dump_type (TYPE_OFFSET_BASETYPE (t), flags);
- pp_colon_colon (cxx_pp);
+ pp_cxx_colon_colon (cxx_pp);
}
- pp_star (cxx_pp);
- padding = dump_qualifiers (t, none);
+ pp_cxx_star (cxx_pp);
+ pp_cxx_cv_qualifier_seq (cxx_pp, t);
+ pp_base (cxx_pp)->padding = pp_before;
break;
/* Can only be reached through function pointer -- this would not be
correct if FUNCTION_DECLs used it. */
case FUNCTION_TYPE:
- padding = dump_type_prefix (TREE_TYPE (t), flags);
- if (padding != none)
- pp_space (cxx_pp);
- pp_left_paren (cxx_pp);
- padding = none;
+ dump_type_prefix (TREE_TYPE (t), flags);
+ pp_maybe_space (cxx_pp);
+ pp_cxx_left_paren (cxx_pp);
break;
case METHOD_TYPE:
- padding = dump_type_prefix (TREE_TYPE (t), flags);
- if (padding != none)
- pp_space (cxx_pp);
- pp_left_paren (cxx_pp);
- padding = none;
+ dump_type_prefix (TREE_TYPE (t), flags);
+ pp_maybe_space (cxx_pp);
+ pp_cxx_left_paren (cxx_pp);
dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
- pp_colon_colon (cxx_pp);
+ pp_cxx_colon_colon (cxx_pp);
break;
case ARRAY_TYPE:
- padding = dump_type_prefix (TREE_TYPE (t), flags);
+ dump_type_prefix (TREE_TYPE (t), flags);
break;
case ENUMERAL_TYPE:
case VECTOR_TYPE:
case TYPEOF_TYPE:
dump_type (t, flags);
- padding = before;
+ pp_base (cxx_pp)->padding = pp_before;
break;
default:
pp_identifier (cxx_pp, "<typeprefixerror>");
break;
}
- return padding;
}
/* Dump the suffix of type T, under control of FLAGS. This is the part
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;
- /* Can only be reached through function pointer */
+ /* Can only be reached through function pointer. */
case FUNCTION_TYPE:
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);
dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
if (TREE_CODE (t) == METHOD_TYPE)
- dump_qualifiers
- (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), before);
+ pp_cxx_cv_qualifier_seq
+ (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
+ else
+ pp_cxx_cv_qualifier_seq(cxx_pp, t);
dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
dump_type_suffix (TREE_TYPE (t), flags);
break;
}
case ARRAY_TYPE:
- pp_left_bracket (cxx_pp);
+ pp_maybe_space (cxx_pp);
+ pp_cxx_left_bracket (cxx_pp);
if (TYPE_DOMAIN (t))
{
if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0))
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;
else if (DECL_GLOBAL_DTOR_P (t))
p = "destructors";
else
- abort ();
+ gcc_unreachable ();
pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename);
}
{
if (flags & TFF_DECL_SPECIFIERS)
{
- if (dump_type_prefix (type, flags) != none)
- pp_space (cxx_pp);
+ dump_type_prefix (type, flags);
+ pp_maybe_space (cxx_pp);
}
if (!DECL_INITIAL (t) || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX)
dump_scope (CP_DECL_CONTEXT (t), flags);
switch (TREE_CODE (t))
{
case TYPE_DECL:
- {
- /* Don't say 'typedef class A' */
- if (DECL_ARTIFICIAL (t))
- {
- if ((flags & TFF_DECL_SPECIFIERS)
- && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
- /* Say `class T' not just `T'. */
- pp_string (cxx_pp, "class ");
-
- dump_type (TREE_TYPE (t), flags);
- break;
- }
- }
+ /* Don't say 'typedef class A' */
+ if (DECL_ARTIFICIAL (t))
+ {
+ if ((flags & TFF_DECL_SPECIFIERS)
+ && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
+ /* Say `class T' not just `T'. */
+ pp_cxx_identifier (cxx_pp, "class");
+
+ dump_type (TREE_TYPE (t), flags);
+ break;
+ }
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);
if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
{
pp_string (cxx_pp, "vtable for ");
- my_friendly_assert (TYPE_P (DECL_CONTEXT (t)), 20010720);
+ gcc_assert (TYPE_P (DECL_CONTEXT (t)));
dump_type (DECL_CONTEXT (t), flags);
break;
}
- /* else fall through */
+ /* Else fall through. */
case FIELD_DECL:
case PARM_DECL:
+ case ALIAS_DECL:
dump_simple_decl (t, TREE_TYPE (t), flags);
break;
else
{
dump_scope (CP_DECL_CONTEXT (t), flags);
- if (DECL_NAME (t) == anonymous_namespace_name)
+ if (DECL_NAME (t) == NULL_TREE)
pp_identifier (cxx_pp, "<unnamed>");
else
- pp_tree_identifier (cxx_pp, DECL_NAME (t));
+ pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
}
break;
case SCOPE_REF:
- dump_decl (TREE_OPERAND (t, 0), flags & ~TFF_DECL_SPECIFIERS);
- pp_colon_colon (cxx_pp);
- dump_decl (TREE_OPERAND (t, 1), flags);
+ pp_expression (cxx_pp, t);
break;
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. */
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;
case TYPE_EXPR:
- abort ();
+ gcc_unreachable ();
break;
/* These special cases are duplicated here so that other functions
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:
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;
/* Fall through. */
case FUNCTION_DECL:
- if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
+ if (! DECL_LANG_SPECIFIC (t))
+ pp_identifier (cxx_pp, "<built-in>");
+ else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
dump_global_iord (t);
- else if (! DECL_LANG_SPECIFIC (t))
- pp_identifier (cxx_pp, "<internal>");
else
dump_function_decl (t, flags);
break;
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:
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;
dump_expr (t, flags);
break;
+ case TEMPLATE_TYPE_PARM:
+ if (flags & TFF_DECL_SPECIFIERS)
+ pp_cxx_declaration (cxx_pp, t);
+ else
+ pp_type_id (cxx_pp, t);
+ break;
+
default:
pp_unsupported_tree (cxx_pp, t);
- /* Fallthrough to error. */
+ /* Fall through to error. */
case ERROR_MARK:
pp_identifier (cxx_pp, "<declaration error>");
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. */
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<arg> class TT' not just `template<arg> TT'. */
- pp_string (cxx_pp, "class ");
+ pp_cxx_identifier (cxx_pp, "class");
}
if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
| (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
- else if (TREE_TYPE (t) == NULL_TREE)
- abort ();
else
- switch (NEXT_CODE (t))
{
- case METHOD_TYPE:
- case FUNCTION_TYPE:
- dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
- break;
- default:
- /* This case can occur with some invalid code. */
- dump_type (TREE_TYPE (t),
- (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
- | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0));
+ gcc_assert (TREE_TYPE (t));
+ switch (NEXT_CODE (t))
+ {
+ case METHOD_TYPE:
+ case FUNCTION_TYPE:
+ dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
+ break;
+ default:
+ /* This case can occur with some invalid code. */
+ dump_type (TREE_TYPE (t),
+ (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
+ | (flags & TFF_DECL_SPECIFIERS
+ ? TFF_CLASS_KEY_OR_ENUM : 0));
+ }
}
}
if (DECL_CLASS_SCOPE_P (t))
cname = DECL_CONTEXT (t);
- /* this is for partially instantiated template methods */
+ /* This is for partially instantiated template methods. */
else if (TREE_CODE (fntype) == METHOD_TYPE)
cname = TREE_TYPE (TREE_VALUE (parmtypes));
if (!(flags & TFF_DECL_SPECIFIERS))
/* OK */;
else if (DECL_STATIC_FUNCTION_P (t))
- 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);
dump_function_name (t, flags);
- if (1)
+ if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
{
dump_parameters (parmtypes, flags);
if (TREE_CODE (fntype) == METHOD_TYPE)
- dump_qualifiers (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))),
- before);
+ {
+ pp_base (cxx_pp)->padding = pp_before;
+ pp_cxx_cv_qualifier_seq
+ (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
+ }
if (flags & TFF_EXCEPTION_SPECIFICATION)
- dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
+ {
+ pp_base (cxx_pp)->padding = pp_before;
+ dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
+ }
if (show_return)
dump_type_suffix (TREE_TYPE (fntype), flags);
/* 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);
}
}
{
int first;
- pp_left_paren (cxx_pp);
+ pp_cxx_left_paren (cxx_pp);
for (first = 1; parmtypes != void_list_node;
parmtypes = TREE_CHAIN (parmtypes))
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. */
{
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)
{
break;
pp_separate_with_comma (cxx_pp);
}
- pp_right_paren (cxx_pp);
+ pp_cxx_right_paren (cxx_pp);
}
}
{
tree name = DECL_NAME (t);
+ /* We can get here with a decl that was synthesized by language-
+ independent machinery (e.g. coverage.c) in which case it won't
+ have a lang_specific structure attached and DECL_CONSTRUCTOR_P
+ will crash. In this case it is safe just to print out the
+ literal name. */
+ if (!DECL_LANG_SPECIFIC (t))
+ {
+ pp_cxx_tree_identifier (cxx_pp, name);
+ return;
+ }
+
if (TREE_CODE (t) == TEMPLATE_DECL)
t = DECL_TEMPLATE_RESULT (t);
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))
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);
- if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
+ if (DECL_TEMPLATE_INFO (t)
&& !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
&& (DECL_TEMPLATE_SPECIALIZATION (t)
|| TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
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. */
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) */
+/* Print out a list of initializers (subr of dump_expr). */
static void
dump_expr_list (tree l, int flags)
case NAMESPACE_DECL:
case OVERLOAD:
case IDENTIFIER_NODE:
- dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
+ dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
break;
- case INTEGER_CST:
case STRING_CST:
+ if (PAREN_STRING_LITERAL_P (t))
+ pp_cxx_left_paren (cxx_pp);
+ pp_c_constant (pp_c_base (cxx_pp), t);
+ if (PAREN_STRING_LITERAL_P (t))
+ pp_cxx_right_paren (cxx_pp);
+ break;
+
+ case INTEGER_CST:
case REAL_CST:
pp_c_constant (pp_c_base (cxx_pp), t);
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_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
if (fn && TREE_CODE (fn) == FUNCTION_DECL)
{
if (DECL_CONSTRUCTOR_P (fn))
- pp_tree_identifier (cxx_pp, TYPE_IDENTIFIER (TREE_TYPE (t)));
+ dump_type (DECL_CONTEXT (fn), flags);
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:
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;
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
(TREE_OPERAND (type, 0),
- build_index_type (fold (build (MINUS_EXPR, integer_type_node,
- TREE_OPERAND (type, 1),
- integer_one_node))));
+ build_index_type (fold (build2 (MINUS_EXPR, integer_type_node,
+ TREE_OPERAND (type, 1),
+ integer_one_node))));
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)
;
else
dump_expr (init, flags);
- pp_right_paren (cxx_pp);
+ pp_cxx_right_paren (cxx_pp);
}
}
break;
case CEIL_DIV_EXPR:
case FLOOR_DIV_EXPR:
case ROUND_DIV_EXPR:
+ case RDIV_EXPR:
dump_binary_op ("/", t, flags);
break;
|| 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);
}
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
if (TREE_HAS_CONSTRUCTOR (t))
{
t = TREE_OPERAND (t, 0);
- my_friendly_assert (TREE_CODE (t) == CALL_EXPR, 237);
+ gcc_assert (TREE_CODE (t) == CALL_EXPR);
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
- 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
{
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:
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 FALLTHRU */
+ /* Else fall through. */
}
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
break;
/* 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);
break;
}
- case EXPR_WITH_FILE_LOCATION:
- dump_expr (EXPR_WFL_NODE (t), flags);
- break;
-
case CONSTRUCTOR:
if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
{
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))
t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
t = TYPE_METHOD_BASETYPE (t);
- virtuals = TYPE_BINFO_VIRTUALS (TYPE_MAIN_VARIANT (t));
+ virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
n = tree_low_cst (idx, 0);
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;
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);
}
break;
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);
+ pp_expression (cxx_pp, t);
break;
case CAST_EXPR:
|| 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__ (");
+ gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
+ pp_cxx_identifier (cxx_pp, "__alignof__");
}
+ pp_cxx_whitespace (cxx_pp);
+ pp_cxx_left_paren (cxx_pp);
if (TYPE_P (TREE_OPERAND (t, 0)))
dump_type (TREE_OPERAND (t, 0), flags);
else
dump_expr (TREE_OPERAND (t, 0), flags);
- 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;
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;
dump_decl (t, flags);
break;
+ case BIND_EXPR:
case STMT_EXPR:
+ case STATEMENT_LIST:
/* We don't yet have a way of dumping statements in a
human-readable format. */
pp_string (cxx_pp, "({...})");
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);
+ pp_cxx_right_brace (cxx_pp);
break;
case EXIT_EXPR:
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:
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, "<unknown operator>");
- 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);
}
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);
}
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);
}
-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);
-}
-
/* Generate the three forms of printable names for cxx_printable_name. */
const char *
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)
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);
}
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);
}
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);
}
return "Java";
default:
- abort ();
- return 0;
+ gcc_unreachable ();
}
+ return 0;
}
/* Return the proper printed version of a parameter to a C++ function. */
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
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);
}
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))
static const char *
cv_to_string (tree p, int v)
{
- pp_clear_output_area (cxx_pp);
- dump_qualifiers (p, v ? before : none);
+ 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);
}
if (diagnostic_last_function_changed (context))
{
const char *old_prefix = context->printer->prefix;
- char *new_prefix = diagnostic->location.file
- ? file_name_as_prefix (diagnostic->location.file)
- : NULL;
+ const char *file = LOCATION_FILE (diagnostic->location);
+ char *new_prefix = file ? file_name_as_prefix (file) : NULL;
pp_base_set_prefix (context->printer, new_prefix);
if (current_function_decl == NULL)
pp_base_string (context->printer, "At global scope:");
else
- pp_printf (context->printer, "In %s `%s':",
+ pp_printf (context->printer, "In %s %qs:",
function_category (current_function_decl),
cxx_printable_name (current_function_decl, 2));
pp_base_newline (context->printer);
/* Avoid redundancy with the the "In function" line. */;
else
pp_verbatim (context->printer,
- "%s: In instantiation of `%s':\n", location.file,
+ "%s: In instantiation of %qs:\n",
+ LOCATION_FILE (location),
decl_as_string (TINST_DECL (p),
TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
- location.line = TINST_LINE (p);
- location.file = TINST_FILE (p);
+ location = TINST_LOCATION (p);
p = TREE_CHAIN (p);
}
}
print_instantiation_partial_context (diagnostic_context *context,
tree t, location_t loc)
{
- for (; t; t = TREE_CHAIN (t))
+ expanded_location xloc;
+ for (; ; t = TREE_CHAIN (t))
{
- pp_verbatim (context->printer, "%s:%d: instantiated from `%s'\n",
- loc.file, loc.line,
+ xloc = expand_location (loc);
+ if (t == NULL_TREE)
+ break;
+ pp_verbatim (context->printer, "%s:%d: instantiated from %qs\n",
+ xloc.file, xloc.line,
decl_as_string (TINST_DECL (t),
TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
- loc.line = TINST_LINE (t);
- loc.file = TINST_FILE (t);
+ loc = TINST_LOCATION (t);
}
pp_verbatim (context->printer, "%s:%d: instantiated from here\n",
- loc.file, loc.line);
+ xloc.file, xloc.line);
}
/* Called from cp_thing to print the template context for an error. */
#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. */
plus = 0;
if (*f == '%')
{
- f++;
+ if (*++f == 'q')
+ ++f; /* ignore quoting flag. */
+
if (*f == '+')
- f++, plus = 1;
+ {
+ ++f;
+ plus = 1;
+ }
if (*f == '#')
f++;
default:
errorcount = 0; /* damn ICE suppression */
- internal_error ("unexpected letter `%c' in locate_error\n", *f);
+ internal_error ("unexpected letter %qc in locate_error\n", *f);
}
}
}
va_start (ap, msgid);
diagnostic_set_info (&diagnostic, msgid, &ap,
+ input_location, DK_ERROR);
+ cp_diagnostic_starter (global_dc, &diagnostic);
+ diagnostic_set_info (&diagnostic, msgid, &ap,
location_of (here), DK_ERROR);
report_diagnostic (&diagnostic);
va_end (ap);
OSDN Git Service
