/* Call-backs for C++ error reporting.
This code is non-reentrant.
- Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002
- Free Software Foundation, Inc.
- This file is part of GNU CC.
+ Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002,
+ 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ This file is part of GCC.
-GNU CC is free software; you can redistribute it and/or modify
+GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
+the Free Software Foundation; either version 3, or (at your option)
any later version.
-GNU CC is distributed in the hope that it will be useful,
+GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GNU CC; see the file COPYING. If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
#include "tree.h"
#include "cp-tree.h"
#include "real.h"
-#include "obstack.h"
#include "toplev.h"
#include "flags.h"
#include "diagnostic.h"
+#include "langhooks-def.h"
+#include "cxx-pretty-print.h"
-enum pad { none, before, after };
-
-#define sorry_for_unsupported_tree(T) \
- sorry ("`%s' not supported by %s", tree_code_name[(int) TREE_CODE (T)], \
- __FUNCTION__)
-
-#define print_scope_operator(BUFFER) output_add_string ((BUFFER), "::")
-#define print_left_paren(BUFFER) output_add_character ((BUFFER), '(')
-#define print_right_paren(BUFFER) output_add_character ((BUFFER), ')')
-#define print_left_bracket(BUFFER) output_add_character ((BUFFER), '[')
-#define print_right_bracket(BUFFER) output_add_character ((BUFFER), ']')
-#define print_template_argument_list_start(BUFFER) \
- print_non_consecutive_character ((BUFFER), '<')
-#define print_template_argument_list_end(BUFFER) \
- print_non_consecutive_character ((BUFFER), '>')
-#define print_whitespace(BUFFER, TFI) \
- do { \
- output_add_space (BUFFER); \
- put_whitespace (TFI) = none; \
- } while (0)
-#define print_tree_identifier(BUFFER, TID) \
- output_add_string ((BUFFER), IDENTIFIER_POINTER (TID))
-#define print_identifier(BUFFER, ID) output_add_string ((BUFFER), (ID))
-#define separate_with_comma(BUFFER) output_add_string ((BUFFER), ", ")
+#define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
/* The global buffer where we dump everything. It is there only for
transitional purpose. It is expected, in the near future, to be
completely removed. */
-static output_buffer scratch_buffer_rec;
-static output_buffer *scratch_buffer = &scratch_buffer_rec;
+static cxx_pretty_printer scratch_pretty_printer;
+#define cxx_pp (&scratch_pretty_printer)
# define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
-#define reinit_global_formatting_buffer() \
- output_clear_message_text (scratch_buffer)
-
-static const char *args_to_string PARAMS ((tree, int));
-static const char *assop_to_string PARAMS ((enum tree_code, int));
-static const char *code_to_string PARAMS ((enum tree_code, int));
-static const char *cv_to_string PARAMS ((tree, int));
-static const char *decl_to_string PARAMS ((tree, int));
-static const char *expr_to_string PARAMS ((tree, int));
-static const char *fndecl_to_string PARAMS ((tree, int));
-static const char *op_to_string PARAMS ((enum tree_code, int));
-static const char *parm_to_string PARAMS ((int, int));
-static const char *type_to_string PARAMS ((tree, int));
-
-static void dump_type PARAMS ((tree, int));
-static void dump_typename PARAMS ((tree, int));
-static void dump_simple_decl PARAMS ((tree, tree, int));
-static void dump_decl PARAMS ((tree, int));
-static void dump_template_decl PARAMS ((tree, int));
-static void dump_function_decl PARAMS ((tree, int));
-static void dump_expr PARAMS ((tree, int));
-static void dump_unary_op PARAMS ((const char *, tree, int));
-static void dump_binary_op PARAMS ((const char *, tree, int));
-static void dump_aggr_type PARAMS ((tree, int));
-static enum pad dump_type_prefix PARAMS ((tree, int));
-static void dump_type_suffix PARAMS ((tree, int));
-static void dump_function_name PARAMS ((tree, int));
-static void dump_expr_list PARAMS ((tree, int));
-static void dump_global_iord PARAMS ((tree));
-static enum pad dump_qualifiers PARAMS ((tree, enum pad));
-static void dump_char PARAMS ((int));
-static void dump_parameters PARAMS ((tree, int));
-static void dump_exception_spec PARAMS ((tree, int));
-static const char *class_key_or_enum PARAMS ((tree));
-static void dump_template_argument PARAMS ((tree, int));
-static void dump_template_argument_list PARAMS ((tree, int));
-static void dump_template_parameter PARAMS ((tree, int));
-static void dump_template_bindings PARAMS ((tree, tree));
-static void dump_scope PARAMS ((tree, int));
-static void dump_template_parms PARAMS ((tree, int, int));
-
-static const char *function_category PARAMS ((tree));
-static void lang_print_error_function PARAMS ((diagnostic_context *,
- const char *));
-static void maybe_print_instantiation_context PARAMS ((output_buffer *));
-static void print_instantiation_full_context PARAMS ((output_buffer *));
-static void print_instantiation_partial_context PARAMS ((output_buffer *, tree,
- const char *, int));
-static void cp_diagnostic_starter PARAMS ((output_buffer *,
- diagnostic_context *));
-static void cp_diagnostic_finalizer PARAMS ((output_buffer *,
- diagnostic_context *));
-static void cp_print_error_function PARAMS ((output_buffer *,
- diagnostic_context *));
-
-static int cp_printer PARAMS ((output_buffer *));
-static void print_non_consecutive_character PARAMS ((output_buffer *, int));
-static void print_integer PARAMS ((output_buffer *, HOST_WIDE_INT));
-static tree locate_error PARAMS ((const char *, va_list));
+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 const char *cv_to_string (tree, int);
+static const char *decl_to_string (tree, int);
+static const char *expr_to_string (tree);
+static const char *fndecl_to_string (tree, int);
+static const char *op_to_string (enum tree_code);
+static const char *parm_to_string (int);
+static const char *type_to_string (tree, int);
+
+static void dump_type (tree, int);
+static void dump_typename (tree, int);
+static void dump_simple_decl (tree, tree, int);
+static void dump_decl (tree, int);
+static void dump_template_decl (tree, int);
+static void dump_function_decl (tree, int);
+static void dump_expr (tree, int);
+static void dump_unary_op (const char *, tree, int);
+static void dump_binary_op (const char *, tree, int);
+static void dump_aggr_type (tree, int);
+static void dump_type_prefix (tree, int);
+static void dump_type_suffix (tree, int);
+static void dump_function_name (tree, int);
+static void dump_call_expr_args (tree, int, bool);
+static void dump_aggr_init_expr_args (tree, int, bool);
+static void dump_expr_list (tree, int);
+static void dump_global_iord (tree);
+static void dump_parameters (tree, int);
+static void dump_exception_spec (tree, int);
+static void dump_template_argument (tree, int);
+static void dump_template_argument_list (tree, int);
+static void dump_template_parameter (tree, int);
+static void dump_template_bindings (tree, tree);
+static void dump_scope (tree, int);
+static void dump_template_parms (tree, int, int);
+
+static const char *function_category (tree);
+static void maybe_print_instantiation_context (diagnostic_context *);
+static void print_instantiation_full_context (diagnostic_context *);
+static void print_instantiation_partial_context (diagnostic_context *,
+ struct tinst_level *,
+ location_t);
+static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
+static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
+static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
+
+static bool cp_printer (pretty_printer *, text_info *, const char *,
+ int, bool, bool, bool);
+static location_t location_of (tree);
void
-init_error ()
+init_error (void)
{
- print_error_function = lang_print_error_function;
diagnostic_starter (global_dc) = cp_diagnostic_starter;
diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer;
diagnostic_format_decoder (global_dc) = cp_printer;
- init_output_buffer (scratch_buffer, /* prefix */NULL, /* line-width */0);
+ pp_construct (pp_base (cxx_pp), NULL, 0);
+ pp_cxx_pretty_printer_init (cxx_pp);
}
/* Dump a scope, if deemed necessary. */
static void
-dump_scope (scope, flags)
- tree scope;
- int flags;
+dump_scope (tree scope, int flags)
{
int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF));
if (TREE_CODE (scope) == NAMESPACE_DECL)
{
if (scope != global_namespace)
- {
- dump_decl (scope, f);
- print_scope_operator (scratch_buffer);
- }
+ {
+ dump_decl (scope, f);
+ pp_cxx_colon_colon (cxx_pp);
+ }
}
else if (AGGREGATE_TYPE_P (scope))
{
dump_type (scope, f);
- print_scope_operator (scratch_buffer);
+ pp_cxx_colon_colon (cxx_pp);
}
else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
{
dump_function_decl (scope, f);
- print_scope_operator (scratch_buffer);
+ 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 (t, p)
- tree t;
- enum pad p;
-{
- static const int masks[] =
- {TYPE_QUAL_CONST, TYPE_QUAL_VOLATILE, TYPE_QUAL_RESTRICT};
- static const char *const names[] =
- {"const", "volatile", "__restrict"};
- int ix;
- int quals = TYPE_QUALS (t);
- int do_after = p == after;
-
- if (quals)
- {
- for (ix = 0; ix != 3; ix++)
- if (masks[ix] & quals)
- {
- if (p == before)
- output_add_space (scratch_buffer);
- p = before;
- print_identifier (scratch_buffer, names[ix]);
- }
- if (do_after)
- output_add_space (scratch_buffer);
- }
- else
- p = none;
- return p;
-}
-
-/* This must be large enough to hold any printed integer or floating-point
- value. */
-static char digit_buffer[128];
-
/* Dump the template ARGument under control of FLAGS. */
static void
-dump_template_argument (arg, flags)
- tree arg;
- int flags;
+dump_template_argument (tree arg, int flags)
{
- if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
+ if (ARGUMENT_PACK_P (arg))
+ dump_template_argument_list (ARGUMENT_PACK_ARGS (arg), flags);
+ else if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
else
- dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
+ {
+ if (TREE_CODE (arg) == TREE_LIST)
+ arg = TREE_VALUE (arg);
+
+ dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
+ }
}
/* Dump a template-argument-list ARGS (always a TREE_VEC) under control
of FLAGS. */
static void
-dump_template_argument_list (args, flags)
- tree args;
- int flags;
+dump_template_argument_list (tree args, int flags)
{
int n = TREE_VEC_LENGTH (args);
int need_comma = 0;
for (i = 0; i< n; ++i)
{
- if (need_comma)
- separate_with_comma (scratch_buffer);
- dump_template_argument (TREE_VEC_ELT (args, i), flags);
+ tree arg = TREE_VEC_ELT (args, i);
+
+ /* Only print a comma if we know there is an argument coming. In
+ the case of an empty template argument pack, no actual
+ argument will be printed. */
+ if (need_comma
+ && (!ARGUMENT_PACK_P (arg)
+ || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
+ pp_separate_with_comma (cxx_pp);
+
+ dump_template_argument (arg, flags);
need_comma = 1;
}
}
/* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
static void
-dump_template_parameter (parm, flags)
- tree parm;
- int flags;
+dump_template_parameter (tree parm, int flags)
{
- tree p = TREE_VALUE (parm);
- tree a = TREE_PURPOSE (parm);
+ tree p;
+ tree a;
+
+ if (parm == error_mark_node)
+ return;
+
+ p = TREE_VALUE (parm);
+ a = TREE_PURPOSE (parm);
if (TREE_CODE (p) == TYPE_DECL)
{
if (flags & TFF_DECL_SPECIFIERS)
- {
- print_identifier (scratch_buffer, "class");
- if (DECL_NAME (p))
- {
- output_add_space (scratch_buffer);
- print_tree_identifier (scratch_buffer, DECL_NAME (p));
- }
- }
+ {
+ pp_cxx_identifier (cxx_pp, "class");
+ if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p)))
+ pp_cxx_identifier (cxx_pp, "...");
+ if (DECL_NAME (p))
+ pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
+ }
else if (DECL_NAME (p))
- print_tree_identifier (scratch_buffer, DECL_NAME (p));
+ pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
else
- print_identifier (scratch_buffer, "{template default argument error}");
+ pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
}
else
dump_decl (p, flags | TFF_DECL_SPECIFIERS);
if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
{
- output_add_string (scratch_buffer, " = ");
+ pp_cxx_whitespace (cxx_pp);
+ pp_equal (cxx_pp);
+ pp_cxx_whitespace (cxx_pp);
if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
- dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
+ dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
else
- dump_expr (a, flags | TFF_EXPR_IN_PARENS);
+ dump_expr (a, flags | TFF_EXPR_IN_PARENS);
}
}
TREE_VEC. */
static void
-dump_template_bindings (parms, args)
- tree parms, args;
+dump_template_bindings (tree parms, tree args)
{
int need_comma = 0;
}
if (need_comma)
- separate_with_comma (scratch_buffer);
+ pp_separate_with_comma (cxx_pp);
dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
- output_add_string (scratch_buffer, " = ");
+ pp_cxx_whitespace (cxx_pp);
+ pp_equal (cxx_pp);
+ pp_cxx_whitespace (cxx_pp);
if (arg)
dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
else
- print_identifier (scratch_buffer, "<missing>");
+ pp_identifier (cxx_pp, "<missing>");
++arg_idx;
need_comma = 1;
}
}
-/* Dump into the obstack a human-readable equivalent of TYPE. FLAGS
- controls the format. */
+/* Dump a human-readable equivalent of TYPE. FLAGS controls the
+ format. */
static void
-dump_type (t, flags)
- tree t;
- int flags;
+dump_type (tree t, int flags)
{
if (t == NULL_TREE)
return;
switch (TREE_CODE (t))
{
case UNKNOWN_TYPE:
- print_identifier (scratch_buffer, "<unknown type>");
+ if (t == init_list_type_node)
+ pp_identifier (cxx_pp, "<brace-enclosed initializer list>");
+ else
+ pp_identifier (cxx_pp, "<unresolved overloaded function type>");
break;
case TREE_LIST:
break;
case IDENTIFIER_NODE:
- print_tree_identifier (scratch_buffer, t);
+ pp_cxx_tree_identifier (cxx_pp, t);
break;
- case TREE_VEC:
+ case TREE_BINFO:
dump_type (BINFO_TYPE (t), flags);
break;
case TYPE_DECL:
if (flags & TFF_CHASE_TYPEDEF)
- {
- dump_type (DECL_ORIGINAL_TYPE (t)
- ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
- break;
- }
- /* else fallthrough */
+ {
+ dump_type (DECL_ORIGINAL_TYPE (t)
+ ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
+ break;
+ }
+ /* Else fall through. */
case TEMPLATE_DECL:
case NAMESPACE_DECL:
dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
break;
- case COMPLEX_TYPE:
- output_add_string (scratch_buffer, "__complex__ ");
- dump_type (TREE_TYPE (t), flags);
- break;
-
- case VECTOR_TYPE:
- output_add_string (scratch_buffer, "vector ");
- {
- /* The subtype of a VECTOR_TYPE is something like intQI_type_node,
- which has no name and is not very useful for diagnostics. So
- look up the equivalent C type and print its name. */
- tree elt = TREE_TYPE (t);
- elt = type_for_mode (TYPE_MODE (elt), TREE_UNSIGNED (elt));
- dump_type (elt, flags);
- }
- break;
-
case INTEGER_TYPE:
- if (!TREE_UNSIGNED (TYPE_MAIN_VARIANT (t)) && TREE_UNSIGNED (t))
- output_add_string (scratch_buffer, "unsigned ");
- else if (TREE_UNSIGNED (TYPE_MAIN_VARIANT (t)) && !TREE_UNSIGNED (t))
- output_add_string (scratch_buffer, "signed ");
-
- /* fall through. */
case REAL_TYPE:
case VOID_TYPE:
case BOOLEAN_TYPE:
- {
- tree type;
- dump_qualifiers (t, after);
- type = flags & TFF_CHASE_TYPEDEF ? TYPE_MAIN_VARIANT (t) : t;
- if (TYPE_NAME (type) && TYPE_IDENTIFIER (type))
- print_tree_identifier (scratch_buffer, TYPE_IDENTIFIER (type));
- else
- /* Types like intQI_type_node and friends have no names.
- These don't come up in user error messages, but it's nice
- to be able to print them from the debugger. */
- print_identifier (scratch_buffer, "<anonymous>");
- }
+ case COMPLEX_TYPE:
+ case VECTOR_TYPE:
+ case FIXED_POINT_TYPE:
+ pp_type_specifier_seq (cxx_pp, t);
break;
case TEMPLATE_TEMPLATE_PARM:
- /* For parameters inside template signature. */
+ /* For parameters inside template signature. */
if (TYPE_IDENTIFIER (t))
- print_tree_identifier (scratch_buffer, TYPE_IDENTIFIER (t));
+ pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
else
- print_identifier
- (scratch_buffer, "<anonymous template template parameter>");
+ pp_cxx_canonical_template_parameter (cxx_pp, t);
break;
case BOUND_TEMPLATE_TEMPLATE_PARM:
{
tree args = TYPE_TI_ARGS (t);
- print_tree_identifier (scratch_buffer, TYPE_IDENTIFIER (t));
- print_template_argument_list_start (scratch_buffer);
- dump_template_argument_list (args, flags);
- print_template_argument_list_end (scratch_buffer);
+ pp_cxx_cv_qualifier_seq (cxx_pp, t);
+ pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
+ pp_cxx_begin_template_argument_list (cxx_pp);
+ dump_template_argument_list (args, flags);
+ pp_cxx_end_template_argument_list (cxx_pp);
}
break;
case TEMPLATE_TYPE_PARM:
- dump_qualifiers (t, after);
+ pp_cxx_cv_qualifier_seq (cxx_pp, t);
if (TYPE_IDENTIFIER (t))
- print_tree_identifier (scratch_buffer, TYPE_IDENTIFIER (t));
+ pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
else
- print_identifier
- (scratch_buffer, "<anonymous template type parameter>");
+ pp_cxx_canonical_template_parameter
+ (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
break;
/* This is not always necessary for pointers and such, but doing this
break;
}
case TYPENAME_TYPE:
- if (IMPLICIT_TYPENAME_P (t))
- output_add_string (scratch_buffer, "typename ");
+ pp_cxx_cv_qualifier_seq (cxx_pp, t);
+ pp_cxx_identifier (cxx_pp,
+ TYPENAME_IS_ENUM_P (t) ? "enum"
+ : TYPENAME_IS_CLASS_P (t) ? "class"
+ : "typename");
dump_typename (t, flags);
break;
case UNBOUND_CLASS_TEMPLATE:
dump_type (TYPE_CONTEXT (t), flags);
- print_scope_operator (scratch_buffer);
- print_identifier (scratch_buffer, "template ");
+ pp_cxx_colon_colon (cxx_pp);
+ pp_cxx_identifier (cxx_pp, "template");
dump_type (DECL_NAME (TYPE_NAME (t)), flags);
break;
case TYPEOF_TYPE:
- output_add_string (scratch_buffer, "__typeof (");
- dump_expr (TYPE_FIELDS (t), flags & ~TFF_EXPR_IN_PARENS);
- print_right_paren (scratch_buffer);
+ pp_cxx_identifier (cxx_pp, "__typeof__");
+ pp_cxx_whitespace (cxx_pp);
+ pp_cxx_left_paren (cxx_pp);
+ dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
+ pp_cxx_right_paren (cxx_pp);
+ break;
+
+ case TYPE_PACK_EXPANSION:
+ dump_type (PACK_EXPANSION_PATTERN (t), flags);
+ pp_cxx_identifier (cxx_pp, "...");
+ break;
+
+ case TYPE_ARGUMENT_PACK:
+ dump_template_argument (t, flags);
+ break;
+
+ case DECLTYPE_TYPE:
+ pp_cxx_identifier (cxx_pp, "decltype");
+ pp_cxx_whitespace (cxx_pp);
+ pp_cxx_left_paren (cxx_pp);
+ dump_expr (DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
+ pp_cxx_right_paren (cxx_pp);
break;
default:
- sorry_for_unsupported_tree (t);
- /* Fall through to error. */
+ pp_unsupported_tree (cxx_pp, t);
+ /* Fall through to error. */
case ERROR_MARK:
- print_identifier (scratch_buffer, "<type error>");
+ pp_identifier (cxx_pp, "<type error>");
break;
}
}
a TYPENAME_TYPE. */
static void
-dump_typename (t, flags)
- tree t;
- int flags;
+dump_typename (tree t, int flags)
{
tree ctx = TYPE_CONTEXT (t);
dump_typename (ctx, flags);
else
dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
- print_scope_operator (scratch_buffer);
+ pp_cxx_colon_colon (cxx_pp);
dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
}
/* Return the name of the supplied aggregate, or enumeral type. */
-static const char *
-class_key_or_enum (t)
- tree t;
+const char *
+class_key_or_enum_as_string (tree t)
{
- if (TREE_CODE (t) == ENUMERAL_TYPE)
- return "enum";
+ if (TREE_CODE (t) == ENUMERAL_TYPE)
+ {
+ if (SCOPED_ENUM_P (t))
+ return "enum class";
+ else
+ return "enum";
+ }
else if (TREE_CODE (t) == UNION_TYPE)
return "union";
else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
in the form `class foo'. */
static void
-dump_aggr_type (t, flags)
- tree t;
- int flags;
+dump_aggr_type (tree t, int flags)
{
tree name;
- const char *variety = class_key_or_enum (t);
+ const char *variety = class_key_or_enum_as_string (t);
int typdef = 0;
int tmplate = 0;
- dump_qualifiers (t, after);
+ pp_cxx_cv_qualifier_seq (cxx_pp, t);
if (flags & TFF_CLASS_KEY_OR_ENUM)
- {
- print_identifier (scratch_buffer, variety);
- output_add_space (scratch_buffer);
- }
+ pp_cxx_identifier (cxx_pp, variety);
if (flags & TFF_CHASE_TYPEDEF)
t = TYPE_MAIN_VARIANT (t);
{
typdef = !DECL_ARTIFICIAL (name);
tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
- && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
- && (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
- || TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
- || DECL_TEMPLATE_SPECIALIZATION (CLASSTYPE_TI_TEMPLATE (t))
- || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
- dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
+ && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
+ && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
+ || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
+
+ if (! (flags & TFF_UNQUALIFIED_NAME))
+ dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
+ flags &= ~TFF_UNQUALIFIED_NAME;
if (tmplate)
- {
- /* Because the template names are mangled, we have to locate
- the most general template, and use that name. */
- tree tpl = CLASSTYPE_TI_TEMPLATE (t);
-
- while (DECL_TEMPLATE_INFO (tpl))
- tpl = DECL_TI_TEMPLATE (tpl);
- name = tpl;
- }
+ {
+ /* Because the template names are mangled, we have to locate
+ the most general template, and use that name. */
+ tree tpl = CLASSTYPE_TI_TEMPLATE (t);
+
+ while (DECL_TEMPLATE_INFO (tpl))
+ tpl = DECL_TI_TEMPLATE (tpl);
+ name = tpl;
+ }
name = DECL_NAME (name);
}
if (name == 0 || ANON_AGGRNAME_P (name))
{
if (flags & TFF_CLASS_KEY_OR_ENUM)
-
print_identifier (scratch_buffer, "<anonymous>");
+
pp_identifier (cxx_pp, "<anonymous>");
else
-
output_printf (scratch_buffer, "<anonymous %s>", variety);
+
pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety);
}
else
- print_tree_identifier (scratch_buffer, name);
+ pp_cxx_tree_identifier (cxx_pp, name);
if (tmplate)
dump_template_parms (TYPE_TEMPLATE_INFO (t),
- !CLASSTYPE_USE_TEMPLATE (t),
- flags & ~TFF_TEMPLATE_HEADER);
+ !CLASSTYPE_USE_TEMPLATE (t),
+ flags & ~TFF_TEMPLATE_HEADER);
}
/* Dump into the obstack the initial part of the output for a given type.
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
-dump_type_prefix (t, flags)
- tree t;
- int flags;
+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);
- /* A tree for a member pointer looks like pointer to offset,
- so let the OFFSET_TYPE case handle it. */
- if (!TYPE_PTRMEM_P (t))
+ dump_type_prefix (sub, flags);
+ if (TREE_CODE (sub) == ARRAY_TYPE
+ || TREE_CODE (sub) == FUNCTION_TYPE)
{
- if (TREE_CODE (sub) == ARRAY_TYPE)
- {
- output_add_space (scratch_buffer);
- print_left_paren (scratch_buffer);
- }
- output_add_character
- (scratch_buffer, "&*"[TREE_CODE (t) == POINTER_TYPE]);
- padding = dump_qualifiers (t, before);
+ pp_cxx_whitespace (cxx_pp);
+ pp_cxx_left_paren (cxx_pp);
}
+ if (TREE_CODE (t) == POINTER_TYPE)
+ pp_character(cxx_pp, '*');
+ else if (TREE_CODE (t) == REFERENCE_TYPE)
+ {
+ if (TYPE_REF_IS_RVALUE (t))
+ pp_string (cxx_pp, "&&");
+ else
+ pp_character (cxx_pp, '&');
+ }
+ pp_base (cxx_pp)->padding = pp_before;
+ pp_cxx_cv_qualifier_seq (cxx_pp, t);
}
break;
case OFFSET_TYPE:
offset_type:
- padding = dump_type_prefix (TREE_TYPE (t), flags);
+ dump_type_prefix (TREE_TYPE (t), flags);
if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
{
- if (padding != none)
- output_add_space (scratch_buffer);
+ pp_maybe_space (cxx_pp);
+ if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
+ pp_cxx_left_paren (cxx_pp);
dump_type (TYPE_OFFSET_BASETYPE (t), flags);
- print_scope_operator (scratch_buffer);
+ pp_cxx_colon_colon (cxx_pp);
}
- output_add_character (scratch_buffer, '*');
- padding = dump_qualifiers (t, none);
+ pp_cxx_star (cxx_pp);
+ pp_cxx_cv_qualifier_seq (cxx_pp, t);
+ pp_base (cxx_pp)->padding = pp_before;
break;
- /* Can only be reached through function pointer -- this would not be
- correct if FUNCTION_DECLs used it. */
+ /* This can be reached without a pointer when dealing with
+ templates, e.g. std::is_function. */
case FUNCTION_TYPE:
- padding = dump_type_prefix (TREE_TYPE (t), flags);
- if (padding != none)
- output_add_space (scratch_buffer);
- print_left_paren (scratch_buffer);
- padding = none;
+ dump_type_prefix (TREE_TYPE (t), flags);
break;
case METHOD_TYPE:
- padding = dump_type_prefix (TREE_TYPE (t), flags);
- if (padding != none)
- output_add_space (scratch_buffer);
- print_left_paren (scratch_buffer);
- padding = none;
+ dump_type_prefix (TREE_TYPE (t), flags);
+ pp_maybe_space (cxx_pp);
+ pp_cxx_left_paren (cxx_pp);
dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
- print_scope_operator (scratch_buffer);
+ pp_cxx_colon_colon (cxx_pp);
break;
case ARRAY_TYPE:
- padding = dump_type_prefix (TREE_TYPE (t), flags);
+ dump_type_prefix (TREE_TYPE (t), flags);
break;
case ENUMERAL_TYPE:
case COMPLEX_TYPE:
case VECTOR_TYPE:
case TYPEOF_TYPE:
+ case DECLTYPE_TYPE:
+ case TYPE_PACK_EXPANSION:
+ case FIXED_POINT_TYPE:
dump_type (t, flags);
- padding = before;
+ pp_base (cxx_pp)->padding = pp_before;
break;
default:
- sorry_for_unsupported_tree (t);
+ pp_unsupported_tree (cxx_pp, t);
/* fall through. */
case ERROR_MARK:
- print_identifier (scratch_buffer, "<typeprefixerror>");
+ pp_identifier (cxx_pp, "<typeprefixerror>");
break;
}
- return padding;
}
/* Dump the suffix of type T, under control of FLAGS. This is the part
which appears after the identifier (or function parms). */
static void
-dump_type_suffix (t, flags)
- tree t;
- int flags;
+dump_type_suffix (tree t, int flags)
{
if (TYPE_PTRMEMFUNC_P (t))
t = TYPE_PTRMEMFUNC_FN_TYPE (t);
case POINTER_TYPE:
case REFERENCE_TYPE:
case OFFSET_TYPE:
- if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
- print_right_paren (scratch_buffer);
+ if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
+ || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
+ pp_cxx_right_paren (cxx_pp);
dump_type_suffix (TREE_TYPE (t), flags);
break;
- /* Can only be reached through function pointer */
case FUNCTION_TYPE:
case METHOD_TYPE:
{
tree arg;
- print_right_paren (scratch_buffer);
+ if (TREE_CODE (t) == METHOD_TYPE)
+ /* Can only be reached through a pointer. */
+ 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:
- print_left_bracket (scratch_buffer);
+ pp_maybe_space (cxx_pp);
+ pp_cxx_left_bracket (cxx_pp);
if (TYPE_DOMAIN (t))
{
- if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0))
- print_integer
- (scratch_buffer,
- tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1);
- else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR)
- dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0),
- flags & ~TFF_EXPR_IN_PARENS);
+ tree dtype = TYPE_DOMAIN (t);
+ tree max = TYPE_MAX_VALUE (dtype);
+ if (host_integerp (max, 0))
+ pp_wide_integer (cxx_pp, tree_low_cst (max, 0) + 1);
+ else if (TREE_CODE (max) == MINUS_EXPR)
+ dump_expr (TREE_OPERAND (max, 0),
+ flags & ~TFF_EXPR_IN_PARENS);
else
- dump_expr (fold (cp_build_binary_op
- (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)),
- integer_one_node)),
- flags & ~TFF_EXPR_IN_PARENS);
+ dump_expr (fold_build2 (PLUS_EXPR, dtype, max,
+ build_int_cst (dtype, 1)),
+ flags & ~TFF_EXPR_IN_PARENS);
}
- print_right_bracket (scratch_buffer);
+ pp_cxx_right_bracket (cxx_pp);
dump_type_suffix (TREE_TYPE (t), flags);
break;
case COMPLEX_TYPE:
case VECTOR_TYPE:
case TYPEOF_TYPE:
+ case DECLTYPE_TYPE:
+ case TYPE_PACK_EXPANSION:
+ case FIXED_POINT_TYPE:
break;
default:
- sorry_for_unsupported_tree (t);
+ pp_unsupported_tree (cxx_pp, t);
case ERROR_MARK:
/* Don't mark it here, we should have already done in
- dump_type_prefix. */
+ dump_type_prefix. */
break;
}
}
static void
-dump_global_iord (t)
- tree t;
+dump_global_iord (tree t)
{
const char *p = NULL;
else if (DECL_GLOBAL_DTOR_P (t))
p = "destructors";
else
- abort ();
+ gcc_unreachable ();
- output_printf (scratch_buffer, "(static %s for %s)", p, input_filename);
+ pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename);
}
static void
-dump_simple_decl (t, type, flags)
- tree t;
- tree type;
- int flags;
+dump_simple_decl (tree t, tree type, int flags)
{
if (flags & TFF_DECL_SPECIFIERS)
{
- if (dump_type_prefix (type, flags) != none)
- output_add_space (scratch_buffer);
+ dump_type_prefix (type, flags & ~TFF_UNQUALIFIED_NAME);
+ pp_maybe_space (cxx_pp);
}
- if (!DECL_INITIAL (t) || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX)
+ if (! (flags & TFF_UNQUALIFIED_NAME)
+ && (!DECL_INITIAL (t)
+ || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
dump_scope (CP_DECL_CONTEXT (t), flags);
+ flags &= ~TFF_UNQUALIFIED_NAME;
+ if ((flags & TFF_DECL_SPECIFIERS)
+ && DECL_TEMPLATE_PARM_P (t)
+ && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t)))
+ pp_identifier (cxx_pp, "...");
if (DECL_NAME (t))
dump_decl (DECL_NAME (t), flags);
else
- p
rint_identifier (scratch_buffer, "<anonymous>");
+ p
p_identifier (cxx_pp, "<anonymous>");
if (flags & TFF_DECL_SPECIFIERS)
dump_type_suffix (type, flags);
}
/* Dump a human readable string for the decl T under control of FLAGS. */
static void
-dump_decl (t, flags)
- tree t;
- int flags;
+dump_decl (tree t, int flags)
{
if (t == NULL_TREE)
return;
switch (TREE_CODE (t))
{
case TYPE_DECL:
- {
- /* Don't say 'typedef class A' */
- if (DECL_ARTIFICIAL (t))
- {
- if ((flags & TFF_DECL_SPECIFIERS)
- && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
- /* Say `class T' not just `T'. */
- output_add_string (scratch_buffer, "class ");
+ /* Don't say 'typedef class A' */
+ if (DECL_ARTIFICIAL (t))
+ {
+ if ((flags & TFF_DECL_SPECIFIERS)
+ && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
+ {
+ /* Say `class T' not just `T'. */
+ pp_cxx_identifier (cxx_pp, "class");
- dump_type (TREE_TYPE (t), flags);
- break;
- }
- }
+ /* Emit the `...' for a parameter pack. */
+ if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
+ pp_cxx_identifier (cxx_pp, "...");
+ }
+
+ dump_type (TREE_TYPE (t), flags);
+ break;
+ }
if (flags & TFF_DECL_SPECIFIERS)
- output_add_string (scratch_buffer, "typedef ");
+ pp_cxx_identifier (cxx_pp, "typedef");
dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
- flags);
+ flags);
break;
case VAR_DECL:
if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
{
- output_add_string (scratch_buffer, "vtable for ");
- my_friendly_assert (TYPE_P (DECL_CONTEXT (t)), 20010720);
+ pp_string (cxx_pp, "vtable for ");
+ gcc_assert (TYPE_P (DECL_CONTEXT (t)));
dump_type (DECL_CONTEXT (t), flags);
break;
}
- /* else fall through */
+ /* Else fall through. */
case FIELD_DECL:
case PARM_DECL:
dump_simple_decl (t, TREE_TYPE (t), flags);
break;
case RESULT_DECL:
- output_add_string (scratch_buffer, "<return value> ");
+ pp_string (cxx_pp, "<return value> ");
dump_simple_decl (t, TREE_TYPE (t), flags);
break;
case NAMESPACE_DECL:
- dump_scope (CP_DECL_CONTEXT (t), flags);
- if (DECL_NAME (t) == anonymous_namespace_name)
- print_identifier (scratch_buffer, "<unnamed>");
+ if (flags & TFF_DECL_SPECIFIERS)
+ pp_cxx_declaration (cxx_pp, t);
else
- print_tree_identifier (scratch_buffer, DECL_NAME (t));
+ {
+ if (! (flags & TFF_UNQUALIFIED_NAME))
+ dump_scope (CP_DECL_CONTEXT (t), flags);
+ flags &= ~TFF_UNQUALIFIED_NAME;
+ if (DECL_NAME (t) == NULL_TREE)
+ pp_identifier (cxx_pp, "<unnamed>");
+ else
+ pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
+ }
break;
case SCOPE_REF:
- dump_decl (TREE_OPERAND (t, 0), flags & ~TFF_DECL_SPECIFIERS);
- print_scope_operator (scratch_buffer);
- dump_decl (TREE_OPERAND (t, 1), flags);
+ pp_expression (cxx_pp, t);
break;
case ARRAY_REF:
dump_decl (TREE_OPERAND (t, 0), flags);
- print_left_bracket (scratch_buffer);
+ pp_cxx_left_bracket (cxx_pp);
dump_decl (TREE_OPERAND (t, 1), flags);
- print_right_bracket (scratch_buffer);
+ pp_cxx_right_bracket (cxx_pp);
break;
/* So that we can do dump_decl on an aggr type. */
dump_type (t, flags);
break;
+ 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;
+
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))
{
- output_add_string (scratch_buffer, "operator ");
+ pp_cxx_identifier (cxx_pp, "operator");
/* Not exactly IDENTIFIER_TYPE_VALUE. */
dump_type (TREE_TYPE (t), flags);
break;
}
else
- print_tree_identifier (scratch_buffer, t);
+ pp_cxx_tree_identifier (cxx_pp, t);
break;
case OVERLOAD:
if (DECL_CLASS_SCOPE_P (t))
{
dump_type (DECL_CONTEXT (t), flags);
- output_add_string (scratch_buffer, "::");
+ pp_cxx_colon_colon (cxx_pp);
}
else if (DECL_CONTEXT (t))
{
dump_decl (DECL_CONTEXT (t), flags);
- output_add_string (scratch_buffer, "::");
+ pp_cxx_colon_colon (cxx_pp);
}
dump_decl (DECL_NAME (t), flags);
break;
}
-
+
/* If there's only one function, just treat it like an ordinary
FUNCTION_DECL. */
t = OVL_CURRENT (t);
/* Fall through. */
case FUNCTION_DECL:
- if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
+ if (! DECL_LANG_SPECIFIC (t))
+ pp_identifier (cxx_pp, "<built-in>");
+ else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
dump_global_iord (t);
- else if (! DECL_LANG_SPECIFIC (t))
- print_identifier (scratch_buffer, "<internal>");
else
- dump_function_decl (t, flags);
+ dump_function_decl (t, flags);
break;
case TEMPLATE_DECL:
case TEMPLATE_ID_EXPR:
{
- tree args;
tree name = TREE_OPERAND (t, 0);
+
if (is_overloaded_fn (name))
name = DECL_NAME (get_first_fn (name));
dump_decl (name, flags);
- print_template_argument_list_start (scratch_buffer);
- for (args = TREE_OPERAND (t, 1); args; args = TREE_CHAIN (args))
- {
- dump_template_argument (TREE_VALUE (args), flags);
- if (TREE_CHAIN (args))
- separate_with_comma (scratch_buffer);
- }
- print_template_argument_list_end (scratch_buffer);
+ pp_cxx_begin_template_argument_list (cxx_pp);
+ if (TREE_OPERAND (t, 1))
+ dump_template_argument_list (TREE_OPERAND (t, 1), flags);
+ pp_cxx_end_template_argument_list (cxx_pp);
}
break;
- case LOOKUP_EXPR:
- dump_decl (TREE_OPERAND (t, 0), flags);
- break;
-
case LABEL_DECL:
- print_tree_identifier (scratch_buffer, DECL_NAME (t));
+ pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
break;
case CONST_DECL:
else if (DECL_INITIAL (t))
dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
else
- print_identifier (scratch_buffer, "enumerator");
+ pp_identifier (cxx_pp, "<enumerator>");
break;
case USING_DECL:
- output_add_string (scratch_buffer, "using ");
- dump_type (DECL_INITIAL (t), flags);
- print_scope_operator (scratch_buffer);
- print_tree_identifier (scratch_buffer, DECL_NAME (t));
+ pp_cxx_identifier (cxx_pp, "using");
+ dump_type (USING_DECL_SCOPE (t), flags);
+ pp_cxx_colon_colon (cxx_pp);
+ dump_decl (DECL_NAME (t), flags);
+ break;
+
+ case STATIC_ASSERT:
+ pp_cxx_declaration (cxx_pp, t);
+ break;
+
+ case BASELINK:
+ dump_decl (BASELINK_FUNCTIONS (t), flags);
+ break;
+
+ case NON_DEPENDENT_EXPR:
+ dump_expr (t, flags);
+ break;
+
+ case TEMPLATE_TYPE_PARM:
+ if (flags & TFF_DECL_SPECIFIERS)
+ pp_cxx_declaration (cxx_pp, t);
+ else
+ pp_type_id (cxx_pp, t);
+ break;
+
+ case UNBOUND_CLASS_TEMPLATE:
+ case TYPE_PACK_EXPANSION:
+ case TREE_BINFO:
+ dump_type (t, flags);
break;
default:
- sorry_for_unsupported_tree (t);
- /* Fallthrough to error. */
+ pp_unsupported_tree (cxx_pp, t);
+ /* Fall through to error. */
case ERROR_MARK:
- print_identifier (scratch_buffer, "<declaration error>");
+ pp_identifier (cxx_pp, "<declaration error>");
break;
}
}
'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
static void
-dump_template_decl (t, flags)
- tree t;
- int flags;
+dump_template_decl (tree t, int flags)
{
tree orig_parms = DECL_TEMPLATE_PARMS (t);
tree parms;
if (flags & TFF_TEMPLATE_HEADER)
{
for (parms = orig_parms = nreverse (orig_parms);
- parms;
- parms = TREE_CHAIN (parms))
- {
+ parms;
+ parms = TREE_CHAIN (parms))
+ {
tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
- int len = TREE_VEC_LENGTH (inner_parms);
+ int len = TREE_VEC_LENGTH (inner_parms);
- output_add_string (scratch_buffer, "template<");
+ pp_cxx_identifier (cxx_pp, "template");
+ pp_cxx_begin_template_argument_list (cxx_pp);
/* If we've shown the template prefix, we'd better show the
parameters' and decl's type too. */
flags |= TFF_DECL_SPECIFIERS;
- for (i = 0; i < len; i++)
- {
- if (i)
- separate_with_comma (scratch_buffer);
- dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
- }
- print_template_argument_list_end (scratch_buffer);
- output_add_space (scratch_buffer);
- }
+ for (i = 0; i < len; i++)
+ {
+ if (i)
+ pp_separate_with_comma (cxx_pp);
+ dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
+ }
+ pp_cxx_end_template_argument_list (cxx_pp);
+ pp_cxx_whitespace (cxx_pp);
+ }
nreverse(orig_parms);
if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
- /* Say `template<arg> class TT' not just `template<arg> TT'. */
- output_add_string (scratch_buffer, "class ");
+ {
+ /* Say `template<arg> class TT' not just `template<arg> TT'. */
+ pp_cxx_identifier (cxx_pp, "class");
+
+ /* If this is a parameter pack, print the ellipsis. */
+ if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
+ pp_cxx_identifier (cxx_pp, "...");
+ }
}
- if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
+ if (DECL_TEMPLATE_RESULT (t)
+ && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
dump_type (TREE_TYPE (t),
- ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
- | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
- else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
+ ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
+ | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
+ else if (DECL_TEMPLATE_RESULT (t)
+ && 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 illegal 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));
+ }
}
}
/* Pretty print a function decl. There are several ways we want to print a
function declaration. The TFF_ bits in FLAGS tells us how to behave.
As error can only apply the '#' flag once to give 0 and 1 for V, there
- is %D which doesn't print the throw specs, and %F which does. */
+ is %D which doesn't print the throw specs, and %F which does. */
static void
-dump_function_decl (t, flags)
- tree t;
- int flags;
+dump_function_decl (tree t, int flags)
{
tree fntype;
tree parmtypes;
tree template_args = NULL_TREE;
tree template_parms = NULL_TREE;
int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
+ int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
+ tree exceptions;
+ flags &= ~TFF_UNQUALIFIED_NAME;
if (TREE_CODE (t) == TEMPLATE_DECL)
t = DECL_TEMPLATE_RESULT (t);
+ /* Save the exceptions, in case t is a specialization and we are
+ emitting an error about incompatible specifications. */
+ exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
+
/* Pretty print template instantiations only. */
if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t))
{
if (DECL_CLASS_SCOPE_P (t))
cname = DECL_CONTEXT (t);
- /* this is for partially instantiated template methods */
+ /* This is for partially instantiated template methods. */
else if (TREE_CODE (fntype) == METHOD_TYPE)
cname = TREE_TYPE (TREE_VALUE (parmtypes));
if (!(flags & TFF_DECL_SPECIFIERS))
/* OK */;
else if (DECL_STATIC_FUNCTION_P (t))
- print_identifier (scratch_buffer, "static ");
+ pp_cxx_identifier (cxx_pp, "static");
else if (DECL_VIRTUAL_P (t))
- print_identifier (scratch_buffer, "virtual ");
+ pp_cxx_identifier (cxx_pp, "virtual");
/* Print the return type? */
if (show_return)
show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
- && !DECL_DESTRUCTOR_P (t);
+ && !DECL_DESTRUCTOR_P (t);
if (show_return)
- {
- dump_type_prefix (TREE_TYPE (fntype), flags);
- output_add_space (scratch_buffer);
- }
+ dump_type_prefix (TREE_TYPE (fntype), flags);
/* Print the function name. */
- if (cname)
+ if (!do_outer_scope)
+ /* Nothing. */;
+ else if (cname)
{
dump_type (cname, flags);
- print_scope_operator (scratch_buffer);
+ pp_cxx_colon_colon (cxx_pp);
}
else
dump_scope (CP_DECL_CONTEXT (t), flags);
dump_function_name (t, flags);
- if (1)
+ if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
{
dump_parameters (parmtypes, flags);
if (TREE_CODE (fntype) == METHOD_TYPE)
- dump_qualifiers (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))),
- before);
+ {
+ pp_base (cxx_pp)->padding = pp_before;
+ pp_cxx_cv_qualifier_seq
+ (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
+ }
if (flags & TFF_EXCEPTION_SPECIFICATION)
- dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
+ {
+ pp_base (cxx_pp)->padding = pp_before;
+ dump_exception_spec (exceptions, 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)
{
- output_add_string (scratch_buffer, " [with ");
+ pp_cxx_whitespace (cxx_pp);
+ pp_cxx_left_bracket (cxx_pp);
+ pp_cxx_identifier (cxx_pp, "with");
+ pp_cxx_whitespace (cxx_pp);
dump_template_bindings (template_parms, template_args);
- print_right_bracket (scratch_buffer);
+ pp_cxx_right_bracket (cxx_pp);
}
}
/* Print a parameter list. If this is for a member function, the
member object ptr (and any other hidden args) should have
- already been removed. */
+ already been removed. */
static void
-dump_parameters (parmtypes, flags)
- tree parmtypes;
- int flags;
+dump_parameters (tree parmtypes, int flags)
{
- int first;
-
- print_left_paren (scratch_buffer);
+ int first = 1;
+ pp_cxx_left_paren (cxx_pp);
for (first = 1; parmtypes != void_list_node;
parmtypes = TREE_CHAIN (parmtypes))
{
if (!first)
- separate_with_comma (scratch_buffer);
+ pp_separate_with_comma (cxx_pp);
first = 0;
if (!parmtypes)
- {
- print_identifier (scratch_buffer, "...");
- break;
- }
+ {
+ pp_cxx_identifier (cxx_pp, "...");
+ break;
+ }
+
dump_type (TREE_VALUE (parmtypes), flags);
if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
- {
- output_add_string (scratch_buffer, " = ");
- dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
- }
+ {
+ pp_cxx_whitespace (cxx_pp);
+ pp_equal (cxx_pp);
+ pp_cxx_whitespace (cxx_pp);
+ dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
+ }
}
- print_right_paren (scratch_buffer);
+ pp_cxx_right_paren (cxx_pp);
}
-/* Print an exception specification. T is the exception specification. */
+/* Print an exception specification. T is the exception specification. */
static void
-dump_exception_spec (t, flags)
- tree t;
- int flags;
+dump_exception_spec (tree t, int flags)
{
if (t)
{
- output_add_string (scratch_buffer, " throw (");
+ pp_cxx_identifier (cxx_pp, "throw");
+ pp_cxx_whitespace (cxx_pp);
+ pp_cxx_left_paren (cxx_pp);
if (TREE_VALUE (t) != NULL_TREE)
- while (1)
- {
- dump_type (TREE_VALUE (t), flags);
- t = TREE_CHAIN (t);
- if (!t)
- break;
- separate_with_comma (scratch_buffer);
- }
- print_right_paren (scratch_buffer);
+ while (1)
+ {
+ dump_type (TREE_VALUE (t), flags);
+ t = TREE_CHAIN (t);
+ if (!t)
+ break;
+ pp_separate_with_comma (cxx_pp);
+ }
+ pp_cxx_right_paren (cxx_pp);
}
}
and destructors properly. */
static void
-dump_function_name (t, flags)
- tree t;
- int flags;
+dump_function_name (tree t, int flags)
{
tree name = DECL_NAME (t);
+ /* We can get here with a decl that was synthesized by language-
+ independent machinery (e.g. coverage.c) in which case it won't
+ have a lang_specific structure attached and DECL_CONSTRUCTOR_P
+ will crash. In this case it is safe just to print out the
+ literal name. */
+ if (!DECL_LANG_SPECIFIC (t))
+ {
+ pp_cxx_tree_identifier (cxx_pp, name);
+ return;
+ }
+
+ if (TREE_CODE (t) == TEMPLATE_DECL)
+ t = DECL_TEMPLATE_RESULT (t);
+
/* Don't let the user see __comp_ctor et al. */
if (DECL_CONSTRUCTOR_P (t)
|| DECL_DESTRUCTOR_P (t))
if (DECL_DESTRUCTOR_P (t))
{
- output_add_character (scratch_buffer, '~');
+ pp_cxx_complement (cxx_pp);
dump_decl (name, TFF_PLAIN_IDENTIFIER);
}
else if (DECL_CONV_FN_P (t))
declarations, both will have the same name, yet
the types will be different, hence the TREE_TYPE field
of the first name will be clobbered by the second. */
- output_add_string (scratch_buffer, "operator ");
+ pp_cxx_identifier (cxx_pp, "operator");
dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
}
else if (IDENTIFIER_OPNAME_P (name))
- print_tree_identifier (scratch_buffer, name);
+ pp_cxx_tree_identifier (cxx_pp, name);
else
dump_decl (name, flags);
- if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
+ if (DECL_TEMPLATE_INFO (t)
&& !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
- && (DECL_TEMPLATE_SPECIALIZATION (t)
- || TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
- || DECL_TEMPLATE_SPECIALIZATION (DECL_TI_TEMPLATE (t))
+ && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
|| PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
}
decoration. */
static void
-dump_template_parms (info, primary, flags)
- tree info;
- int primary;
- int flags;
+dump_template_parms (tree info, int primary, int flags)
{
tree args = info ? TI_ARGS (info) : NULL_TREE;
if (primary && flags & TFF_TEMPLATE_NAME)
return;
flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
- print_template_argument_list_start (scratch_buffer);
+ pp_cxx_begin_template_argument_list (cxx_pp);
/* Be careful only to print things when we have them, so as not
to crash producing error messages. */
if (args && !primary)
{
- int len = 0;
- int ix = 0;
- int need_comma = 0;
+ int len, ix;
- if (TREE_CODE (args) == TREE_VEC)
- {
- if (TREE_VEC_LENGTH (args) > 0
- && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
- args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
+ if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
+ args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
- len = TREE_VEC_LENGTH (args);
- }
- else if (TREE_CODE (args) == TREE_LIST)
- len = -1;
- while (ix != len && args)
- {
- tree arg;
- if (len >= 0)
- {
- arg = TREE_VEC_ELT (args, ix);
- ix++;
- }
- else
- {
- arg = TREE_VALUE (args);
- args = TREE_CHAIN (args);
- }
- if (need_comma)
- separate_with_comma (scratch_buffer);
+ len = TREE_VEC_LENGTH (args);
+
+ for (ix = 0; ix != len; ix++)
+ {
+ tree arg = TREE_VEC_ELT (args, ix);
+
+ /* Only print a comma if we know there is an argument coming. In
+ the case of an empty template argument pack, no actual
+ argument will be printed. */
+ if (ix
+ && (!ARGUMENT_PACK_P (arg)
+ || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
+ pp_separate_with_comma (cxx_pp);
if (!arg)
- print_identifier (scratch_buffer, "<template parameter error>");
+ pp_identifier (cxx_pp, "<template parameter error>");
else
dump_template_argument (arg, flags);
- need_comma = 1;
}
}
else if (primary)
len = parms ? TREE_VEC_LENGTH (parms) : 0;
for (ix = 0; ix != len; ix++)
- {
- tree parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
+ {
+ tree parm;
+
+ if (TREE_VEC_ELT (parms, ix) == error_mark_node)
+ {
+ pp_identifier (cxx_pp, "<template parameter error>");
+ continue;
+ }
- if (ix)
- separate_with_comma (scratch_buffer);
+ parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
- dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
- }
+ if (ix)
+ pp_separate_with_comma (cxx_pp);
+
+ dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
+ }
}
- print_template_argument_list_end (scratch_buffer);
+ pp_cxx_end_template_argument_list (cxx_pp);
}
+/* Print out the arguments of CALL_EXPR T as a parenthesized list using
+ flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
+
static void
-dump_char (c)
- int c;
+dump_call_expr_args (tree t, int flags, bool skipfirst)
{
- switch (c)
+ tree arg;
+ call_expr_arg_iterator iter;
+
+ pp_cxx_left_paren (cxx_pp);
+ FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
{
- case TARGET_NEWLINE:
- output_add_string (scratch_buffer, "\\n");
- break;
- case TARGET_TAB:
- output_add_string (scratch_buffer, "\\t");
- break;
- case TARGET_VT:
- output_add_string (scratch_buffer, "\\v");
- break;
- case TARGET_BS:
- output_add_string (scratch_buffer, "\\b");
- break;
- case TARGET_CR:
- output_add_string (scratch_buffer, "\\r");
- break;
- case TARGET_FF:
- output_add_string (scratch_buffer, "\\f");
- break;
- case TARGET_BELL:
- output_add_string (scratch_buffer, "\\a");
- break;
- case '\\':
- output_add_string (scratch_buffer, "\\\\");
- break;
- case '\'':
- output_add_string (scratch_buffer, "\\'");
- break;
- case '\"':
- output_add_string (scratch_buffer, "\\\"");
- break;
- default:
- if (ISPRINT (c))
- output_add_character (scratch_buffer, c);
+ if (skipfirst)
+ skipfirst = false;
else
{
- sprintf (digit_buffer, "\\%03o", (int) c);
- output_add_string (scratch_buffer, digit_buffer);
+ dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
+ if (more_call_expr_args_p (&iter))
+ pp_separate_with_comma (cxx_pp);
}
}
+ pp_cxx_right_paren (cxx_pp);
}
-/* Print out a list of initializers (subr of dump_expr) */
+/* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
+ using flags FLAGS. Skip over the first argument if SKIPFIRST is
+ true. */
static void
-dump_expr_list (l, flags)
- tree l;
- int flags;
+dump_aggr_init_expr_args (tree t, int flags, bool skipfirst)
+{
+ tree arg;
+ aggr_init_expr_arg_iterator iter;
+
+ pp_cxx_left_paren (cxx_pp);
+ FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
+ {
+ if (skipfirst)
+ skipfirst = false;
+ else
+ {
+ dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
+ if (more_aggr_init_expr_args_p (&iter))
+ pp_separate_with_comma (cxx_pp);
+ }
+ }
+ pp_cxx_right_paren (cxx_pp);
+}
+
+/* Print out a list of initializers (subr of dump_expr). */
+
+static void
+dump_expr_list (tree l, int flags)
{
while (l)
{
dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
l = TREE_CHAIN (l);
if (l)
- separate_with_comma (scratch_buffer);
+ pp_separate_with_comma (cxx_pp);
}
}
-/* Print out an expression E under control of FLAGS. */
+/* Print out a vector of initializers (subr of dump_expr). */
static void
-dump_expr (t, flags)
- tree t;
- int flags;
+dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
{
- if (t == 0)
+ unsigned HOST_WIDE_INT idx;
+ tree value;
+
+ FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
+ {
+ dump_expr (value, flags | TFF_EXPR_IN_PARENS);
+ if (idx != VEC_length (constructor_elt, v) - 1)
+ pp_separate_with_comma (cxx_pp);
+ }
+}
+
+
+/* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
+ function. Resolve it to a close relative -- in the sense of static
+ type -- variant being overridden. That is close to what was written in
+ the source code. Subroutine of dump_expr. */
+
+static tree
+resolve_virtual_fun_from_obj_type_ref (tree ref)
+{
+ tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
+ HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
+ tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
+ while (index)
+ {
+ fun = TREE_CHAIN (fun);
+ index -= (TARGET_VTABLE_USES_DESCRIPTORS
+ ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
+ }
+
+ return BV_FN (fun);
+}
+
+/* Print out an expression E under control of FLAGS. */
+
+static void
+dump_expr (tree t, int flags)
+{
+ if (t == 0)
+ return;
+
+ if (STATEMENT_CLASS_P (t))
+ {
+ pp_cxx_identifier (cxx_pp, "<statement>");
return;
-
+ }
+
switch (TREE_CODE (t))
{
case VAR_DECL:
case FUNCTION_DECL:
case TEMPLATE_DECL:
case NAMESPACE_DECL:
+ case LABEL_DECL:
case OVERLOAD:
- dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
+ case IDENTIFIER_NODE:
+ dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
break;
case INTEGER_CST:
- {
- tree type = TREE_TYPE (t);
- my_friendly_assert (type != 0, 81);
-
- /* If it's an enum, output its tag, rather than its value. */
- if (TREE_CODE (type) == ENUMERAL_TYPE)
- {
- tree values = TYPE_VALUES (type);
-
- for (; values;
- values = TREE_CHAIN (values))
- if (tree_int_cst_equal (TREE_VALUE (values), t))
- break;
-
- if (values)
- print_tree_identifier (scratch_buffer, TREE_PURPOSE (values));
- else
- {
- /* Value must have been cast. */
- print_left_paren (scratch_buffer);
- dump_type (type, flags);
- print_right_paren (scratch_buffer);
- goto do_int;
- }
- }
- else if (type == boolean_type_node)
- {
- if (t == boolean_false_node || integer_zerop (t))
- print_identifier (scratch_buffer, "false");
- else if (t == boolean_true_node)
- print_identifier (scratch_buffer, "true");
- }
- else if (type == char_type_node)
- {
- output_add_character (scratch_buffer, '\'');
- if (host_integerp (t, TREE_UNSIGNED (type)))
- dump_char (tree_low_cst (t, TREE_UNSIGNED (type)));
- else
- output_printf (scratch_buffer, "\\x%x",
- (unsigned int) TREE_INT_CST_LOW (t));
- output_add_character (scratch_buffer, '\'');
- }
- else
- {
- do_int:
- if (! host_integerp (t, 0))
- {
- tree val = t;
-
- if (tree_int_cst_sgn (val) < 0)
- {
- output_add_character (scratch_buffer, '-');
- val = build_int_2 (-TREE_INT_CST_LOW (val),
- ~TREE_INT_CST_HIGH (val)
- + !TREE_INT_CST_LOW (val));
- }
- /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
- systems? */
- {
- static char format[10]; /* "%x%09999x\0" */
- if (!format[0])
- sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4);
- sprintf (digit_buffer, format, TREE_INT_CST_HIGH (val),
- TREE_INT_CST_LOW (val));
- output_add_string (scratch_buffer, digit_buffer);
- }
- }
- else
- print_integer (scratch_buffer, TREE_INT_CST_LOW (t));
- }
- }
+ case REAL_CST:
+ case STRING_CST:
+ case COMPLEX_CST:
+ pp_constant (cxx_pp, t);
break;
- case REAL_CST:
-#ifndef REAL_IS_NOT_DOUBLE
- sprintf (digit_buffer, "%g", TREE_REAL_CST (t));
-#else
- {
- const unsigned char *p = (const unsigned char *) &TREE_REAL_CST (t);
- size_t i;
- strcpy (digit_buffer, "0x");
- for (i = 0; i < sizeof TREE_REAL_CST (t); i++)
- sprintf (digit_buffer + 2 + 2*i, "%02x", *p++);
- }
-#endif
- output_add_string (scratch_buffer, digit_buffer);
+ case THROW_EXPR:
+ /* While waiting for caret diagnostics, avoid printing
+ __cxa_allocate_exception, __cxa_throw, and the like. */
+ pp_cxx_identifier (cxx_pp, "<throw-expression>");
break;
case PTRMEM_CST:
- output_add_character (scratch_buffer, '&');
+ pp_ampersand (cxx_pp);
dump_type (PTRMEM_CST_CLASS (t), flags);
- print_scope_operator (scratch_buffer);
- print_tree_identifier
- (scratch_buffer, DECL_NAME (PTRMEM_CST_MEMBER (t)));
- break;
-
- case STRING_CST:
- {
- const char *p = TREE_STRING_POINTER (t);
- int len = TREE_STRING_LENGTH (t) - 1;
- int i;
-
- output_add_character (scratch_buffer, '\"');
- for (i = 0; i < len; i++)
- dump_char (p[i]);
- output_add_character (scratch_buffer, '\"');
- }
+ pp_cxx_colon_colon (cxx_pp);
+ pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
break;
case COMPOUND_EXPR:
- print_left_paren (scratch_buffer);
+ pp_cxx_left_paren (cxx_pp);
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
- separate_with_comma (scratch_buffer);
+ pp_separate_with_comma (cxx_pp);
dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
- print_right_paren (scratch_buffer);
+ pp_cxx_right_paren (cxx_pp);
break;
case COND_EXPR:
- print_left_paren (scratch_buffer);
+ pp_cxx_left_paren (cxx_pp);
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
- output_add_string (scratch_buffer, " ? ");
+ pp_string (cxx_pp, " ? ");
dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
- output_add_string (scratch_buffer, " : ");
+ pp_string (cxx_pp, " : ");
dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
- print_right_paren (scratch_buffer);
+ pp_cxx_right_paren (cxx_pp);
break;
case SAVE_EXPR:
if (TREE_HAS_CONSTRUCTOR (t))
{
- output_add_string (scratch_buffer, "new ");
+ pp_cxx_identifier (cxx_pp, "new");
+ pp_cxx_whitespace (cxx_pp);
dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
}
else
- {
- dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
- }
+ dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
break;
case AGGR_INIT_EXPR:
{
tree fn = NULL_TREE;
- if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
- fn = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
+ if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
+ fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
if (fn && TREE_CODE (fn) == FUNCTION_DECL)
{
if (DECL_CONSTRUCTOR_P (fn))
- print_tree_identifier
- (scratch_buffer, TYPE_IDENTIFIER (TREE_TYPE (t)));
+ dump_type (DECL_CONTEXT (fn), flags);
else
dump_decl (fn, 0);
}
else
- dump_expr (TREE_OPERAND (t, 0), 0);
+ dump_expr (AGGR_INIT_EXPR_FN (t), 0);
}
- print_left_paren (scratch_buffer);
- if (TREE_OPERAND (t, 1))
- dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
- print_right_paren (scratch_buffer);
+ dump_aggr_init_expr_args (t, flags, true);
break;
case CALL_EXPR:
{
- tree fn = TREE_OPERAND (t, 0);
- tree args = TREE_OPERAND (t, 1);
+ tree fn = CALL_EXPR_FN (t);
+ bool skipfirst = false;
if (TREE_CODE (fn) == ADDR_EXPR)
fn = TREE_OPERAND (fn, 0);
+ /* Nobody is interested in seeing the guts of vcalls. */
+ if (TREE_CODE (fn) == OBJ_TYPE_REF)
+ fn = resolve_virtual_fun_from_obj_type_ref (fn);
+
if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
{
- tree ob = TREE_VALUE (args);
+ tree ob = CALL_EXPR_ARG (t, 0);
if (TREE_CODE (ob) == ADDR_EXPR)
{
dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
- output_add_character (scratch_buffer, '.');
+ pp_cxx_dot (cxx_pp);
}
else if (TREE_CODE (ob) != PARM_DECL
|| strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
{
dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
- output_add_string (scratch_buffer, "->");
+ pp_cxx_arrow (cxx_pp);
}
- args = TREE_CHAIN (args);
+ skipfirst = true;
}
dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
- print_left_paren (scratch_buffer);
- dump_expr_list (args, flags);
- print_right_paren (scratch_buffer);
- }
- break;
-
- case NEW_EXPR:
- {
- tree type = TREE_OPERAND (t, 1);
- if (NEW_EXPR_USE_GLOBAL (t))
- print_scope_operator (scratch_buffer);
- output_add_string (scratch_buffer, "new ");
- if (TREE_OPERAND (t, 0))
- {
- print_left_paren (scratch_buffer);
- dump_expr_list (TREE_OPERAND (t, 0), flags);
- output_add_string (scratch_buffer, ") ");
- }
- 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))));
- dump_type (type, flags);
- if (TREE_OPERAND (t, 2))
- {
- print_left_paren (scratch_buffer);
- dump_expr_list (TREE_OPERAND (t, 2), flags);
- print_right_paren (scratch_buffer);
- }
+ dump_call_expr_args (t, flags, skipfirst);
}
break;
dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
break;
+ case POINTER_PLUS_EXPR:
+ dump_binary_op ("+", t, flags);
+ break;
+
case INIT_EXPR:
case MODIFY_EXPR:
case PLUS_EXPR:
case BIT_IOR_EXPR:
case BIT_XOR_EXPR:
case BIT_AND_EXPR:
- case BIT_ANDTC_EXPR:
case TRUTH_ANDIF_EXPR:
case TRUTH_ORIF_EXPR:
case LT_EXPR:
case CEIL_DIV_EXPR:
case FLOOR_DIV_EXPR:
case ROUND_DIV_EXPR:
+ case RDIV_EXPR:
dump_binary_op ("/", t, flags);
break;
{
ob = TREE_OPERAND (ob, 0);
if (TREE_CODE (ob) != PARM_DECL
- || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
+ || (DECL_NAME (ob)
+ && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
{
dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
- output_add_string (scratch_buffer, "->");
+ pp_cxx_arrow (cxx_pp);
}
}
else
{
dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
- output_add_character (scratch_buffer, '.');
+ pp_cxx_dot (cxx_pp);
}
dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
}
case ARRAY_REF:
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
- print_left_bracket (scratch_buffer);
+ pp_cxx_left_bracket (cxx_pp);
dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
- print_right_bracket (scratch_buffer);
+ pp_cxx_right_bracket (cxx_pp);
break;
- case CONVERT_EXPR:
- if (TREE_TYPE (t) && VOID_TYPE_P (TREE_TYPE (t)))
- {
- print_left_paren (scratch_buffer);
- dump_type (TREE_TYPE (t), flags);
- print_right_paren (scratch_buffer);
- dump_expr (TREE_OPERAND (t, 0), flags);
- }
- else
- dump_unary_op ("+", t, flags);
+ case UNARY_PLUS_EXPR:
+ dump_unary_op ("+", t, flags);
break;
case ADDR_EXPR:
|| (TREE_TYPE (t)
&& TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
+ else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
+ dump_unary_op ("&&", t, flags);
else
dump_unary_op ("&", t, flags);
break;
if (TREE_HAS_CONSTRUCTOR (t))
{
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);
- print_left_paren (scratch_buffer);
- dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
- print_right_paren (scratch_buffer);
+ gcc_assert (TREE_CODE (t) == CALL_EXPR);
+ dump_expr (CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
+ dump_call_expr_args (t, flags, true);
}
else
{
case POSTDECREMENT_EXPR:
case POSTINCREMENT_EXPR:
- print_left_paren (scratch_buffer);
+ pp_cxx_left_paren (cxx_pp);
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
- print_identifier
- (scratch_buffer, operator_name_info[(int)TREE_CODE (t)].name);
- print_right_paren (scratch_buffer);
+ pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
+ pp_cxx_right_paren (cxx_pp);
break;
case NON_LVALUE_EXPR:
if (TREE_CODE (next) == FUNCTION_TYPE)
{
if (flags & TFF_EXPR_IN_PARENS)
- print_left_paren (scratch_buffer);
- output_add_character (scratch_buffer, '*');
+ pp_cxx_left_paren (cxx_pp);
+ pp_cxx_star (cxx_pp);
dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
if (flags & TFF_EXPR_IN_PARENS)
- print_right_paren (scratch_buffer);
+ pp_cxx_right_paren (cxx_pp);
break;
}
- /* else FALLTHRU */
+ /* Else fall through. */
}
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
break;
- case NOP_EXPR:
- dump_expr (TREE_OPERAND (t, 0), flags);
- break;
+ CASE_CONVERT:
+ case VIEW_CONVERT_EXPR:
+ {
+ tree op = TREE_OPERAND (t, 0);
- case EXPR_WITH_FILE_LOCATION:
- dump_expr (EXPR_WFL_NODE (t), flags);
- break;
+ if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
+ {
+ /* It is a cast, but we cannot tell whether it is a
+ reinterpret or static cast. Use the C style notation. */
+ if (flags & TFF_EXPR_IN_PARENS)
+ pp_cxx_left_paren (cxx_pp);
+ pp_cxx_left_paren (cxx_pp);
+ dump_type (TREE_TYPE (t), flags);
+ pp_cxx_right_paren (cxx_pp);
+ dump_expr (op, flags | TFF_EXPR_IN_PARENS);
+ if (flags & TFF_EXPR_IN_PARENS)
+ pp_cxx_right_paren (cxx_pp);
+ }
+ else
+ dump_expr (op, flags);
+ break;
+ }
case CONSTRUCTOR:
if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
{
- tree idx = build_component_ref (t, pfn_identifier, NULL_TREE, 0);
+ tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
if (integer_zerop (idx))
{
/* A NULL pointer-to-member constant. */
- output_add_string (scratch_buffer, "((");
+ pp_cxx_left_paren (cxx_pp);
+ pp_cxx_left_paren (cxx_pp);
dump_type (TREE_TYPE (t), flags);
- output_add_string (scratch_buffer, ") 0)");
+ pp_cxx_right_paren (cxx_pp);
+ pp_character (cxx_pp, '0');
+ pp_cxx_right_paren (cxx_pp);
break;
}
else if (host_integerp (idx, 0))
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 (virtuals)
{
dump_expr (BV_FN (virtuals),
- flags | TFF_EXPR_IN_PARENS);
+ flags | TFF_EXPR_IN_PARENS);
break;
}
}
}
- output_add_character (scratch_buffer, '{');
- dump_expr_list (CONSTRUCTOR_ELTS (t), flags);
- output_add_character (scratch_buffer, '}');
+ if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (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_init_vec (CONSTRUCTOR_ELTS (t), flags);
+ pp_cxx_right_brace (cxx_pp);
+ }
+
break;
case OFFSET_REF:
/* A::f */
dump_expr (t, flags | TFF_EXPR_IN_PARENS);
else if (BASELINK_P (t))
- dump_expr (OVL_CURRENT (TREE_VALUE (t)), flags | TFF_EXPR_IN_PARENS);
+ dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
+ flags | TFF_EXPR_IN_PARENS);
else
dump_decl (t, flags);
}
if (TREE_CODE (ob) == INDIRECT_REF)
{
dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
- output_add_string (scratch_buffer, "->*");
+ pp_cxx_arrow (cxx_pp);
+ pp_cxx_star (cxx_pp);
}
else
{
dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
- output_add_string (scratch_buffer, ".*");
+ pp_cxx_dot (cxx_pp);
+ pp_cxx_star (cxx_pp);
}
dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
}
dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
break;
- case IDENTIFIER_NODE:
- print_tree_identifier (scratch_buffer, t);
- break;
-
- case SCOPE_REF:
- dump_type (TREE_OPERAND (t, 0), flags);
- print_scope_operator (scratch_buffer);
- dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
- break;
-
case CAST_EXPR:
if (TREE_OPERAND (t, 0) == NULL_TREE
|| TREE_CHAIN (TREE_OPERAND (t, 0)))
{
dump_type (TREE_TYPE (t), flags);
- print_left_paren (scratch_buffer);
+ pp_cxx_left_paren (cxx_pp);
dump_expr_list (TREE_OPERAND (t, 0), flags);
- print_right_paren (scratch_buffer);
+ pp_cxx_right_paren (cxx_pp);
}
else
{
- print_left_paren (scratch_buffer);
+ pp_cxx_left_paren (cxx_pp);
dump_type (TREE_TYPE (t), flags);
- output_add_string (scratch_buffer, ")(");
+ pp_cxx_right_paren (cxx_pp);
+ pp_cxx_left_paren (cxx_pp);
dump_expr_list (TREE_OPERAND (t, 0), flags);
- print_right_paren (scratch_buffer);
+ pp_cxx_right_paren (cxx_pp);
}
break;
case STATIC_CAST_EXPR:
- output_add_string (scratch_buffer, "static_cast<");
+ pp_cxx_identifier (cxx_pp, "static_cast");
goto cast;
case REINTERPRET_CAST_EXPR:
- output_add_string (scratch_buffer, "reinterpret_cast<");
+ pp_cxx_identifier (cxx_pp, "reinterpret_cast");
goto cast;
case CONST_CAST_EXPR:
- output_add_string (scratch_buffer, "const_cast<");
+ pp_cxx_identifier (cxx_pp, "const_cast");
goto cast;
case DYNAMIC_CAST_EXPR:
- output_add_string (scratch_buffer, "dynamic_cast<");
+ pp_cxx_identifier (cxx_pp, "dynamic_cast");
cast:
+ pp_cxx_begin_template_argument_list (cxx_pp);
dump_type (TREE_TYPE (t), flags);
- output_add_string (scratch_buffer, ">(");
+ pp_cxx_end_template_argument_list (cxx_pp);
+ pp_cxx_left_paren (cxx_pp);
dump_expr (TREE_OPERAND (t, 0), flags);
- print_right_paren (scratch_buffer);
- break;
-
- case LOOKUP_EXPR:
- print_tree_identifier (scratch_buffer, TREE_OPERAND (t, 0));
+ pp_cxx_right_paren (cxx_pp);
break;
case ARROW_EXPR:
dump_expr (TREE_OPERAND (t, 0), flags);
- output_add_string (scratch_buffer, "->");
+ pp_cxx_arrow (cxx_pp);
break;
case SIZEOF_EXPR:
case ALIGNOF_EXPR:
if (TREE_CODE (t) == SIZEOF_EXPR)
- output_add_string (scratch_buffer, "sizeof (");
+ pp_cxx_identifier (cxx_pp, "sizeof");
else
{
- my_friendly_assert (TREE_CODE (t) == ALIGNOF_EXPR, 0);
- output_add_string (scratch_buffer, "__alignof__ (");
+ gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
+ pp_cxx_identifier (cxx_pp, "__alignof__");
}
+ pp_cxx_whitespace (cxx_pp);
+ pp_cxx_left_paren (cxx_pp);
if (TYPE_P (TREE_OPERAND (t, 0)))
dump_type (TREE_OPERAND (t, 0), flags);
else
- dump_unary_op ("*", t, flags | TFF_EXPR_IN_PARENS);
- print_right_paren (scratch_buffer);
+ dump_expr (TREE_OPERAND (t, 0), flags);
+ pp_cxx_right_paren (cxx_pp);
+ break;
+
+ case REALPART_EXPR:
+ case IMAGPART_EXPR:
+ pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
+ pp_cxx_whitespace (cxx_pp);
+ dump_expr (TREE_OPERAND (t, 0), flags);
break;
case DEFAULT_ARG:
- print_identifier (scratch_buffer, "<unparsed>");
+ pp_identifier (cxx_pp, "<unparsed>");
break;
case TRY_CATCH_EXPR:
case PSEUDO_DTOR_EXPR:
dump_expr (TREE_OPERAND (t, 2), flags);
- output_add_character (scratch_buffer, '.');
+ pp_cxx_dot (cxx_pp);
dump_type (TREE_OPERAND (t, 0), flags);
- output_add_string (scratch_buffer, "::~");
+ pp_cxx_colon_colon (cxx_pp);
+ pp_cxx_complement (cxx_pp);
dump_type (TREE_OPERAND (t, 1), flags);
break;
dump_decl (t, flags);
break;
+ case BIND_EXPR:
case STMT_EXPR:
+ case EXPR_STMT:
+ case STATEMENT_LIST:
/* We don't yet have a way of dumping statements in a
human-readable format. */
- output_add_string (scratch_buffer, "({...})");
- break;
-
- case BIND_EXPR:
- output_add_character (scratch_buffer, '{');
- dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
- output_add_character (scratch_buffer, '}');
+ pp_string (cxx_pp, "({...})");
break;
case LOOP_EXPR:
- output_add_string (scratch_buffer, "while (1) { ");
+ pp_string (cxx_pp, "while (1) { ");
dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
- output_add_character (scratch_buffer, '}');
+ pp_cxx_right_brace (cxx_pp);
break;
case EXIT_EXPR:
- output_add_string (scratch_buffer, "if (");
+ pp_string (cxx_pp, "if (");
dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
- output_add_string (scratch_buffer, ") break; ");
+ pp_string (cxx_pp, ") break; ");
break;
- case TREE_LIST:
- if (TREE_VALUE (t) && TREE_CODE (TREE_VALUE (t)) == FUNCTION_DECL)
- {
- print_tree_identifier (scratch_buffer, DECL_NAME (TREE_VALUE (t)));
- break;
- }
- /* else fall through */
+ case BASELINK:
+ dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
+ break;
+
+ case EMPTY_CLASS_EXPR:
+ dump_type (TREE_TYPE (t), flags);
+ pp_cxx_left_paren (cxx_pp);
+ pp_cxx_right_paren (cxx_pp);
+ break;
+
+ case NON_DEPENDENT_EXPR:
+ dump_expr (TREE_OPERAND (t, 0), flags);
+ break;
+
+ case ARGUMENT_PACK_SELECT:
+ dump_template_argument (ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
+ break;
+
+ case RECORD_TYPE:
+ case UNION_TYPE:
+ case ENUMERAL_TYPE:
+ case REAL_TYPE:
+ case VOID_TYPE:
+ case BOOLEAN_TYPE:
+ case INTEGER_TYPE:
+ case COMPLEX_TYPE:
+ case VECTOR_TYPE:
+ pp_type_specifier_seq (cxx_pp, t);
+ break;
+
+ case TYPENAME_TYPE:
+ /* We get here when we want to print a dependent type as an
+ id-expression, without any disambiguator decoration. */
+ pp_id_expression (cxx_pp, t);
+ break;
+
+ case TEMPLATE_TYPE_PARM:
+ case BOUND_TEMPLATE_TEMPLATE_PARM:
+ dump_type (t, flags);
+ break;
+
+ case TRAIT_EXPR:
+ pp_cxx_trait_expression (cxx_pp, t);
+ break;
+
+ case VA_ARG_EXPR:
+ pp_cxx_va_arg_expression (cxx_pp, t);
+ break;
+
+ case OFFSETOF_EXPR:
+ pp_cxx_offsetof_expression (cxx_pp, t);
+ break;
+
+ case SCOPE_REF:
+ case EXPR_PACK_EXPANSION:
+ case TYPEID_EXPR:
+ case MEMBER_REF:
+ case DOTSTAR_EXPR:
+ case NEW_EXPR:
+ case VEC_NEW_EXPR:
+ case DELETE_EXPR:
+ case VEC_DELETE_EXPR:
+ case MODOP_EXPR:
+ case ABS_EXPR:
+ case CONJ_EXPR:
+ case VECTOR_CST:
+ case FIXED_CST:
+ case UNORDERED_EXPR:
+ case ORDERED_EXPR:
+ case UNLT_EXPR:
+ case UNLE_EXPR:
+ case UNGT_EXPR:
+ case UNGE_EXPR:
+ case UNEQ_EXPR:
+ case LTGT_EXPR:
+ case COMPLEX_EXPR:
+ case BIT_FIELD_REF:
+ case FIX_TRUNC_EXPR:
+ case FLOAT_EXPR:
+ pp_expression (cxx_pp, t);
+ break;
+
+ case TRUTH_AND_EXPR:
+ case TRUTH_OR_EXPR:
+ case TRUTH_XOR_EXPR:
+ if (flags & TFF_EXPR_IN_PARENS)
+ pp_cxx_left_paren (cxx_pp);
+ pp_expression (cxx_pp, t);
+ if (flags & TFF_EXPR_IN_PARENS)
+ pp_cxx_right_paren (cxx_pp);
+ break;
+
+ case OBJ_TYPE_REF:
+ dump_expr (resolve_virtual_fun_from_obj_type_ref (t), flags);
+ break;
/* This list is incomplete, but should suffice for now.
It is very important that `sorry' does not call
`report_error_function'. That could cause an infinite loop. */
default:
- sorry_for_unsupported_tree (t);
+ pp_unsupported_tree (cxx_pp, t);
/* fall through to ERROR_MARK... */
case ERROR_MARK:
- print_identifier (scratch_buffer, "<expression error>");
+ pp_identifier (cxx_pp, "<expression error>");
break;
}
}
static void
-dump_binary_op (opstring, t, flags)
- const char *opstring;
- tree t;
- int flags;
+dump_binary_op (const char *opstring, tree t, int flags)
{
- print_left_paren (scratch_buffer);
+ pp_cxx_left_paren (cxx_pp);
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
- output_add_space (scratch_buffer);
+ pp_cxx_whitespace (cxx_pp);
if (opstring)
- print_identifier (scratch_buffer, opstring);
+ pp_cxx_identifier (cxx_pp, opstring);
else
- print_identifier (scratch_buffer, "<unknown operator>");
- output_add_space (scratch_buffer);
+ pp_identifier (cxx_pp, "<unknown operator>");
+ pp_cxx_whitespace (cxx_pp);
dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
- print_right_paren (scratch_buffer);
+ pp_cxx_right_paren (cxx_pp);
}
static void
-dump_unary_op (opstring, t, flags)
- const char *opstring;
- tree t;
- int flags;
+dump_unary_op (const char *opstring, tree t, int flags)
{
if (flags & TFF_EXPR_IN_PARENS)
- print_left_paren (scratch_buffer);
- print_identifier (scratch_buffer, opstring);
+ pp_cxx_left_paren (cxx_pp);
+ pp_cxx_identifier (cxx_pp, opstring);
dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
if (flags & TFF_EXPR_IN_PARENS)
- print_right_paren (scratch_buffer);
+ pp_cxx_right_paren (cxx_pp);
}
+static void
+reinit_cxx_pp (void)
+{
+ pp_clear_output_area (cxx_pp);
+ pp_base (cxx_pp)->padding = pp_none;
+ pp_indentation (cxx_pp) = 0;
+ pp_needs_newline (cxx_pp) = false;
+ cxx_pp->enclosing_scope = current_function_decl;
+}
+
+
/* Exported interface to stringifying types, exprs and decls under TFF_*
control. */
const char *
-type_as_string (typ, flags)
- tree typ;
- int flags;
+type_as_string (tree typ, int flags)
{
- reinit_global_formatting_buffer ();
-
+ reinit_cxx_pp ();
dump_type (typ, flags);
-
- return output_finalize_message (scratch_buffer);
+ return pp_formatted_text (cxx_pp);
}
const char *
-expr_as_string (decl, flags)
- tree decl;
- int flags;
+expr_as_string (tree decl, int flags)
{
- reinit_global_formatting_buffer ();
-
+ reinit_cxx_pp ();
dump_expr (decl, flags);
-
- return output_finalize_message (scratch_buffer);
+ return pp_formatted_text (cxx_pp);
}
const char *
-decl_as_string (decl, flags)
- tree decl;
- int flags;
+decl_as_string (tree decl, int flags)
{
- reinit_global_formatting_buffer ();
-
+ reinit_cxx_pp ();
dump_decl (decl, flags);
-
- return output_finalize_message (scratch_buffer);
+ return pp_formatted_text (cxx_pp);
}
-const char *
-context_as_string (context, flags)
- tree context;
- int flags;
-{
- reinit_global_formatting_buffer ();
-
- dump_scope (context, flags);
-
- return output_finalize_message (scratch_buffer);
-}
-
-/* Generate the three forms of printable names for lang_printable_name. */
+/* Generate the three forms of printable names for cxx_printable_name. */
const char *
-lang_decl_name (decl, v)
- tree decl;
- int v;
+lang_decl_name (tree decl, int v)
{
if (v >= 2)
return decl_as_string (decl, TFF_DECL_SPECIFIERS);
- reinit_global_formatting_buffer ();
-
- if (v == 1 && DECL_CLASS_SCOPE_P (decl))
+ reinit_cxx_pp ();
+ if (v == 1
+ && (DECL_CLASS_SCOPE_P (decl)
+ || (DECL_NAMESPACE_SCOPE_P (decl)
+ && CP_DECL_CONTEXT (decl) != global_namespace)))
{
dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
- print_scope_operator (scratch_buffer);
+ pp_cxx_colon_colon (cxx_pp);
}
if (TREE_CODE (decl) == FUNCTION_DECL)
else
dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
- return output_finalize_message (scratch_buffer);
+ return pp_formatted_text (cxx_pp);
}
-const char *
-cp_file_of (t)
- tree t;
-{
- if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
- return DECL_SOURCE_FILE (DECL_CONTEXT (t));
- else if (TYPE_P (t))
- return DECL_SOURCE_FILE (TYPE_MAIN_DECL (t));
- else if (TREE_CODE (t) == OVERLOAD)
- return DECL_SOURCE_FILE (OVL_FUNCTION (t));
- else
- return DECL_SOURCE_FILE (t);
-}
+/* Return the location of a tree passed to %+ formats. */
-int
-cp_line_of (t)
- tree t;
+static location_t
+location_of (tree t)
{
- int line = 0;
if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
- line = DECL_SOURCE_LINE (DECL_CONTEXT (t));
- if (TREE_CODE (t) == TYPE_DECL && DECL_ARTIFICIAL (t)
- && TYPE_MAIN_DECL (TREE_TYPE (t)))
- t = TREE_TYPE (t);
-
- if (TYPE_P (t))
- line = DECL_SOURCE_LINE (TYPE_MAIN_DECL (t));
+ t = DECL_CONTEXT (t);
+ else if (TYPE_P (t))
+ t = TYPE_MAIN_DECL (t);
else if (TREE_CODE (t) == OVERLOAD)
- line = DECL_SOURCE_LINE (OVL_FUNCTION (t));
- else
- line = DECL_SOURCE_LINE (t);
-
- if (line == 0)
- return lineno;
+ t = OVL_FUNCTION (t);
- return line;
+ return DECL_SOURCE_LOCATION (t);
}
/* Now the interfaces from error et al to dump_type et al. Each takes an
function. */
static const char *
-decl_to_string (decl, verbose)
- tree decl;
- int verbose;
+decl_to_string (tree decl, int verbose)
{
int flags = 0;
|| TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
flags = TFF_CLASS_KEY_OR_ENUM;
if (verbose)
- flags |= TFF_DECL_SPECIFIERS | TFF_FUNCTION_DEFAULT_ARGUMENTS;
+ flags |= TFF_DECL_SPECIFIERS;
else if (TREE_CODE (decl) == FUNCTION_DECL)
flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
flags |= TFF_TEMPLATE_HEADER;
- reinit_global_formatting_buffer ();
-
+ reinit_cxx_pp ();
dump_decl (decl, flags);
-
- return output_finalize_message (scratch_buffer);
+ return pp_formatted_text (cxx_pp);
}
static const char *
-expr_to_string (decl, verbose)
- tree decl;
- int verbose ATTRIBUTE_UNUSED;
+expr_to_string (tree decl)
{
- reinit_global_formatting_buffer ();
-
+ reinit_cxx_pp ();
dump_expr (decl, 0);
-
- return output_finalize_message (scratch_buffer);
+ return pp_formatted_text (cxx_pp);
}
static const char *
-fndecl_to_string (fndecl, verbose)
- tree fndecl;
- int verbose;
+fndecl_to_string (tree fndecl, int verbose)
{
int flags;
- flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS;
+ flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
+ | TFF_TEMPLATE_HEADER;
if (verbose)
flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
- reinit_global_formatting_buffer ();
-
+ reinit_cxx_pp ();
dump_decl (fndecl, flags);
-
- return output_finalize_message (scratch_buffer);
+ return pp_formatted_text (cxx_pp);
}
static const char *
-code_to_string (c, v)
- enum tree_code c;
- int v ATTRIBUTE_UNUSED;
+code_to_string (enum tree_code c)
{
return tree_code_name [c];
}
const char *
-language_to_string (c, v)
- enum languages c;
- int v ATTRIBUTE_UNUSED;
+language_to_string (enum languages c)
{
switch (c)
{
return "Java";
default:
- abort ();
- return 0;
+ gcc_unreachable ();
}
+ return NULL;
}
/* Return the proper printed version of a parameter to a C++ function. */
static const char *
-parm_to_string (p, v)
- int p;
- int v ATTRIBUTE_UNUSED;
+parm_to_string (int p)
{
+ reinit_cxx_pp ();
if (p < 0)
- return "`this'";
-
- sprintf (digit_buffer, "%d", p+1);
- return digit_buffer;
+ pp_string (cxx_pp, "'this'");
+ else
+ pp_decimal_int (cxx_pp, p + 1);
+ return pp_formatted_text (cxx_pp);
}
static const char *
-op_to_string (p, v)
- enum tree_code p;
- int v ATTRIBUTE_UNUSED;
+op_to_string (enum tree_code p)
{
- tree id;
-
- id = operator_name_info[(int) p].identifier;
- return id ? IDENTIFIER_POINTER (id) : "{unknown}";
+ tree id = operator_name_info[(int) p].identifier;
+ return id ? IDENTIFIER_POINTER (id) : "<unknown>";
}
static const char *
-type_to_string (typ, verbose)
- tree typ;
- int verbose;
+type_to_string (tree typ, int verbose)
{
- int flags;
-
- flags = 0;
+ int flags = 0;
if (verbose)
flags |= TFF_CLASS_KEY_OR_ENUM;
flags |= TFF_TEMPLATE_HEADER;
- reinit_global_formatting_buffer ();
-
+ reinit_cxx_pp ();
dump_type (typ, flags);
-
- return output_finalize_message (scratch_buffer);
+ return pp_formatted_text (cxx_pp);
}
static const char *
-assop_to_string (p, v)
- enum tree_code p;
- int v ATTRIBUTE_UNUSED;
+assop_to_string (enum tree_code p)
{
- tree id;
-
- id = assignment_operator_name_info[(int) p].identifier;
+ tree id = assignment_operator_name_info[(int) p].identifier;
return id ? IDENTIFIER_POINTER (id) : "{unknown}";
}
static const char *
-args_to_string (p, verbose)
- tree p;
- int verbose;
+args_to_string (tree p, int verbose)
{
int flags = 0;
if (verbose)
if (TYPE_P (TREE_VALUE (p)))
return type_as_string (p, flags);
- reinit_global_formatting_buffer ();
+ reinit_cxx_pp ();
for (; p; p = TREE_CHAIN (p))
{
if (TREE_VALUE (p) == null_node)
- print_identifier (scratch_buffer, "NULL");
+ pp_cxx_identifier (cxx_pp, "NULL");
else
dump_type (error_type (TREE_VALUE (p)), flags);
if (TREE_CHAIN (p))
- separate_with_comma (scratch_buffer);
+ pp_separate_with_comma (cxx_pp);
}
- return output_finalize_message (scratch_buffer);
+ return pp_formatted_text (cxx_pp);
}
static const char *
-cv_to_string (p, v)
- tree p;
- int v;
+cv_to_string (tree p, int v)
{
- reinit_global_formatting_buffer ();
-
- dump_qualifiers (p, v ? before : none);
-
- return output_finalize_message (scratch_buffer);
+ reinit_cxx_pp ();
+ pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
+ pp_cxx_cv_qualifier_seq (cxx_pp, p);
+ return pp_formatted_text (cxx_pp);
}
-static void
-lang_print_error_function (context, file)
- diagnostic_context *context;
- const char *file;
+/* Langhook for print_error_function. */
+void
+cxx_print_error_function (diagnostic_context *context, const char *file,
+ diagnostic_info *diagnostic)
{
- output_state os;
-
- default_print_error_function (context, file);
- os = output_buffer_state (context);
- output_set_prefix ((output_buffer *)context, file);
- maybe_print_instantiation_context ((output_buffer *)context);
- output_buffer_state (context) = os;
+ lhd_print_error_function (context, file, diagnostic);
+ pp_base_set_prefix (context->printer, file);
+ maybe_print_instantiation_context (context);
}
static void
-cp_diagnostic_starter (buffer, dc)
- output_buffer *buffer;
- diagnostic_context *dc;
+cp_diagnostic_starter (diagnostic_context *context,
+ diagnostic_info *diagnostic)
{
- report_problematic_module (buffer);
- cp_print_error_function (buffer, dc);
- maybe_print_instantiation_context (buffer);
- output_set_prefix (buffer,
- context_as_prefix (diagnostic_file_location (dc),
- diagnostic_line_location (dc),
- diagnostic_is_warning (dc)));
+ diagnostic_report_current_module (context);
+ cp_print_error_function (context, diagnostic);
+ maybe_print_instantiation_context (context);
+ pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
}
static void
-cp_diagnostic_finalizer (buffer, dc)
- output_buffer *buffer;
- diagnostic_context *dc __attribute__ ((__unused__));
+cp_diagnostic_finalizer (diagnostic_context *context,
+ diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
{
- output_destroy_prefix (buffer);
+ pp_base_destroy_prefix (context->printer);
}
/* Print current function onto BUFFER, in the process of reporting
a diagnostic message. Called from cp_diagnostic_starter. */
static void
-cp_print_error_function (buffer, dc)
- output_buffer *buffer;
- diagnostic_context *dc;
+cp_print_error_function (diagnostic_context *context,
+ diagnostic_info *diagnostic)
{
- if (error_function_changed ())
+ if (diagnostic_last_function_changed (context, diagnostic))
{
- char *prefix = diagnostic_file_location (dc)
- ? file_name_as_prefix (diagnostic_file_location (dc))
- : NULL;
- output_state os;
+ const char *old_prefix = context->printer->prefix;
+ const char *file = LOCATION_FILE (diagnostic->location);
+ tree abstract_origin = diagnostic->abstract_origin;
+ char *new_prefix = (file && abstract_origin == NULL)
+ ? file_name_as_prefix (file) : NULL;
- os = output_buffer_state (buffer);
- output_set_prefix (buffer, prefix);
+ pp_base_set_prefix (context->printer, new_prefix);
if (current_function_decl == NULL)
- output_add_string (buffer, "At global scope:");
+ pp_base_string (context->printer, "At global scope:");
else
- output_printf
- (buffer, "In %s `%s':", function_category (current_function_decl),
- (*decl_printable_name) (current_function_decl, 2));
- output_add_newline (buffer);
-
- record_last_error_function ();
- output_destroy_prefix (buffer);
- output_buffer_state (buffer) = os;
+ {
+ tree fndecl, ao;
+
+ if (abstract_origin)
+ {
+ ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
+ while (TREE_CODE (ao) == BLOCK
+ && BLOCK_ABSTRACT_ORIGIN (ao)
+ && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
+ ao = BLOCK_ABSTRACT_ORIGIN (ao);
+ gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
+ fndecl = ao;
+ }
+ else
+ fndecl = current_function_decl;
+
+ pp_printf (context->printer, "In %s %qs",
+ function_category (fndecl),
+ cxx_printable_name (fndecl, 2));
+
+ while (abstract_origin)
+ {
+ location_t *locus;
+ tree block = abstract_origin;
+
+ locus = &BLOCK_SOURCE_LOCATION (block);
+ fndecl = NULL;
+ block = BLOCK_SUPERCONTEXT (block);
+ while (block && TREE_CODE (block) == BLOCK
+ && BLOCK_ABSTRACT_ORIGIN (block))
+ {
+ ao = BLOCK_ABSTRACT_ORIGIN (block);
+
+ while (TREE_CODE (ao) == BLOCK
+ && BLOCK_ABSTRACT_ORIGIN (ao)
+ && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
+ ao = BLOCK_ABSTRACT_ORIGIN (ao);
+
+ if (TREE_CODE (ao) == FUNCTION_DECL)
+ {
+ fndecl = ao;
+ break;
+ }
+ else if (TREE_CODE (ao) != BLOCK)
+ break;
+
+ block = BLOCK_SUPERCONTEXT (block);
+ }
+ if (fndecl)
+ abstract_origin = block;
+ else
+ {
+ while (block && TREE_CODE (block) == BLOCK)
+ block = BLOCK_SUPERCONTEXT (block);
+
+ if (block && TREE_CODE (block) == FUNCTION_DECL)
+ fndecl = block;
+ abstract_origin = NULL;
+ }
+ if (fndecl)
+ {
+ expanded_location s = expand_location (*locus);
+ pp_base_character (context->printer, ',');
+ pp_base_newline (context->printer);
+ if (s.file != NULL)
+ {
+ if (flag_show_column && s.column != 0)
+ pp_printf (context->printer,
+ " inlined from %qs at %s:%d:%d",
+ cxx_printable_name (fndecl, 2),
+ s.file, s.line, s.column);
+ else
+ pp_printf (context->printer,
+ " inlined from %qs at %s:%d",
+ cxx_printable_name (fndecl, 2),
+ s.file, s.line);
+
+ }
+ else
+ pp_printf (context->printer, " inlined from %qs",
+ cxx_printable_name (fndecl, 2));
+ }
+ }
+ pp_base_character (context->printer, ':');
+ }
+ pp_base_newline (context->printer);
+
+ diagnostic_set_last_function (context, diagnostic);
+ pp_base_destroy_prefix (context->printer);
+ context->printer->prefix = old_prefix;
}
}
/* Returns a description of FUNCTION using standard terminology. */
static const char *
-function_category (fn)
- tree fn;
+function_category (tree fn)
{
if (DECL_FUNCTION_MEMBER_P (fn))
{
if (DECL_STATIC_FUNCTION_P (fn))
- return "static member function";
+ return "static member function";
else if (DECL_COPY_CONSTRUCTOR_P (fn))
- return "copy constructor";
+ return "copy constructor";
else if (DECL_CONSTRUCTOR_P (fn))
- return "constructor";
+ return "constructor";
else if (DECL_DESTRUCTOR_P (fn))
- return "destructor";
+ return "destructor";
else
- return "member function";
+ return "member function";
}
else
return "function";
/* Report the full context of a current template instantiation,
onto BUFFER. */
static void
-print_instantiation_full_context (buffer)
- output_buffer *buffer;
+print_instantiation_full_context (diagnostic_context *context)
{
- tree p = current_instantiation ();
- int line = lineno;
- const char *file = input_filename;
+ struct tinst_level *p = current_instantiation ();
+ location_t location = input_location;
if (p)
{
- if (current_function_decl != TINST_DECL (p)
+ if (current_function_decl != p->decl
&& current_function_decl != NULL_TREE)
/* We can get here during the processing of some synthesized
- method. Then, TINST_DECL (p) will be the function that's causing
+ method. Then, P->DECL will be the function that's causing
the synthesis. */
;
else
{
- if (current_function_decl == TINST_DECL (p))
- /* Avoid redundancy with the the "In function" line. */;
+ if (current_function_decl == p->decl)
+ /* Avoid redundancy with the "In function" line. */;
else
- output_verbatim (buffer, "%s: In instantiation of `%s':\n", file,
- decl_as_string (TINST_DECL (p),
- TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
-
- line = TINST_LINE (p);
- file = TINST_FILE (p);
- p = TREE_CHAIN (p);
+ pp_verbatim (context->printer,
+ "%s: In instantiation of %qs:\n",
+ LOCATION_FILE (location),
+ decl_as_string (p->decl,
+ TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
+
+ location = p->locus;
+ p = p->next;
}
}
- print_instantiation_partial_context (buffer, p, file, line);
+ print_instantiation_partial_context (context, p, location);
}
/* Same as above but less verbose. */
static void
-print_instantiation_partial_context (buffer, t, file, line)
- output_buffer *buffer;
- tree t;
- const char *file;
- int line;
+print_instantiation_partial_context (diagnostic_context *context,
+ struct tinst_level *t, location_t loc)
{
- for (; t; t = TREE_CHAIN (t))
+ expanded_location xloc;
+ for (; ; t = t->next)
{
- output_verbatim
- (buffer, "%s:%d: instantiated from `%s'\n", file, line,
- decl_as_string (TINST_DECL (t), TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
- line = TINST_LINE (t);
- file = TINST_FILE (t);
+ xloc = expand_location (loc);
+ if (t == NULL)
+ break;
+ pp_verbatim (context->printer, "%s:%d: instantiated from %qs\n",
+ xloc.file, xloc.line,
+ decl_as_string (t->decl,
+ TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
+ loc = t->locus;
}
- output_verbatim (buffer, "%s:%d: instantiated from here\n", file, line);
+ pp_verbatim (context->printer, "%s:%d: instantiated from here",
+ xloc.file, xloc.line);
+ pp_base_newline (context->printer);
}
/* Called from cp_thing to print the template context for an error. */
static void
-maybe_print_instantiation_context (buffer)
- output_buffer *buffer;
+maybe_print_instantiation_context (diagnostic_context *context)
{
if (!problematic_instantiation_changed () || current_instantiation () == 0)
return;
record_last_problematic_instantiation ();
- print_instantiation_full_context (buffer);
+ print_instantiation_full_context (context);
}
/* Report the bare minimum context of a template instantiation. */
void
-print_instantiation_context ()
+print_instantiation_context (void)
{
print_instantiation_partial_context
- (diagnostic_buffer, current_instantiation (), input_filename, lineno);
- flush_diagnostic_buffer ();
+ (global_dc, current_instantiation (), input_location);
+ diagnostic_flush_buffer (global_dc);
}
\f
/* Called from output_format -- during diagnostic message processing --
%Q assignment operator.
%T type.
%V cv-qualifier. */
-static int
-cp_printer (buffer)
- output_buffer *buffer;
+static bool
+cp_printer (pretty_printer *pp, text_info *text, const char *spec,
+ int precision, bool wide, bool set_locus, bool verbose)
{
- int verbose = 0;
const char *result;
-#define next_tree va_arg (output_buffer_format_args (buffer), tree)
-#define next_tcode va_arg (output_buffer_format_args (buffer), enum tree_code)
-#define next_lang va_arg (output_buffer_format_args (buffer), enum languages)
-#define next_int va_arg (output_buffer_format_args (buffer), int)
-
- if (*output_buffer_text_cursor (buffer) == '+')
- ++output_buffer_text_cursor (buffer);
- if (*output_buffer_text_cursor (buffer) == '#')
- {
- verbose = 1;
- ++output_buffer_text_cursor (buffer);
- }
+ tree t = NULL;
+#define next_tree (t = va_arg (*text->args_ptr, tree))
+#define next_tcode va_arg (*text->args_ptr, enum tree_code)
+#define next_lang va_arg (*text->args_ptr, enum languages)
+#define next_int va_arg (*text->args_ptr, int)
+
+ if (precision != 0 || wide)
+ return false;
- switch (*output_buffer_text_cursor (buffer))
+ if (text->locus == NULL)
+ set_locus = false;
+
+ switch (*spec)
{
case 'A': result = args_to_string (next_tree, verbose); break;
- case 'C': result = code_to_string (next_tcode, verbose); break;
- case 'D': result = decl_to_string (next_tree, verbose); break;
- case 'E': result = expr_to_string (next_tree, verbose); break;
+ case 'C': result = code_to_string (next_tcode); break;
+ case 'D':
+ {
+ tree temp = next_tree;
+ if (DECL_P (temp)
+ && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
+ {
+ temp = DECL_DEBUG_EXPR (temp);
+ if (!DECL_P (temp))
+ {
+ result = expr_to_string (temp);
+ break;
+ }
+ }
+ result = decl_to_string (temp, verbose);
+ }
+ break;
+ case 'E': result = expr_to_string (next_tree); break;
case 'F': result = fndecl_to_string (next_tree, verbose); break;
- case 'L': result = language_to_string (next_lang, verbose); break;
- case 'O': result = op_to_string (next_tcode, verbose); break;
- case 'P': result = parm_to_string (next_int, verbose); break;
- case 'Q': result = assop_to_string (next_tcode, verbose); break;
+ case 'L': result = language_to_string (next_lang); break;
+ case 'O': result = op_to_string (next_tcode); break;
+ case 'P': result = parm_to_string (next_int); break;
+ case 'Q': result = assop_to_string (next_tcode); break;
case 'T': result = type_to_string (next_tree, verbose); break;
case 'V': result = cv_to_string (next_tree, verbose); break;
-
+
default:
- return 0;
+ return false;
}
- output_add_string (buffer, result);
- return 1;
+ pp_base_string (pp, result);
+ if (set_locus && t != NULL)
+ *text->locus = location_of (t);
+ return true;
#undef next_tree
#undef next_tcode
#undef next_lang
#undef next_int
}
+\f
+/* Callback from cpp_error for PFILE to print diagnostics arising from
+ interpreting strings. The diagnostic is of type LEVEL; MSG is the
+ translated message and AP the arguments. */
-static void
-print_integer (buffer, i)
- output_buffer *buffer;
- HOST_WIDE_INT i;
-{
- sprintf (digit_buffer, HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT) i);
- output_add_string (buffer, digit_buffer);
-}
-
-static void
-print_non_consecutive_character (buffer, c)
- output_buffer *buffer;
- int c;
-{
- const char *p = output_last_position (buffer);
-
- if (p != NULL && *p == c)
- output_add_space (buffer);
- output_add_character (buffer, c);
-}
-
-/* These are temporary wrapper functions which handle the historic
- behavior of cp_*_at. */
-
-static tree
-locate_error (msgid, ap)
- const char *msgid;
- va_list ap;
+void
+cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
+ const char *msg, va_list *ap)
{
- tree here = 0, t;
- int plus = 0;
- const char *f;
-
- for (f = msgid; *f; f++)
+ diagnostic_info diagnostic;
+ diagnostic_t dlevel;
+ switch (level)
{
- plus = 0;
- if (*f == '%')
- {
- f++;
- if (*f == '+')
- f++, plus = 1;
- if (*f == '#')
- f++;
-
- switch (*f)
- {
- /* Just ignore these possibilities. */
- case '%': break;
- case 'd': (void) va_arg (ap, int); break;
- case 's': (void) va_arg (ap, char *); break;
- case 'L': (void) va_arg (ap, enum languages); break;
- case 'C':
- case 'O':
- case 'Q': (void) va_arg (ap, enum tree_code); break;
-
- /* These take a tree, which may be where the error is
- located. */
- case 'A':
- case 'D':
- case 'E':
- case 'F':
- case 'P':
- case 'T':
- case 'V':
- t = va_arg (ap, tree);
- if (!here || plus)
- here = t;
- break;
-
- default:
- errorcount = 0; /* damn ICE suppression */
- internal_error ("unexpected letter `%c' in locate_error\n", *f);
- }
- }
+ case CPP_DL_WARNING:
+ case CPP_DL_WARNING_SYSHDR:
+ dlevel = DK_WARNING;
+ break;
+ case CPP_DL_PEDWARN:
+ dlevel = DK_PEDWARN;
+ break;
+ case CPP_DL_ERROR:
+ dlevel = DK_ERROR;
+ break;
+ case CPP_DL_ICE:
+ dlevel = DK_ICE;
+ break;
+ default:
+ gcc_unreachable ();
}
-
- if (here == 0)
- here = va_arg (ap, tree);
-
- return here;
-}
-
-
-void
-cp_error_at VPARAMS ((const char *msgid, ...))
-{
- tree here;
- diagnostic_context dc;
-
- VA_OPEN (ap, msgid);
- VA_FIXEDARG (ap, const char *, msgid);
- here = locate_error (msgid, ap);
- VA_CLOSE (ap);
-
- VA_OPEN (ap, msgid);
- VA_FIXEDARG (ap, const char *, msgid);
-
- set_diagnostic_context (&dc, msgid, &ap,
- cp_file_of (here),
- cp_line_of (here), /* warning = */ 0);
- report_diagnostic (&dc);
- VA_CLOSE (ap);
+ diagnostic_set_info_translated (&diagnostic, msg, ap,
+ input_location, dlevel);
+ report_diagnostic (&diagnostic);
}
+/* Warn about the use of C++0x features when appropriate. */
void
-cp_warning_at VPARAMS ((const char *msgid, ...))
+maybe_warn_cpp0x (const char* str)
{
- tree here;
- diagnostic_context dc;
-
- VA_OPEN (ap, msgid);
- VA_FIXEDARG (ap, const char *, msgid);
- here = locate_error (msgid, ap);
- VA_CLOSE (ap);
-
- VA_OPEN (ap, msgid);
- VA_FIXEDARG (ap, const char *, msgid);
-
- set_diagnostic_context (&dc, msgid, &ap,
- cp_file_of (here),
- cp_line_of (here), /* warning = */ 1);
- report_diagnostic (&dc);
- VA_CLOSE (ap);
+ if ((cxx_dialect == cxx98) && !in_system_header)
+ /* We really want to suppress this warning in system headers,
+ because libstdc++ uses variadic templates even when we aren't
+ in C++0x mode. */
+ pedwarn (input_location, 0, "%s only available with -std=c++0x or -std=gnu++0x", str);
}
+/* Warn about the use of variadic templates when appropriate. */
void
-cp_pedwarn_at VPARAMS ((const char *msgid, ...))
+maybe_warn_variadic_templates (void)
{
- tree here;
- diagnostic_context dc;
-
- VA_OPEN (ap, msgid);
- VA_FIXEDARG (ap, const char *, msgid);
- here = locate_error (msgid, ap);
- VA_CLOSE (ap);
-
- VA_OPEN (ap, msgid);
- VA_FIXEDARG (ap, const char *, msgid);
-
- set_diagnostic_context (&dc, msgid, &ap,
- cp_file_of (here),
- cp_line_of (here),
- /* warning = */ !flag_pedantic_errors);
- report_diagnostic (&dc);
- VA_CLOSE (ap);
+ maybe_warn_cpp0x ("variadic templates");
}
projects / msp430-gcc.git / blobdiff