1996-09-18 05:35:50 +00:00
|
|
|
|
/* Call-backs for C++ error reporting.
|
|
|
|
|
This code is non-reentrant.
|
2004-07-28 03:11:36 +00:00
|
|
|
|
Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002,
|
2007-05-19 01:19:51 +00:00
|
|
|
|
2003, 2004, 2005 Free Software Foundation, Inc.
|
2004-07-28 03:11:36 +00:00
|
|
|
|
This file is part of GCC.
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
GCC is free software; you can redistribute it and/or modify
|
1996-09-18 05:35:50 +00:00
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
|
|
|
any later version.
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
GCC is distributed in the hope that it will be useful,
|
1996-09-18 05:35:50 +00:00
|
|
|
|
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
|
2004-07-28 03:11:36 +00:00
|
|
|
|
along with GCC; see the file COPYING. If not, write to
|
2007-05-19 01:19:51 +00:00
|
|
|
|
the Free Software Foundation, 51 Franklin Street, Fifth Floor,
|
|
|
|
|
Boston, MA 02110-1301, USA. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
#include "config.h"
|
1999-08-26 09:30:50 +00:00
|
|
|
|
#include "system.h"
|
2004-07-28 03:11:36 +00:00
|
|
|
|
#include "coretypes.h"
|
|
|
|
|
#include "tm.h"
|
1996-09-18 05:35:50 +00:00
|
|
|
|
#include "tree.h"
|
|
|
|
|
#include "cp-tree.h"
|
2002-02-01 18:16:02 +00:00
|
|
|
|
#include "real.h"
|
1999-08-26 09:30:50 +00:00
|
|
|
|
#include "toplev.h"
|
2002-02-01 18:16:02 +00:00
|
|
|
|
#include "flags.h"
|
|
|
|
|
#include "diagnostic.h"
|
2003-07-11 03:40:53 +00:00
|
|
|
|
#include "langhooks-def.h"
|
2004-07-28 03:11:36 +00:00
|
|
|
|
#include "cxx-pretty-print.h"
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
#define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* 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. */
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static cxx_pretty_printer scratch_pretty_printer;
|
|
|
|
|
#define cxx_pp (&scratch_pretty_printer)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
# define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
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);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
static void dump_type_prefix (tree, int);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void dump_type_suffix (tree, int);
|
|
|
|
|
static void dump_function_name (tree, int);
|
|
|
|
|
static void dump_expr_list (tree, int);
|
|
|
|
|
static void dump_global_iord (tree);
|
|
|
|
|
static 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 *,
|
2007-05-19 01:19:51 +00:00
|
|
|
|
tree, location_t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
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 *);
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
static bool cp_printer (pretty_printer *, text_info *, const char *,
|
|
|
|
|
int, bool, bool, bool);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static location_t location_of (tree);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
init_error (void)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
diagnostic_starter (global_dc) = cp_diagnostic_starter;
|
|
|
|
|
diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer;
|
|
|
|
|
diagnostic_format_decoder (global_dc) = cp_printer;
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_construct (pp_base (cxx_pp), NULL, 0);
|
|
|
|
|
pp_cxx_pretty_printer_init (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Dump a scope, if deemed necessary. */
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_scope (tree scope, int flags)
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF));
|
|
|
|
|
|
|
|
|
|
if (scope == NULL_TREE)
|
|
|
|
|
return;
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (TREE_CODE (scope) == NAMESPACE_DECL)
|
|
|
|
|
{
|
|
|
|
|
if (scope != global_namespace)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
dump_decl (scope, f);
|
|
|
|
|
pp_cxx_colon_colon (cxx_pp);
|
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
else if (AGGREGATE_TYPE_P (scope))
|
|
|
|
|
{
|
|
|
|
|
dump_type (scope, f);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_colon_colon (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
|
|
|
|
|
{
|
|
|
|
|
dump_function_decl (scope, f);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_colon_colon (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Dump the template ARGument under control of FLAGS. */
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_template_argument (tree arg, int flags)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
|
|
|
|
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);
|
|
|
|
|
}
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Dump a template-argument-list ARGS (always a TREE_VEC) under control
|
|
|
|
|
of FLAGS. */
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_template_argument_list (tree args, int flags)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
|
|
|
|
int n = TREE_VEC_LENGTH (args);
|
|
|
|
|
int need_comma = 0;
|
|
|
|
|
int i;
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
for (i = 0; i< n; ++i)
|
|
|
|
|
{
|
|
|
|
|
if (need_comma)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_separate_with_comma (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_template_argument (TREE_VEC_ELT (args, i), flags);
|
|
|
|
|
need_comma = 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
|
|
|
|
|
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_template_parameter (tree parm, int flags)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
tree p;
|
|
|
|
|
tree a;
|
|
|
|
|
|
|
|
|
|
if (parm == error_mark_node)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
p = TREE_VALUE (parm);
|
|
|
|
|
a = TREE_PURPOSE (parm);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
if (TREE_CODE (p) == TYPE_DECL)
|
|
|
|
|
{
|
|
|
|
|
if (flags & TFF_DECL_SPECIFIERS)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
pp_cxx_identifier (cxx_pp, "class");
|
|
|
|
|
if (DECL_NAME (p))
|
|
|
|
|
pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
|
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else if (DECL_NAME (p))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
dump_decl (p, flags | TFF_DECL_SPECIFIERS);
|
|
|
|
|
|
|
|
|
|
if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
|
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_whitespace (cxx_pp);
|
|
|
|
|
pp_equal (cxx_pp);
|
|
|
|
|
pp_cxx_whitespace (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_expr (a, flags | TFF_EXPR_IN_PARENS);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Dump, under control of FLAGS, a template-parameter-list binding.
|
|
|
|
|
PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
|
|
|
|
|
TREE_VEC. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_template_bindings (tree parms, tree args)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
|
|
|
|
int need_comma = 0;
|
|
|
|
|
|
|
|
|
|
while (parms)
|
|
|
|
|
{
|
|
|
|
|
tree p = TREE_VALUE (parms);
|
|
|
|
|
int lvl = TMPL_PARMS_DEPTH (parms);
|
|
|
|
|
int arg_idx = 0;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
|
|
|
|
|
{
|
|
|
|
|
tree arg = NULL_TREE;
|
|
|
|
|
|
|
|
|
|
/* Don't crash if we had an invalid argument list. */
|
|
|
|
|
if (TMPL_ARGS_DEPTH (args) >= lvl)
|
|
|
|
|
{
|
|
|
|
|
tree lvl_args = TMPL_ARGS_LEVEL (args, lvl);
|
|
|
|
|
if (NUM_TMPL_ARGS (lvl_args) > arg_idx)
|
|
|
|
|
arg = TREE_VEC_ELT (lvl_args, arg_idx);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (need_comma)
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_separate_with_comma (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_whitespace (cxx_pp);
|
|
|
|
|
pp_equal (cxx_pp);
|
|
|
|
|
pp_cxx_whitespace (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (arg)
|
|
|
|
|
dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
|
|
|
|
|
else
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_identifier (cxx_pp, "<missing>");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
++arg_idx;
|
|
|
|
|
need_comma = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
parms = TREE_CHAIN (parms);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2003-07-11 03:40:53 +00:00
|
|
|
|
/* Dump a human-readable equivalent of TYPE. FLAGS controls the
|
|
|
|
|
format. */
|
1999-08-26 09:30:50 +00:00
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_type (tree t, int flags)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
if (t == NULL_TREE)
|
|
|
|
|
return;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
if (TYPE_PTRMEMFUNC_P (t))
|
|
|
|
|
goto offset_type;
|
|
|
|
|
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case UNKNOWN_TYPE:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_identifier (cxx_pp, "<unresolved overloaded function type>");
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TREE_LIST:
|
1999-10-16 06:09:09 +00:00
|
|
|
|
/* A list of function parms. */
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_parameters (t, flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case IDENTIFIER_NODE:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_tree_identifier (cxx_pp, t);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
case TREE_BINFO:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (BINFO_TYPE (t), flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case RECORD_TYPE:
|
|
|
|
|
case UNION_TYPE:
|
|
|
|
|
case ENUMERAL_TYPE:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_aggr_type (t, flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TYPE_DECL:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (flags & TFF_CHASE_TYPEDEF)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
dump_type (DECL_ORIGINAL_TYPE (t)
|
|
|
|
|
? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2004-07-28 03:11:36 +00:00
|
|
|
|
/* Else fall through. */
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
1999-08-26 09:30:50 +00:00
|
|
|
|
case TEMPLATE_DECL:
|
1999-10-16 06:09:09 +00:00
|
|
|
|
case NAMESPACE_DECL:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case INTEGER_TYPE:
|
|
|
|
|
case REAL_TYPE:
|
|
|
|
|
case VOID_TYPE:
|
|
|
|
|
case BOOLEAN_TYPE:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case COMPLEX_TYPE:
|
|
|
|
|
case VECTOR_TYPE:
|
|
|
|
|
pp_type_specifier_seq (cxx_pp, t);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
1999-08-26 09:30:50 +00:00
|
|
|
|
case TEMPLATE_TEMPLATE_PARM:
|
2003-07-11 03:40:53 +00:00
|
|
|
|
/* For parameters inside template signature. */
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (TYPE_IDENTIFIER (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
|
1999-08-26 09:30:50 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_canonical_template_parameter (cxx_pp, t);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BOUND_TEMPLATE_TEMPLATE_PARM:
|
|
|
|
|
{
|
|
|
|
|
tree args = TYPE_TI_ARGS (t);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
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);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
1999-08-26 09:30:50 +00:00
|
|
|
|
case TEMPLATE_TYPE_PARM:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_cv_qualifier_seq (cxx_pp, t);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
if (TYPE_IDENTIFIER (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
|
1999-08-26 09:30:50 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_canonical_template_parameter
|
|
|
|
|
(cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* This is not always necessary for pointers and such, but doing this
|
|
|
|
|
reduces code size. */
|
|
|
|
|
case ARRAY_TYPE:
|
|
|
|
|
case POINTER_TYPE:
|
2014-01-05 00:43:28 +00:00
|
|
|
|
/* APPLE LOCAL blocks 6040305 */
|
|
|
|
|
case BLOCK_POINTER_TYPE:
|
1996-09-18 05:35:50 +00:00
|
|
|
|
case REFERENCE_TYPE:
|
|
|
|
|
case OFFSET_TYPE:
|
|
|
|
|
offset_type:
|
|
|
|
|
case FUNCTION_TYPE:
|
|
|
|
|
case METHOD_TYPE:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
|
|
|
|
dump_type_prefix (t, flags);
|
|
|
|
|
dump_type_suffix (t, flags);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
break;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
1999-08-26 09:30:50 +00:00
|
|
|
|
case TYPENAME_TYPE:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
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");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_typename (t, flags);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case UNBOUND_CLASS_TEMPLATE:
|
|
|
|
|
dump_type (TYPE_CONTEXT (t), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_colon_colon (cxx_pp);
|
|
|
|
|
pp_cxx_identifier (cxx_pp, "template");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (DECL_NAME (TYPE_NAME (t)), flags);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TYPEOF_TYPE:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
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);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_unsupported_tree (cxx_pp, t);
|
2003-07-11 03:40:53 +00:00
|
|
|
|
/* Fall through to error. */
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
case ERROR_MARK:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_identifier (cxx_pp, "<type error>");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
break;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Dump a TYPENAME_TYPE. We need to notice when the context is itself
|
|
|
|
|
a TYPENAME_TYPE. */
|
|
|
|
|
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_typename (tree t, int flags)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
|
|
|
|
tree ctx = TYPE_CONTEXT (t);
|
|
|
|
|
|
|
|
|
|
if (TREE_CODE (ctx) == TYPENAME_TYPE)
|
|
|
|
|
dump_typename (ctx, flags);
|
|
|
|
|
else
|
|
|
|
|
dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_colon_colon (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return the name of the supplied aggregate, or enumeral type. */
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
const char *
|
|
|
|
|
class_key_or_enum_as_string (tree t)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
if (TREE_CODE (t) == ENUMERAL_TYPE)
|
|
|
|
|
return "enum";
|
|
|
|
|
else if (TREE_CODE (t) == UNION_TYPE)
|
|
|
|
|
return "union";
|
|
|
|
|
else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
|
|
|
|
|
return "class";
|
|
|
|
|
else
|
|
|
|
|
return "struct";
|
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Print out a class declaration T under the control of FLAGS,
|
|
|
|
|
in the form `class foo'. */
|
1999-08-26 09:30:50 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_aggr_type (tree t, int flags)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
tree name;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
const char *variety = class_key_or_enum_as_string (t);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
int typdef = 0;
|
|
|
|
|
int tmplate = 0;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_cv_qualifier_seq (cxx_pp, t);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (flags & TFF_CLASS_KEY_OR_ENUM)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, variety);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (flags & TFF_CHASE_TYPEDEF)
|
|
|
|
|
t = TYPE_MAIN_VARIANT (t);
|
|
|
|
|
|
|
|
|
|
name = TYPE_NAME (t);
|
|
|
|
|
|
|
|
|
|
if (name)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
typdef = !DECL_ARTIFICIAL (name);
|
|
|
|
|
tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
|
2007-05-19 01:19:51 +00:00
|
|
|
|
&& TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
|
|
|
|
|
&& (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
|
|
|
|
|
|| PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
|
|
|
|
|
if (tmplate)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
/* 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;
|
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
name = DECL_NAME (name);
|
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
if (name == 0 || ANON_AGGRNAME_P (name))
|
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (flags & TFF_CLASS_KEY_OR_ENUM)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_identifier (cxx_pp, "<anonymous>");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_tree_identifier (cxx_pp, name);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (tmplate)
|
|
|
|
|
dump_template_parms (TYPE_TEMPLATE_INFO (t),
|
2007-05-19 01:19:51 +00:00
|
|
|
|
!CLASSTYPE_USE_TEMPLATE (t),
|
|
|
|
|
flags & ~TFF_TEMPLATE_HEADER);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Dump into the obstack the initial part of the output for a given type.
|
|
|
|
|
This is necessary when dealing with things like functions returning
|
|
|
|
|
functions. Examples:
|
|
|
|
|
|
|
|
|
|
return type of `int (* fee ())()': pointer -> function -> int. Both
|
|
|
|
|
pointer (and reference and offset) and function (and member) types must
|
|
|
|
|
deal with prefix and suffix.
|
|
|
|
|
|
|
|
|
|
Arrays must also do this for DECL nodes, like int a[], and for things like
|
2007-05-19 01:19:51 +00:00
|
|
|
|
int *[]&. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_type_prefix (tree t, int flags)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
if (TYPE_PTRMEMFUNC_P (t))
|
|
|
|
|
{
|
|
|
|
|
t = TYPE_PTRMEMFUNC_FN_TYPE (t);
|
|
|
|
|
goto offset_type;
|
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case POINTER_TYPE:
|
2014-01-05 00:43:28 +00:00
|
|
|
|
/* APPLE LOCAL blocks 6040305 */
|
|
|
|
|
case BLOCK_POINTER_TYPE:
|
1999-10-16 06:09:09 +00:00
|
|
|
|
case REFERENCE_TYPE:
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
tree sub = TREE_TYPE (t);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_type_prefix (sub, flags);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
if (TREE_CODE (sub) == ARRAY_TYPE)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_whitespace (cxx_pp);
|
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
2014-01-05 00:43:28 +00:00
|
|
|
|
/* APPLE LOCAL begin blocks 6040305 */
|
|
|
|
|
pp_character (cxx_pp, "&*^"[(TREE_CODE (t) == POINTER_TYPE)
|
|
|
|
|
+ (TREE_CODE (t) == BLOCK_POINTER_TYPE)*2]);
|
|
|
|
|
/* APPLE LOCAL end blocks 6040305 */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_base (cxx_pp)->padding = pp_before;
|
|
|
|
|
pp_cxx_cv_qualifier_seq (cxx_pp, t);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case OFFSET_TYPE:
|
|
|
|
|
offset_type:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_type_prefix (TREE_TYPE (t), flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
|
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_maybe_space (cxx_pp);
|
|
|
|
|
if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
|
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (TYPE_OFFSET_BASETYPE (t), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_colon_colon (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_star (cxx_pp);
|
|
|
|
|
pp_cxx_cv_qualifier_seq (cxx_pp, t);
|
|
|
|
|
pp_base (cxx_pp)->padding = pp_before;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* Can only be reached through function pointer -- this would not be
|
2007-05-19 01:19:51 +00:00
|
|
|
|
correct if FUNCTION_DECLs used it. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
case FUNCTION_TYPE:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_type_prefix (TREE_TYPE (t), flags);
|
|
|
|
|
pp_maybe_space (cxx_pp);
|
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case METHOD_TYPE:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_type_prefix (TREE_TYPE (t), flags);
|
|
|
|
|
pp_maybe_space (cxx_pp);
|
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_colon_colon (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case ARRAY_TYPE:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_type_prefix (TREE_TYPE (t), flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case ENUMERAL_TYPE:
|
|
|
|
|
case IDENTIFIER_NODE:
|
|
|
|
|
case INTEGER_TYPE:
|
|
|
|
|
case BOOLEAN_TYPE:
|
|
|
|
|
case REAL_TYPE:
|
|
|
|
|
case RECORD_TYPE:
|
|
|
|
|
case TEMPLATE_TYPE_PARM:
|
1999-08-26 09:30:50 +00:00
|
|
|
|
case TEMPLATE_TEMPLATE_PARM:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
case BOUND_TEMPLATE_TEMPLATE_PARM:
|
1996-09-18 05:35:50 +00:00
|
|
|
|
case TREE_LIST:
|
|
|
|
|
case TYPE_DECL:
|
|
|
|
|
case TREE_VEC:
|
|
|
|
|
case UNION_TYPE:
|
|
|
|
|
case UNKNOWN_TYPE:
|
|
|
|
|
case VOID_TYPE:
|
1999-08-26 09:30:50 +00:00
|
|
|
|
case TYPENAME_TYPE:
|
|
|
|
|
case COMPLEX_TYPE:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
case VECTOR_TYPE:
|
2003-07-11 03:40:53 +00:00
|
|
|
|
case TYPEOF_TYPE:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (t, flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_base (cxx_pp)->padding = pp_before;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
default:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_unsupported_tree (cxx_pp, t);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* fall through. */
|
|
|
|
|
case ERROR_MARK:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_identifier (cxx_pp, "<typeprefixerror>");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
break;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Dump the suffix of type T, under control of FLAGS. This is the part
|
|
|
|
|
which appears after the identifier (or function parms). */
|
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_type_suffix (tree t, int flags)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
if (TYPE_PTRMEMFUNC_P (t))
|
|
|
|
|
t = TYPE_PTRMEMFUNC_FN_TYPE (t);
|
|
|
|
|
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case POINTER_TYPE:
|
2014-01-05 00:43:28 +00:00
|
|
|
|
/* APPLE LOCAL blocks 6040305 */
|
|
|
|
|
case BLOCK_POINTER_TYPE:
|
1996-09-18 05:35:50 +00:00
|
|
|
|
case REFERENCE_TYPE:
|
|
|
|
|
case OFFSET_TYPE:
|
|
|
|
|
if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type_suffix (TREE_TYPE (t), flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
/* Can only be reached through function pointer. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
case FUNCTION_TYPE:
|
|
|
|
|
case METHOD_TYPE:
|
|
|
|
|
{
|
|
|
|
|
tree arg;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
arg = TYPE_ARG_TYPES (t);
|
|
|
|
|
if (TREE_CODE (t) == METHOD_TYPE)
|
|
|
|
|
arg = TREE_CHAIN (arg);
|
|
|
|
|
|
1999-10-16 06:09:09 +00:00
|
|
|
|
/* Function pointers don't have default args. Not in standard C++,
|
|
|
|
|
anyway; they may in g++, but we'll just pretend otherwise. */
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
if (TREE_CODE (t) == METHOD_TYPE)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_cv_qualifier_seq
|
|
|
|
|
(cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
|
|
|
|
|
else
|
|
|
|
|
pp_cxx_cv_qualifier_seq(cxx_pp, t);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
|
|
|
|
|
dump_type_suffix (TREE_TYPE (t), flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case ARRAY_TYPE:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_maybe_space (cxx_pp);
|
|
|
|
|
pp_cxx_left_bracket (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
if (TYPE_DOMAIN (t))
|
1999-08-26 09:30:50 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0))
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_wide_integer
|
2007-05-19 01:19:51 +00:00
|
|
|
|
(cxx_pp, tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0),
|
2007-05-19 01:19:51 +00:00
|
|
|
|
flags & ~TFF_EXPR_IN_PARENS);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
else
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (fold (cp_build_binary_op
|
1999-08-26 09:30:50 +00:00
|
|
|
|
(PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)),
|
2002-02-01 18:16:02 +00:00
|
|
|
|
integer_one_node)),
|
2007-05-19 01:19:51 +00:00
|
|
|
|
flags & ~TFF_EXPR_IN_PARENS);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
}
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_bracket (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type_suffix (TREE_TYPE (t), flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
case ENUMERAL_TYPE:
|
|
|
|
|
case IDENTIFIER_NODE:
|
|
|
|
|
case INTEGER_TYPE:
|
|
|
|
|
case BOOLEAN_TYPE:
|
|
|
|
|
case REAL_TYPE:
|
|
|
|
|
case RECORD_TYPE:
|
|
|
|
|
case TEMPLATE_TYPE_PARM:
|
1999-08-26 09:30:50 +00:00
|
|
|
|
case TEMPLATE_TEMPLATE_PARM:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
case BOUND_TEMPLATE_TEMPLATE_PARM:
|
1996-09-18 05:35:50 +00:00
|
|
|
|
case TREE_LIST:
|
|
|
|
|
case TYPE_DECL:
|
|
|
|
|
case TREE_VEC:
|
|
|
|
|
case UNION_TYPE:
|
|
|
|
|
case UNKNOWN_TYPE:
|
|
|
|
|
case VOID_TYPE:
|
1999-08-26 09:30:50 +00:00
|
|
|
|
case TYPENAME_TYPE:
|
|
|
|
|
case COMPLEX_TYPE:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
case VECTOR_TYPE:
|
2003-07-11 03:40:53 +00:00
|
|
|
|
case TYPEOF_TYPE:
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_unsupported_tree (cxx_pp, t);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
case ERROR_MARK:
|
|
|
|
|
/* Don't mark it here, we should have already done in
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_type_prefix. */
|
2002-02-01 18:16:02 +00:00
|
|
|
|
break;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1999-08-26 09:30:50 +00:00
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_global_iord (tree t)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
const char *p = NULL;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (DECL_GLOBAL_CTOR_P (t))
|
|
|
|
|
p = "initializers";
|
|
|
|
|
else if (DECL_GLOBAL_DTOR_P (t))
|
|
|
|
|
p = "destructors";
|
1996-09-18 05:35:50 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
gcc_unreachable ();
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
1999-08-26 09:30:50 +00:00
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_simple_decl (tree t, tree type, int flags)
|
1999-08-26 09:30:50 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (flags & TFF_DECL_SPECIFIERS)
|
1999-08-26 09:30:50 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_type_prefix (type, flags);
|
|
|
|
|
pp_maybe_space (cxx_pp);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (!DECL_INITIAL (t) || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX)
|
|
|
|
|
dump_scope (CP_DECL_CONTEXT (t), flags);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
if (DECL_NAME (t))
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_decl (DECL_NAME (t), flags);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
else
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_identifier (cxx_pp, "<anonymous>");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (flags & TFF_DECL_SPECIFIERS)
|
|
|
|
|
dump_type_suffix (type, flags);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Dump a human readable string for the decl T under control of FLAGS. */
|
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_decl (tree t, int flags)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
if (t == NULL_TREE)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case TYPE_DECL:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
/* 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");
|
1999-08-26 09:30:50 +00:00
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_type (TREE_TYPE (t), flags);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (flags & TFF_DECL_SPECIFIERS)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, "typedef");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
|
|
|
|
|
? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
|
2007-05-19 01:19:51 +00:00
|
|
|
|
flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
case VAR_DECL:
|
|
|
|
|
if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
|
|
|
|
|
{
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_string (cxx_pp, "vtable for ");
|
2007-05-19 01:19:51 +00:00
|
|
|
|
gcc_assert (TYPE_P (DECL_CONTEXT (t)));
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (DECL_CONTEXT (t), flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
2004-07-28 03:11:36 +00:00
|
|
|
|
/* Else fall through. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
case FIELD_DECL:
|
|
|
|
|
case PARM_DECL:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_simple_decl (t, TREE_TYPE (t), flags);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case RESULT_DECL:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_string (cxx_pp, "<return value> ");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_simple_decl (t, TREE_TYPE (t), flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case NAMESPACE_DECL:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
if (flags & TFF_DECL_SPECIFIERS)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_declaration (cxx_pp, t);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
dump_scope (CP_DECL_CONTEXT (t), flags);
|
|
|
|
|
if (DECL_NAME (t) == NULL_TREE)
|
|
|
|
|
pp_identifier (cxx_pp, "<unnamed>");
|
|
|
|
|
else
|
|
|
|
|
pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
|
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
1999-08-26 09:30:50 +00:00
|
|
|
|
case SCOPE_REF:
|
2005-06-03 03:28:44 +00:00
|
|
|
|
pp_expression (cxx_pp, t);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
break;
|
1999-08-26 09:30:50 +00:00
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
case ARRAY_REF:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_decl (TREE_OPERAND (t, 0), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_bracket (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_decl (TREE_OPERAND (t, 1), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_bracket (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* So that we can do dump_decl on an aggr type. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
case RECORD_TYPE:
|
|
|
|
|
case UNION_TYPE:
|
|
|
|
|
case ENUMERAL_TYPE:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (t, flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case BIT_NOT_EXPR:
|
|
|
|
|
/* This is a pseudo destructor call which has not been folded into
|
2007-05-19 01:19:51 +00:00
|
|
|
|
a PSEUDO_DTOR_EXPR yet. */
|
|
|
|
|
pp_cxx_complement (cxx_pp);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_type (TREE_OPERAND (t, 0), flags);
|
|
|
|
|
break;
|
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
case TYPE_EXPR:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
gcc_unreachable ();
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* These special cases are duplicated here so that other functions
|
2002-02-01 18:16:02 +00:00
|
|
|
|
can feed identifiers to error and get them demangled properly. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
case IDENTIFIER_NODE:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (IDENTIFIER_TYPENAME_P (t))
|
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, "operator");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Not exactly IDENTIFIER_TYPE_VALUE. */
|
|
|
|
|
dump_type (TREE_TYPE (t), flags);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_tree_identifier (cxx_pp, t);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
1999-10-16 06:09:09 +00:00
|
|
|
|
case OVERLOAD:
|
2003-02-10 05:41:50 +00:00
|
|
|
|
if (OVL_CHAIN (t))
|
|
|
|
|
{
|
|
|
|
|
t = OVL_CURRENT (t);
|
|
|
|
|
if (DECL_CLASS_SCOPE_P (t))
|
|
|
|
|
{
|
|
|
|
|
dump_type (DECL_CONTEXT (t), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_colon_colon (cxx_pp);
|
2003-02-10 05:41:50 +00:00
|
|
|
|
}
|
|
|
|
|
else if (DECL_CONTEXT (t))
|
|
|
|
|
{
|
|
|
|
|
dump_decl (DECL_CONTEXT (t), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_colon_colon (cxx_pp);
|
2003-02-10 05:41:50 +00:00
|
|
|
|
}
|
|
|
|
|
dump_decl (DECL_NAME (t), flags);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2003-02-10 05:41:50 +00:00
|
|
|
|
/* If there's only one function, just treat it like an ordinary
|
|
|
|
|
FUNCTION_DECL. */
|
1999-10-16 06:09:09 +00:00
|
|
|
|
t = OVL_CURRENT (t);
|
|
|
|
|
/* Fall through. */
|
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
case FUNCTION_DECL:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (! DECL_LANG_SPECIFIC (t))
|
|
|
|
|
pp_identifier (cxx_pp, "<built-in>");
|
|
|
|
|
else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_global_iord (t);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_function_decl (t, flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TEMPLATE_DECL:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_template_decl (t, flags);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TEMPLATE_ID_EXPR:
|
|
|
|
|
{
|
|
|
|
|
tree name = TREE_OPERAND (t, 0);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
1999-08-26 09:30:50 +00:00
|
|
|
|
if (is_overloaded_fn (name))
|
|
|
|
|
name = DECL_NAME (get_first_fn (name));
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_decl (name, flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_begin_template_argument_list (cxx_pp);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
if (TREE_OPERAND (t, 1))
|
|
|
|
|
dump_template_argument_list (TREE_OPERAND (t, 1), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_end_template_argument_list (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LABEL_DECL:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case CONST_DECL:
|
1999-08-26 09:30:50 +00:00
|
|
|
|
if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
|
|
|
|
|
|| (DECL_INITIAL (t) &&
|
|
|
|
|
TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_simple_decl (t, TREE_TYPE (t), flags);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
else if (DECL_NAME (t))
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_decl (DECL_NAME (t), flags);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
else if (DECL_INITIAL (t))
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
else
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_identifier (cxx_pp, "<enumerator>");
|
1999-08-26 09:30:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case USING_DECL:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, "using");
|
|
|
|
|
dump_type (USING_DECL_SCOPE (t), flags);
|
|
|
|
|
pp_cxx_colon_colon (cxx_pp);
|
2003-07-11 03:40:53 +00:00
|
|
|
|
dump_decl (DECL_NAME (t), flags);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BASELINK:
|
|
|
|
|
dump_decl (BASELINK_FUNCTIONS (t), flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case NON_DEPENDENT_EXPR:
|
|
|
|
|
dump_expr (t, flags);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TEMPLATE_TYPE_PARM:
|
|
|
|
|
if (flags & TFF_DECL_SPECIFIERS)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_declaration (cxx_pp, t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_type_id (cxx_pp, t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
break;
|
|
|
|
|
|
2011-03-10 13:59:17 +00:00
|
|
|
|
case UNBOUND_CLASS_TEMPLATE:
|
|
|
|
|
dump_type (t, flags);
|
|
|
|
|
break;
|
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
default:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_unsupported_tree (cxx_pp, t);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
/* Fall through to error. */
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
case ERROR_MARK:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_identifier (cxx_pp, "<declaration error>");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Dump a template declaration T under control of FLAGS. This means the
|
|
|
|
|
'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
|
|
|
|
|
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_template_decl (tree t, int flags)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
|
|
|
|
tree orig_parms = DECL_TEMPLATE_PARMS (t);
|
|
|
|
|
tree parms;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if (flags & TFF_TEMPLATE_HEADER)
|
|
|
|
|
{
|
|
|
|
|
for (parms = orig_parms = nreverse (orig_parms);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
parms;
|
|
|
|
|
parms = TREE_CHAIN (parms))
|
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
int len = TREE_VEC_LENGTH (inner_parms);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, "template");
|
|
|
|
|
pp_cxx_begin_template_argument_list (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* If we've shown the template prefix, we'd better show the
|
|
|
|
|
parameters' and decl's type too. */
|
|
|
|
|
flags |= TFF_DECL_SPECIFIERS;
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
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);
|
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
nreverse(orig_parms);
|
|
|
|
|
|
|
|
|
|
if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
|
2003-07-11 03:40:53 +00:00
|
|
|
|
/* Say `template<arg> class TT' not just `template<arg> TT'. */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, "class");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
|
|
|
|
|
dump_type (TREE_TYPE (t),
|
2007-05-19 01:19:51 +00:00
|
|
|
|
((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
|
|
|
|
|
| (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
|
|
|
|
|
dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
|
|
|
|
|
else
|
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
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));
|
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1999-10-16 06:09:09 +00:00
|
|
|
|
/* Pretty print a function decl. There are several ways we want to print a
|
2002-02-01 18:16:02 +00:00
|
|
|
|
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
|
2003-07-11 03:40:53 +00:00
|
|
|
|
is %D which doesn't print the throw specs, and %F which does. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_function_decl (tree t, int flags)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
1999-08-26 09:30:50 +00:00
|
|
|
|
tree fntype;
|
|
|
|
|
tree parmtypes;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
tree cname = NULL_TREE;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
tree template_args = NULL_TREE;
|
|
|
|
|
tree template_parms = NULL_TREE;
|
|
|
|
|
int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
1999-08-26 09:30:50 +00:00
|
|
|
|
if (TREE_CODE (t) == TEMPLATE_DECL)
|
|
|
|
|
t = DECL_TEMPLATE_RESULT (t);
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Pretty print template instantiations only. */
|
|
|
|
|
if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t))
|
|
|
|
|
{
|
|
|
|
|
tree tmpl;
|
|
|
|
|
|
|
|
|
|
template_args = DECL_TI_ARGS (t);
|
|
|
|
|
tmpl = most_general_template (t);
|
|
|
|
|
if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
|
|
|
|
|
{
|
|
|
|
|
template_parms = DECL_TEMPLATE_PARMS (tmpl);
|
|
|
|
|
t = tmpl;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1999-08-26 09:30:50 +00:00
|
|
|
|
fntype = TREE_TYPE (t);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
|
1999-10-16 06:09:09 +00:00
|
|
|
|
if (DECL_CLASS_SCOPE_P (t))
|
2002-02-01 18:16:02 +00:00
|
|
|
|
cname = DECL_CONTEXT (t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
/* This is for partially instantiated template methods. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
else if (TREE_CODE (fntype) == METHOD_TYPE)
|
|
|
|
|
cname = TREE_TYPE (TREE_VALUE (parmtypes));
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (!(flags & TFF_DECL_SPECIFIERS))
|
|
|
|
|
/* OK */;
|
|
|
|
|
else if (DECL_STATIC_FUNCTION_P (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, "static");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else if (DECL_VIRTUAL_P (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, "virtual");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* Print the return type? */
|
|
|
|
|
if (show_return)
|
|
|
|
|
show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
&& !DECL_DESTRUCTOR_P (t);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (show_return)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_type_prefix (TREE_TYPE (fntype), flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
1999-10-16 06:09:09 +00:00
|
|
|
|
/* Print the function name. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
if (cname)
|
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (cname, flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_colon_colon (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else
|
|
|
|
|
dump_scope (CP_DECL_CONTEXT (t), flags);
|
|
|
|
|
|
|
|
|
|
dump_function_name (t, flags);
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_parameters (parmtypes, flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (TREE_CODE (fntype) == METHOD_TYPE)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
pp_base (cxx_pp)->padding = pp_before;
|
|
|
|
|
pp_cxx_cv_qualifier_seq
|
|
|
|
|
(cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
|
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (flags & TFF_EXCEPTION_SPECIFICATION)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
pp_base (cxx_pp)->padding = pp_before;
|
|
|
|
|
dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
|
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (show_return)
|
|
|
|
|
dump_type_suffix (TREE_TYPE (fntype), flags);
|
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* If T is a template instantiation, dump the parameter binding. */
|
|
|
|
|
if (template_parms != NULL_TREE && template_args != NULL_TREE)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_whitespace (cxx_pp);
|
|
|
|
|
pp_cxx_left_bracket (cxx_pp);
|
|
|
|
|
pp_cxx_identifier (cxx_pp, "with");
|
|
|
|
|
pp_cxx_whitespace (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_template_bindings (template_parms, template_args);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_bracket (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
1999-10-16 06:09:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Print a parameter list. If this is for a member function, the
|
|
|
|
|
member object ptr (and any other hidden args) should have
|
2003-07-11 03:40:53 +00:00
|
|
|
|
already been removed. */
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_parameters (tree parmtypes, int flags)
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
|
|
|
|
int first;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
|
|
|
|
for (first = 1; parmtypes != void_list_node;
|
|
|
|
|
parmtypes = TREE_CHAIN (parmtypes))
|
|
|
|
|
{
|
|
|
|
|
if (!first)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_separate_with_comma (cxx_pp);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
first = 0;
|
|
|
|
|
if (!parmtypes)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
pp_cxx_identifier (cxx_pp, "...");
|
|
|
|
|
break;
|
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (TREE_VALUE (parmtypes), flags);
|
|
|
|
|
|
|
|
|
|
if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
pp_cxx_whitespace (cxx_pp);
|
|
|
|
|
pp_equal (cxx_pp);
|
|
|
|
|
pp_cxx_whitespace (cxx_pp);
|
|
|
|
|
dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
|
|
|
|
|
}
|
1999-10-16 06:09:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
2003-07-11 03:40:53 +00:00
|
|
|
|
/* Print an exception specification. T is the exception specification. */
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_exception_spec (tree t, int flags)
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
|
|
|
|
if (t)
|
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, "throw");
|
|
|
|
|
pp_cxx_whitespace (cxx_pp);
|
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
if (TREE_VALUE (t) != NULL_TREE)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
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);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Handle the function name for a FUNCTION_DECL node, grokking operators
|
|
|
|
|
and destructors properly. */
|
1999-08-26 09:30:50 +00:00
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_function_name (tree t, int flags)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
tree name = DECL_NAME (t);
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
/* 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;
|
|
|
|
|
}
|
|
|
|
|
|
2003-07-11 03:40:53 +00:00
|
|
|
|
if (TREE_CODE (t) == TEMPLATE_DECL)
|
|
|
|
|
t = DECL_TEMPLATE_RESULT (t);
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Don't let the user see __comp_ctor et al. */
|
|
|
|
|
if (DECL_CONSTRUCTOR_P (t)
|
|
|
|
|
|| DECL_DESTRUCTOR_P (t))
|
|
|
|
|
name = constructor_name (DECL_CONTEXT (t));
|
|
|
|
|
|
1999-10-16 06:09:09 +00:00
|
|
|
|
if (DECL_DESTRUCTOR_P (t))
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_complement (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_decl (name, TFF_PLAIN_IDENTIFIER);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
1999-10-16 06:09:09 +00:00
|
|
|
|
else if (DECL_CONV_FN_P (t))
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
/* This cannot use the hack that the operator's return
|
|
|
|
|
type is stashed off of its name because it may be
|
|
|
|
|
used for error reporting. In the case of conflicting
|
|
|
|
|
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. */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, "operator");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
else if (IDENTIFIER_OPNAME_P (name))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_tree_identifier (cxx_pp, name);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
else
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_decl (name, flags);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (DECL_TEMPLATE_INFO (t)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
&& !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
&& (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|| PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Dump the template parameters from the template info INFO under control of
|
|
|
|
|
FLAGS. PRIMARY indicates whether this is a primary template decl, or
|
|
|
|
|
specialization (partial or complete). For partial specializations we show
|
|
|
|
|
the specialized parameter values. For a primary template we show no
|
|
|
|
|
decoration. */
|
|
|
|
|
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_template_parms (tree info, int primary, int flags)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
|
|
|
|
tree args = info ? TI_ARGS (info) : NULL_TREE;
|
|
|
|
|
|
|
|
|
|
if (primary && flags & TFF_TEMPLATE_NAME)
|
|
|
|
|
return;
|
|
|
|
|
flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_begin_template_argument_list (cxx_pp);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Be careful only to print things when we have them, so as not
|
1999-10-16 06:09:09 +00:00
|
|
|
|
to crash producing error messages. */
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (args && !primary)
|
|
|
|
|
{
|
2004-07-28 03:11:36 +00:00
|
|
|
|
int len, ix;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
|
|
|
|
|
args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
len = TREE_VEC_LENGTH (args);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
for (ix = 0; ix != len; ix++)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
tree arg = TREE_VEC_ELT (args, ix);
|
|
|
|
|
|
|
|
|
|
if (ix)
|
|
|
|
|
pp_separate_with_comma (cxx_pp);
|
|
|
|
|
|
|
|
|
|
if (!arg)
|
|
|
|
|
pp_identifier (cxx_pp, "<template parameter error>");
|
|
|
|
|
else
|
|
|
|
|
dump_template_argument (arg, flags);
|
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
else if (primary)
|
|
|
|
|
{
|
|
|
|
|
tree tpl = TI_TEMPLATE (info);
|
|
|
|
|
tree parms = DECL_TEMPLATE_PARMS (tpl);
|
|
|
|
|
int len, ix;
|
|
|
|
|
|
|
|
|
|
parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
|
|
|
|
|
len = parms ? TREE_VEC_LENGTH (parms) : 0;
|
|
|
|
|
|
|
|
|
|
for (ix = 0; ix != len; ix++)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
tree parm;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (TREE_VEC_ELT (parms, ix) == error_mark_node)
|
|
|
|
|
{
|
|
|
|
|
pp_identifier (cxx_pp, "<template parameter error>");
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
|
|
|
|
|
|
|
|
|
|
if (ix)
|
|
|
|
|
pp_separate_with_comma (cxx_pp);
|
|
|
|
|
|
|
|
|
|
dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
|
|
|
|
|
}
|
1999-08-26 09:30:50 +00:00
|
|
|
|
}
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_end_template_argument_list (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
/* Print out a list of initializers (subr of dump_expr). */
|
1999-08-26 09:30:50 +00:00
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_expr_list (tree l, int flags)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
while (l)
|
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
l = TREE_CHAIN (l);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (l)
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_separate_with_comma (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
/* Print out a vector of initializers (subr of dump_expr). */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
|
|
|
|
|
{
|
|
|
|
|
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));
|
2011-03-10 13:59:17 +00:00
|
|
|
|
HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
|
2011-03-10 13:59:17 +00:00
|
|
|
|
while (index)
|
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
fun = TREE_CHAIN (fun);
|
2011-03-10 13:59:17 +00:00
|
|
|
|
index -= (TARGET_VTABLE_USES_DESCRIPTORS
|
|
|
|
|
? TARGET_VTABLE_USES_DESCRIPTORS : 1);
|
|
|
|
|
}
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
|
|
|
|
return BV_FN (fun);
|
|
|
|
|
}
|
|
|
|
|
|
2003-07-11 03:40:53 +00:00
|
|
|
|
/* Print out an expression E under control of FLAGS. */
|
1999-08-26 09:30:50 +00:00
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_expr (tree t, int flags)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2003-07-11 03:40:53 +00:00
|
|
|
|
if (t == 0)
|
|
|
|
|
return;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case VAR_DECL:
|
|
|
|
|
case PARM_DECL:
|
|
|
|
|
case FIELD_DECL:
|
|
|
|
|
case CONST_DECL:
|
|
|
|
|
case FUNCTION_DECL:
|
1999-08-26 09:30:50 +00:00
|
|
|
|
case TEMPLATE_DECL:
|
|
|
|
|
case NAMESPACE_DECL:
|
2006-08-26 21:29:10 +00:00
|
|
|
|
case LABEL_DECL:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
case OVERLOAD:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case IDENTIFIER_NODE:
|
|
|
|
|
dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case INTEGER_CST:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case REAL_CST:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
case STRING_CST:
|
|
|
|
|
pp_constant (cxx_pp, t);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case THROW_EXPR:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, "throw");
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
1999-10-16 06:09:09 +00:00
|
|
|
|
case PTRMEM_CST:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_ampersand (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (PTRMEM_CST_CLASS (t), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_colon_colon (cxx_pp);
|
|
|
|
|
pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case COMPOUND_EXPR:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_separate_with_comma (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case COND_EXPR:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_string (cxx_pp, " ? ");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_string (cxx_pp, " : ");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SAVE_EXPR:
|
|
|
|
|
if (TREE_HAS_CONSTRUCTOR (t))
|
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, "new");
|
|
|
|
|
pp_cxx_whitespace (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
1999-08-26 09:30:50 +00:00
|
|
|
|
case AGGR_INIT_EXPR:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
|
|
|
|
tree fn = NULL_TREE;
|
|
|
|
|
|
|
|
|
|
if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
|
|
|
|
|
fn = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
|
|
|
|
|
|
|
|
|
|
if (fn && TREE_CODE (fn) == FUNCTION_DECL)
|
|
|
|
|
{
|
|
|
|
|
if (DECL_CONSTRUCTOR_P (fn))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_type (DECL_CONTEXT (fn), flags);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else
|
|
|
|
|
dump_decl (fn, 0);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), 0);
|
|
|
|
|
}
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
if (TREE_OPERAND (t, 1))
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case CALL_EXPR:
|
|
|
|
|
{
|
|
|
|
|
tree fn = TREE_OPERAND (t, 0);
|
|
|
|
|
tree args = TREE_OPERAND (t, 1);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
if (TREE_CODE (fn) == ADDR_EXPR)
|
|
|
|
|
fn = TREE_OPERAND (fn, 0);
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
/* 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);
|
|
|
|
|
|
1999-08-26 09:30:50 +00:00
|
|
|
|
if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
tree ob = TREE_VALUE (args);
|
|
|
|
|
if (TREE_CODE (ob) == ADDR_EXPR)
|
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
|
2011-03-10 13:59:17 +00:00
|
|
|
|
pp_cxx_dot (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
else if (TREE_CODE (ob) != PARM_DECL
|
|
|
|
|
|| strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
|
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
|
2011-03-10 13:59:17 +00:00
|
|
|
|
pp_cxx_arrow (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
args = TREE_CHAIN (args);
|
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr_list (args, flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
1999-08-26 09:30:50 +00:00
|
|
|
|
case NEW_EXPR:
|
|
|
|
|
{
|
|
|
|
|
tree type = TREE_OPERAND (t, 1);
|
2003-07-11 03:40:53 +00:00
|
|
|
|
tree init = TREE_OPERAND (t, 2);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
if (NEW_EXPR_USE_GLOBAL (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_colon_colon (cxx_pp);
|
|
|
|
|
pp_cxx_identifier (cxx_pp, "new");
|
1999-08-26 09:30:50 +00:00
|
|
|
|
if (TREE_OPERAND (t, 0))
|
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr_list (TREE_OPERAND (t, 0), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
|
|
|
|
pp_cxx_whitespace (cxx_pp);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
}
|
|
|
|
|
if (TREE_CODE (type) == ARRAY_REF)
|
|
|
|
|
type = build_cplus_array_type
|
|
|
|
|
(TREE_OPERAND (type, 0),
|
2007-05-19 01:19:51 +00:00
|
|
|
|
build_index_type (fold_build2 (MINUS_EXPR, integer_type_node,
|
2002-02-01 18:16:02 +00:00
|
|
|
|
TREE_OPERAND (type, 1),
|
2007-05-19 01:19:51 +00:00
|
|
|
|
integer_one_node)));
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (type, flags);
|
2003-07-11 03:40:53 +00:00
|
|
|
|
if (init)
|
1999-08-26 09:30:50 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
2003-07-11 03:40:53 +00:00
|
|
|
|
if (TREE_CODE (init) == TREE_LIST)
|
|
|
|
|
dump_expr_list (init, flags);
|
|
|
|
|
else if (init == void_zero_node)
|
|
|
|
|
/* This representation indicates an empty initializer,
|
|
|
|
|
e.g.: "new int()". */
|
|
|
|
|
;
|
|
|
|
|
else
|
|
|
|
|
dump_expr (init, flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TARGET_EXPR:
|
|
|
|
|
/* Note that this only works for G++ target exprs. If somebody
|
|
|
|
|
builds a general TARGET_EXPR, there's no way to represent that
|
|
|
|
|
it initializes anything other that the parameter slot for the
|
|
|
|
|
default argument. Note we may have cleared out the first
|
|
|
|
|
operand in expand_expr, so don't go killing ourselves. */
|
|
|
|
|
if (TREE_OPERAND (t, 1))
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
case INIT_EXPR:
|
1996-09-18 05:35:50 +00:00
|
|
|
|
case MODIFY_EXPR:
|
|
|
|
|
case PLUS_EXPR:
|
|
|
|
|
case MINUS_EXPR:
|
|
|
|
|
case MULT_EXPR:
|
|
|
|
|
case TRUNC_DIV_EXPR:
|
|
|
|
|
case TRUNC_MOD_EXPR:
|
|
|
|
|
case MIN_EXPR:
|
|
|
|
|
case MAX_EXPR:
|
|
|
|
|
case LSHIFT_EXPR:
|
|
|
|
|
case RSHIFT_EXPR:
|
|
|
|
|
case BIT_IOR_EXPR:
|
|
|
|
|
case BIT_XOR_EXPR:
|
|
|
|
|
case BIT_AND_EXPR:
|
|
|
|
|
case TRUTH_ANDIF_EXPR:
|
|
|
|
|
case TRUTH_ORIF_EXPR:
|
|
|
|
|
case LT_EXPR:
|
|
|
|
|
case LE_EXPR:
|
|
|
|
|
case GT_EXPR:
|
|
|
|
|
case GE_EXPR:
|
|
|
|
|
case EQ_EXPR:
|
|
|
|
|
case NE_EXPR:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
case EXACT_DIV_EXPR:
|
|
|
|
|
dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case CEIL_DIV_EXPR:
|
|
|
|
|
case FLOOR_DIV_EXPR:
|
|
|
|
|
case ROUND_DIV_EXPR:
|
2005-06-03 03:28:44 +00:00
|
|
|
|
case RDIV_EXPR:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_binary_op ("/", t, flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case CEIL_MOD_EXPR:
|
|
|
|
|
case FLOOR_MOD_EXPR:
|
|
|
|
|
case ROUND_MOD_EXPR:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_binary_op ("%", t, flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case COMPONENT_REF:
|
|
|
|
|
{
|
|
|
|
|
tree ob = TREE_OPERAND (t, 0);
|
|
|
|
|
if (TREE_CODE (ob) == INDIRECT_REF)
|
|
|
|
|
{
|
|
|
|
|
ob = TREE_OPERAND (ob, 0);
|
|
|
|
|
if (TREE_CODE (ob) != PARM_DECL
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|| (DECL_NAME (ob)
|
|
|
|
|
&& strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_arrow (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_dot (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case ARRAY_REF:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_bracket (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_bracket (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
case UNARY_PLUS_EXPR:
|
|
|
|
|
dump_unary_op ("+", t, flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case ADDR_EXPR:
|
|
|
|
|
if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|| TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
|
|
|
|
|
/* An ADDR_EXPR can have reference type. In that case, we
|
|
|
|
|
shouldn't print the `&' doing so indicates to the user
|
|
|
|
|
that the expression has pointer type. */
|
|
|
|
|
|| (TREE_TYPE (t)
|
|
|
|
|
&& TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
|
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
|
2006-08-26 21:29:10 +00:00
|
|
|
|
else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
|
|
|
|
|
dump_unary_op ("&&", t, flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
else
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_unary_op ("&", t, flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case INDIRECT_REF:
|
|
|
|
|
if (TREE_HAS_CONSTRUCTOR (t))
|
|
|
|
|
{
|
|
|
|
|
t = TREE_OPERAND (t, 0);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
gcc_assert (TREE_CODE (t) == CALL_EXPR);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
1999-08-26 09:30:50 +00:00
|
|
|
|
if (TREE_OPERAND (t,0) != NULL_TREE
|
1999-10-16 06:09:09 +00:00
|
|
|
|
&& TREE_TYPE (TREE_OPERAND (t, 0))
|
1999-08-26 09:30:50 +00:00
|
|
|
|
&& NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
else
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_unary_op ("*", t, flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case NEGATE_EXPR:
|
|
|
|
|
case BIT_NOT_EXPR:
|
|
|
|
|
case TRUTH_NOT_EXPR:
|
|
|
|
|
case PREDECREMENT_EXPR:
|
|
|
|
|
case PREINCREMENT_EXPR:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case POSTDECREMENT_EXPR:
|
|
|
|
|
case POSTINCREMENT_EXPR:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
|
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case NON_LVALUE_EXPR:
|
|
|
|
|
/* FIXME: This is a KLUDGE workaround for a parsing problem. There
|
|
|
|
|
should be another level of INDIRECT_REF so that I don't have to do
|
|
|
|
|
this. */
|
1999-08-26 09:30:50 +00:00
|
|
|
|
if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
tree next = TREE_TYPE (TREE_TYPE (t));
|
|
|
|
|
|
|
|
|
|
while (TREE_CODE (next) == POINTER_TYPE)
|
|
|
|
|
next = TREE_TYPE (next);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
if (TREE_CODE (next) == FUNCTION_TYPE)
|
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (flags & TFF_EXPR_IN_PARENS)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
|
|
|
|
pp_cxx_star (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
|
|
|
|
|
if (flags & TFF_EXPR_IN_PARENS)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
2004-07-28 03:11:36 +00:00
|
|
|
|
/* Else fall through. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case NOP_EXPR:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
case CONVERT_EXPR:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
{
|
|
|
|
|
tree op = TREE_OPERAND (t, 0);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
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)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_type (TREE_TYPE (t), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_expr (op, flags | TFF_EXPR_IN_PARENS);
|
|
|
|
|
if (flags & TFF_EXPR_IN_PARENS)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
dump_expr (op, flags);
|
|
|
|
|
break;
|
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
case CONSTRUCTOR:
|
1999-08-26 09:30:50 +00:00
|
|
|
|
if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
|
|
|
|
|
{
|
2003-07-11 03:40:53 +00:00
|
|
|
|
tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (integer_zerop (idx))
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
|
|
|
|
/* A NULL pointer-to-member constant. */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (TREE_TYPE (t), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
|
|
|
|
pp_character (cxx_pp, '0');
|
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else if (host_integerp (idx, 0))
|
1999-08-26 09:30:50 +00:00
|
|
|
|
{
|
|
|
|
|
tree virtuals;
|
|
|
|
|
unsigned HOST_WIDE_INT n;
|
|
|
|
|
|
|
|
|
|
t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
|
|
|
|
|
t = TYPE_METHOD_BASETYPE (t);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
n = tree_low_cst (idx, 0);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
|
|
|
|
|
/* Map vtable index back one, to allow for the null pointer to
|
|
|
|
|
member. */
|
|
|
|
|
--n;
|
|
|
|
|
|
|
|
|
|
while (n > 0 && virtuals)
|
|
|
|
|
{
|
|
|
|
|
--n;
|
|
|
|
|
virtuals = TREE_CHAIN (virtuals);
|
|
|
|
|
}
|
|
|
|
|
if (virtuals)
|
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (BV_FN (virtuals),
|
2007-05-19 01:19:51 +00:00
|
|
|
|
flags | TFF_EXPR_IN_PARENS);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
|
2004-07-28 03:11:36 +00:00
|
|
|
|
{
|
|
|
|
|
dump_type (TREE_TYPE (t), 0);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
}
|
2003-07-11 03:40:53 +00:00
|
|
|
|
else
|
2004-07-28 03:11:36 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_brace (cxx_pp);
|
|
|
|
|
dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
|
|
|
|
|
pp_cxx_right_brace (cxx_pp);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
}
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case OFFSET_REF:
|
|
|
|
|
{
|
|
|
|
|
tree ob = TREE_OPERAND (t, 0);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
if (is_dummy_object (ob))
|
|
|
|
|
{
|
|
|
|
|
t = TREE_OPERAND (t, 1);
|
|
|
|
|
if (TREE_CODE (t) == FUNCTION_DECL)
|
|
|
|
|
/* A::f */
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (t, flags | TFF_EXPR_IN_PARENS);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
else if (BASELINK_P (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
|
2003-07-11 03:40:53 +00:00
|
|
|
|
flags | TFF_EXPR_IN_PARENS);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
else
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_decl (t, flags);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
1999-10-16 06:09:09 +00:00
|
|
|
|
if (TREE_CODE (ob) == INDIRECT_REF)
|
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_arrow (cxx_pp);
|
|
|
|
|
pp_cxx_star (cxx_pp);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_dot (cxx_pp);
|
|
|
|
|
pp_cxx_star (cxx_pp);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
1999-08-26 09:30:50 +00:00
|
|
|
|
case TEMPLATE_PARM_INDEX:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SCOPE_REF:
|
2005-06-03 03:28:44 +00:00
|
|
|
|
pp_expression (cxx_pp, t);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case CAST_EXPR:
|
|
|
|
|
if (TREE_OPERAND (t, 0) == NULL_TREE
|
|
|
|
|
|| TREE_CHAIN (TREE_OPERAND (t, 0)))
|
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (TREE_TYPE (t), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr_list (TREE_OPERAND (t, 0), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (TREE_TYPE (t), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr_list (TREE_OPERAND (t, 0), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
case STATIC_CAST_EXPR:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, "static_cast");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
goto cast;
|
|
|
|
|
case REINTERPRET_CAST_EXPR:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, "reinterpret_cast");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
goto cast;
|
|
|
|
|
case CONST_CAST_EXPR:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, "const_cast");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
goto cast;
|
|
|
|
|
case DYNAMIC_CAST_EXPR:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, "dynamic_cast");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
cast:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_begin_template_argument_list (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (TREE_TYPE (t), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_end_template_argument_list (cxx_pp);
|
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case ARROW_EXPR:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_arrow (cxx_pp);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SIZEOF_EXPR:
|
|
|
|
|
case ALIGNOF_EXPR:
|
|
|
|
|
if (TREE_CODE (t) == SIZEOF_EXPR)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, "sizeof");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else
|
1999-08-26 09:30:50 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
|
|
|
|
|
pp_cxx_identifier (cxx_pp, "__alignof__");
|
1999-08-26 09:30:50 +00:00
|
|
|
|
}
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_whitespace (cxx_pp);
|
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (TYPE_P (TREE_OPERAND (t, 0)))
|
|
|
|
|
dump_type (TREE_OPERAND (t, 0), flags);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags);
|
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case REALPART_EXPR:
|
|
|
|
|
case IMAGPART_EXPR:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
|
|
|
|
|
pp_cxx_whitespace (cxx_pp);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case DEFAULT_ARG:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_identifier (cxx_pp, "<unparsed>");
|
1999-08-26 09:30:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TRY_CATCH_EXPR:
|
|
|
|
|
case WITH_CLEANUP_EXPR:
|
|
|
|
|
case CLEANUP_POINT_EXPR:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case PSEUDO_DTOR_EXPR:
|
|
|
|
|
dump_expr (TREE_OPERAND (t, 2), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_dot (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (TREE_OPERAND (t, 0), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_colon_colon (cxx_pp);
|
|
|
|
|
pp_cxx_complement (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (TREE_OPERAND (t, 1), flags);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
break;
|
|
|
|
|
|
1999-10-16 06:09:09 +00:00
|
|
|
|
case TEMPLATE_ID_EXPR:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_decl (t, flags);
|
|
|
|
|
break;
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
case BIND_EXPR:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
case STMT_EXPR:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
case STATEMENT_LIST:
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* We don't yet have a way of dumping statements in a
|
|
|
|
|
human-readable format. */
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_string (cxx_pp, "({...})");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LOOP_EXPR:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_string (cxx_pp, "while (1) { ");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_brace (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case EXIT_EXPR:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_string (cxx_pp, "if (");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_string (cxx_pp, ") break; ");
|
1999-10-16 06:09:09 +00:00
|
|
|
|
break;
|
|
|
|
|
|
2003-07-11 03:40:53 +00:00
|
|
|
|
case BASELINK:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
|
2003-07-11 03:40:53 +00:00
|
|
|
|
break;
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case EMPTY_CLASS_EXPR:
|
|
|
|
|
dump_type (TREE_TYPE (t), flags);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case NON_DEPENDENT_EXPR:
|
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags);
|
|
|
|
|
break;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
/* 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:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_unsupported_tree (cxx_pp, t);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
/* fall through to ERROR_MARK... */
|
|
|
|
|
case ERROR_MARK:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_identifier (cxx_pp, "<expression error>");
|
1996-09-18 05:35:50 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_binary_op (const char *opstring, tree t, int flags)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_whitespace (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (opstring)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, opstring);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_identifier (cxx_pp, "<unknown operator>");
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_whitespace (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
dump_unary_op (const char *opstring, tree t, int flags)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (flags & TFF_EXPR_IN_PARENS)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_left_paren (cxx_pp);
|
|
|
|
|
pp_cxx_identifier (cxx_pp, opstring);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
|
|
|
|
|
if (flags & TFF_EXPR_IN_PARENS)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_right_paren (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
static void
|
|
|
|
|
reinit_cxx_pp (void)
|
|
|
|
|
{
|
|
|
|
|
pp_clear_output_area (cxx_pp);
|
|
|
|
|
pp_base (cxx_pp)->padding = pp_none;
|
|
|
|
|
pp_indentation (cxx_pp) = 0;
|
|
|
|
|
pp_needs_newline (cxx_pp) = false;
|
|
|
|
|
cxx_pp->enclosing_scope = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Exported interface to stringifying types, exprs and decls under TFF_*
|
|
|
|
|
control. */
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
const char *
|
2004-07-28 03:11:36 +00:00
|
|
|
|
type_as_string (tree typ, int flags)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
reinit_cxx_pp ();
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (typ, flags);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
return pp_formatted_text (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
const char *
|
2004-07-28 03:11:36 +00:00
|
|
|
|
expr_as_string (tree decl, int flags)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
reinit_cxx_pp ();
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (decl, flags);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
return pp_formatted_text (cxx_pp);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
const char *
|
2004-07-28 03:11:36 +00:00
|
|
|
|
decl_as_string (tree decl, int flags)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
reinit_cxx_pp ();
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_decl (decl, flags);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
return pp_formatted_text (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
2003-07-11 03:40:53 +00:00
|
|
|
|
/* Generate the three forms of printable names for cxx_printable_name. */
|
1999-08-26 09:30:50 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
const char *
|
2004-07-28 03:11:36 +00:00
|
|
|
|
lang_decl_name (tree decl, int v)
|
1999-08-26 09:30:50 +00:00
|
|
|
|
{
|
|
|
|
|
if (v >= 2)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
return decl_as_string (decl, TFF_DECL_SPECIFIERS);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
reinit_cxx_pp ();
|
1999-08-26 09:30:50 +00:00
|
|
|
|
if (v == 1 && DECL_CLASS_SCOPE_P (decl))
|
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_colon_colon (cxx_pp);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (TREE_CODE (decl) == FUNCTION_DECL)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
else
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
return pp_formatted_text (cxx_pp);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
/* Return the location of a tree passed to %+ formats. */
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static location_t
|
|
|
|
|
location_of (tree t)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
1999-08-26 09:30:50 +00:00
|
|
|
|
if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
|
2004-07-28 03:11:36 +00:00
|
|
|
|
t = DECL_CONTEXT (t);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else if (TYPE_P (t))
|
2004-07-28 03:11:36 +00:00
|
|
|
|
t = TYPE_MAIN_DECL (t);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
else if (TREE_CODE (t) == OVERLOAD)
|
2004-07-28 03:11:36 +00:00
|
|
|
|
t = OVL_FUNCTION (t);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
return DECL_SOURCE_LOCATION (t);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Now the interfaces from error et al to dump_type et al. Each takes an
|
|
|
|
|
on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
|
|
|
|
|
function. */
|
|
|
|
|
|
|
|
|
|
static const char *
|
2004-07-28 03:11:36 +00:00
|
|
|
|
decl_to_string (tree decl, int verbose)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
|
|
|
|
int flags = 0;
|
|
|
|
|
|
|
|
|
|
if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
|
|
|
|
|
|| TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
|
|
|
|
|
flags = TFF_CLASS_KEY_OR_ENUM;
|
|
|
|
|
if (verbose)
|
2003-07-11 03:40:53 +00:00
|
|
|
|
flags |= TFF_DECL_SPECIFIERS;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else if (TREE_CODE (decl) == FUNCTION_DECL)
|
|
|
|
|
flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
|
|
|
|
|
flags |= TFF_TEMPLATE_HEADER;
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
reinit_cxx_pp ();
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_decl (decl, flags);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
return pp_formatted_text (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const char *
|
2004-07-28 03:11:36 +00:00
|
|
|
|
expr_to_string (tree decl)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
reinit_cxx_pp ();
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_expr (decl, 0);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
return pp_formatted_text (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const char *
|
2004-07-28 03:11:36 +00:00
|
|
|
|
fndecl_to_string (tree fndecl, int verbose)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
|
|
|
|
int flags;
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
|
|
|
|
|
| TFF_TEMPLATE_HEADER;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (verbose)
|
|
|
|
|
flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
reinit_cxx_pp ();
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_decl (fndecl, flags);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
return pp_formatted_text (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static const char *
|
2004-07-28 03:11:36 +00:00
|
|
|
|
code_to_string (enum tree_code c)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
return tree_code_name [c];
|
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
const char *
|
2004-07-28 03:11:36 +00:00
|
|
|
|
language_to_string (enum languages c)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
switch (c)
|
|
|
|
|
{
|
|
|
|
|
case lang_c:
|
|
|
|
|
return "C";
|
|
|
|
|
|
|
|
|
|
case lang_cplusplus:
|
|
|
|
|
return "C++";
|
|
|
|
|
|
1999-08-26 09:30:50 +00:00
|
|
|
|
case lang_java:
|
|
|
|
|
return "Java";
|
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
default:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
gcc_unreachable ();
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
2007-05-19 01:19:51 +00:00
|
|
|
|
return NULL;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return the proper printed version of a parameter to a C++ function. */
|
1999-08-26 09:30:50 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
static const char *
|
2004-07-28 03:11:36 +00:00
|
|
|
|
parm_to_string (int p)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
reinit_cxx_pp ();
|
1996-09-18 05:35:50 +00:00
|
|
|
|
if (p < 0)
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_string (cxx_pp, "'this'");
|
|
|
|
|
else
|
|
|
|
|
pp_decimal_int (cxx_pp, p + 1);
|
|
|
|
|
return pp_formatted_text (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
static const char *
|
2004-07-28 03:11:36 +00:00
|
|
|
|
op_to_string (enum tree_code p)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2004-07-28 03:11:36 +00:00
|
|
|
|
tree id = operator_name_info[(int) p].identifier;
|
|
|
|
|
return id ? IDENTIFIER_POINTER (id) : "<unknown>";
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const char *
|
2004-07-28 03:11:36 +00:00
|
|
|
|
type_to_string (tree typ, int verbose)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2004-07-28 03:11:36 +00:00
|
|
|
|
int flags = 0;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (verbose)
|
|
|
|
|
flags |= TFF_CLASS_KEY_OR_ENUM;
|
|
|
|
|
flags |= TFF_TEMPLATE_HEADER;
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
reinit_cxx_pp ();
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (typ, flags);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
return pp_formatted_text (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
static const char *
|
2004-07-28 03:11:36 +00:00
|
|
|
|
assop_to_string (enum tree_code p)
|
1999-08-26 09:30:50 +00:00
|
|
|
|
{
|
2004-07-28 03:11:36 +00:00
|
|
|
|
tree id = assignment_operator_name_info[(int) p].identifier;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
return id ? IDENTIFIER_POINTER (id) : "{unknown}";
|
1999-08-26 09:30:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
static const char *
|
2004-07-28 03:11:36 +00:00
|
|
|
|
args_to_string (tree p, int verbose)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
int flags = 0;
|
|
|
|
|
if (verbose)
|
|
|
|
|
flags |= TFF_CLASS_KEY_OR_ENUM;
|
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
if (p == NULL_TREE)
|
1999-08-26 09:30:50 +00:00
|
|
|
|
return "";
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (TYPE_P (TREE_VALUE (p)))
|
|
|
|
|
return type_as_string (p, flags);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
reinit_cxx_pp ();
|
1999-08-26 09:30:50 +00:00
|
|
|
|
for (; p; p = TREE_CHAIN (p))
|
|
|
|
|
{
|
|
|
|
|
if (TREE_VALUE (p) == null_node)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (cxx_pp, "NULL");
|
1999-08-26 09:30:50 +00:00
|
|
|
|
else
|
2002-02-01 18:16:02 +00:00
|
|
|
|
dump_type (error_type (TREE_VALUE (p)), flags);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
if (TREE_CHAIN (p))
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_separate_with_comma (cxx_pp);
|
1999-08-26 09:30:50 +00:00
|
|
|
|
}
|
2004-07-28 03:11:36 +00:00
|
|
|
|
return pp_formatted_text (cxx_pp);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
static const char *
|
2004-07-28 03:11:36 +00:00
|
|
|
|
cv_to_string (tree p, int v)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
reinit_cxx_pp ();
|
|
|
|
|
pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
|
|
|
|
|
pp_cxx_cv_qualifier_seq (cxx_pp, p);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
return pp_formatted_text (cxx_pp);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
2003-07-11 03:40:53 +00:00
|
|
|
|
/* Langhook for print_error_function. */
|
|
|
|
|
void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
cxx_print_error_function (diagnostic_context *context, const char *file)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2003-07-11 03:40:53 +00:00
|
|
|
|
lhd_print_error_function (context, file);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_base_set_prefix (context->printer, file);
|
2003-07-11 03:40:53 +00:00
|
|
|
|
maybe_print_instantiation_context (context);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
cp_diagnostic_starter (diagnostic_context *context,
|
2007-05-19 01:19:51 +00:00
|
|
|
|
diagnostic_info *diagnostic)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2003-07-11 03:40:53 +00:00
|
|
|
|
diagnostic_report_current_module (context);
|
|
|
|
|
cp_print_error_function (context, diagnostic);
|
|
|
|
|
maybe_print_instantiation_context (context);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
cp_diagnostic_finalizer (diagnostic_context *context,
|
2007-05-19 01:19:51 +00:00
|
|
|
|
diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_base_destroy_prefix (context->printer);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Print current function onto BUFFER, in the process of reporting
|
|
|
|
|
a diagnostic message. Called from cp_diagnostic_starter. */
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
cp_print_error_function (diagnostic_context *context,
|
2007-05-19 01:19:51 +00:00
|
|
|
|
diagnostic_info *diagnostic)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2003-07-11 03:40:53 +00:00
|
|
|
|
if (diagnostic_last_function_changed (context))
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2004-07-28 03:11:36 +00:00
|
|
|
|
const char *old_prefix = context->printer->prefix;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
const char *file = LOCATION_FILE (diagnostic->location);
|
|
|
|
|
char *new_prefix = file ? file_name_as_prefix (file) : NULL;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_base_set_prefix (context->printer, new_prefix);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
if (current_function_decl == NULL)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_base_string (context->printer, "At global scope:");
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_printf (context->printer, "In %s %qs:",
|
|
|
|
|
function_category (current_function_decl),
|
|
|
|
|
cxx_printable_name (current_function_decl, 2));
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_base_newline (context->printer);
|
2003-07-11 03:40:53 +00:00
|
|
|
|
|
|
|
|
|
diagnostic_set_last_function (context);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_base_destroy_prefix (context->printer);
|
|
|
|
|
context->printer->prefix = old_prefix;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Returns a description of FUNCTION using standard terminology. */
|
|
|
|
|
static const char *
|
2004-07-28 03:11:36 +00:00
|
|
|
|
function_category (tree fn)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
|
|
|
|
if (DECL_FUNCTION_MEMBER_P (fn))
|
|
|
|
|
{
|
|
|
|
|
if (DECL_STATIC_FUNCTION_P (fn))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
return "static member function";
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else if (DECL_COPY_CONSTRUCTOR_P (fn))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
return "copy constructor";
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else if (DECL_CONSTRUCTOR_P (fn))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
return "constructor";
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else if (DECL_DESTRUCTOR_P (fn))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
return "destructor";
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
return "member function";
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return "function";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Report the full context of a current template instantiation,
|
|
|
|
|
onto BUFFER. */
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
print_instantiation_full_context (diagnostic_context *context)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
|
|
|
|
tree p = current_instantiation ();
|
2004-07-28 03:11:36 +00:00
|
|
|
|
location_t location = input_location;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (p)
|
|
|
|
|
{
|
|
|
|
|
if (current_function_decl != TINST_DECL (p)
|
|
|
|
|
&& 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
|
|
|
|
|
the synthesis. */
|
|
|
|
|
;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (current_function_decl == TINST_DECL (p))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
/* Avoid redundancy with the "In function" line. */;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_verbatim (context->printer,
|
2007-05-19 01:19:51 +00:00
|
|
|
|
"%s: In instantiation of %qs:\n",
|
|
|
|
|
LOCATION_FILE (location),
|
|
|
|
|
decl_as_string (TINST_DECL (p),
|
|
|
|
|
TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
location = TINST_LOCATION (p);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
p = TREE_CHAIN (p);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
print_instantiation_partial_context (context, p, location);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Same as above but less verbose. */
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
print_instantiation_partial_context (diagnostic_context *context,
|
2007-05-19 01:19:51 +00:00
|
|
|
|
tree t, location_t loc)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
expanded_location xloc;
|
|
|
|
|
for (; ; t = TREE_CHAIN (t))
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
xloc = expand_location (loc);
|
|
|
|
|
if (t == NULL_TREE)
|
|
|
|
|
break;
|
|
|
|
|
pp_verbatim (context->printer, "%s:%d: instantiated from %qs\n",
|
|
|
|
|
xloc.file, xloc.line,
|
|
|
|
|
decl_as_string (TINST_DECL (t),
|
|
|
|
|
TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
|
|
|
|
|
loc = TINST_LOCATION (t);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_verbatim (context->printer, "%s:%d: instantiated from here",
|
|
|
|
|
xloc.file, xloc.line);
|
|
|
|
|
pp_base_newline (context->printer);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Called from cp_thing to print the template context for an error. */
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
maybe_print_instantiation_context (diagnostic_context *context)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
|
|
|
|
if (!problematic_instantiation_changed () || current_instantiation () == 0)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
record_last_problematic_instantiation ();
|
2003-07-11 03:40:53 +00:00
|
|
|
|
print_instantiation_full_context (context);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Report the bare minimum context of a template instantiation. */
|
|
|
|
|
void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
print_instantiation_context (void)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
|
|
|
|
print_instantiation_partial_context
|
2004-07-28 03:11:36 +00:00
|
|
|
|
(global_dc, current_instantiation (), input_location);
|
2003-07-11 03:40:53 +00:00
|
|
|
|
diagnostic_flush_buffer (global_dc);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Called from output_format -- during diagnostic message processing --
|
|
|
|
|
to handle C++ specific format specifier with the following meanings:
|
|
|
|
|
%A function argument-list.
|
|
|
|
|
%C tree code.
|
|
|
|
|
%D declaration.
|
|
|
|
|
%E expression.
|
|
|
|
|
%F function declaration.
|
|
|
|
|
%L language as used in extern "lang".
|
|
|
|
|
%O binary operator.
|
|
|
|
|
%P function parameter whose position is indicated by an integer.
|
|
|
|
|
%Q assignment operator.
|
|
|
|
|
%T type.
|
|
|
|
|
%V cv-qualifier. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
static bool
|
2007-05-19 01:19:51 +00:00
|
|
|
|
cp_printer (pretty_printer *pp, text_info *text, const char *spec,
|
|
|
|
|
int precision, bool wide, bool set_locus, bool verbose)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
|
|
|
|
const char *result;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
tree t = NULL;
|
|
|
|
|
#define next_tree (t = va_arg (*text->args_ptr, tree))
|
2003-07-11 03:40:53 +00:00
|
|
|
|
#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)
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (precision != 0 || wide)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
if (text->locus == NULL)
|
|
|
|
|
set_locus = false;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
switch (*spec)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
|
|
|
|
case 'A': result = args_to_string (next_tree, verbose); break;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
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;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
case 'F': result = fndecl_to_string (next_tree, verbose); break;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
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;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
case 'T': result = type_to_string (next_tree, verbose); break;
|
|
|
|
|
case 'V': result = cv_to_string (next_tree, verbose); break;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
default:
|
2003-07-11 03:40:53 +00:00
|
|
|
|
return false;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_base_string (pp, result);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (set_locus && t != NULL)
|
|
|
|
|
*text->locus = location_of (t);
|
2003-07-11 03:40:53 +00:00
|
|
|
|
return true;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
#undef next_tree
|
|
|
|
|
#undef next_tcode
|
|
|
|
|
#undef next_lang
|
|
|
|
|
#undef next_int
|
|
|
|
|
}
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
|
|
|
|
/* 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. */
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
void
|
2007-05-19 01:19:51 +00:00
|
|
|
|
cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
|
|
|
|
|
const char *msg, va_list *ap)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2003-07-11 03:40:53 +00:00
|
|
|
|
diagnostic_info diagnostic;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
diagnostic_t dlevel;
|
|
|
|
|
switch (level)
|
|
|
|
|
{
|
|
|
|
|
case CPP_DL_WARNING:
|
|
|
|
|
case CPP_DL_WARNING_SYSHDR:
|
|
|
|
|
dlevel = DK_WARNING;
|
|
|
|
|
break;
|
|
|
|
|
case CPP_DL_PEDWARN:
|
|
|
|
|
dlevel = pedantic_error_kind ();
|
|
|
|
|
break;
|
|
|
|
|
case CPP_DL_ERROR:
|
|
|
|
|
dlevel = DK_ERROR;
|
|
|
|
|
break;
|
|
|
|
|
case CPP_DL_ICE:
|
|
|
|
|
dlevel = DK_ICE;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
gcc_unreachable ();
|
|
|
|
|
}
|
|
|
|
|
diagnostic_set_info_translated (&diagnostic, msg, ap,
|
|
|
|
|
input_location, dlevel);
|
2003-07-11 03:40:53 +00:00
|
|
|
|
report_diagnostic (&diagnostic);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|