X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=gcc%2Fcp%2Ferror.c;h=f836ecc59ec1d6c4c8443365adedc39e77d25f0a;hp=4329de5e8762225776b804f8db47039342c31a37;hb=fabe672dddc7fc9e96fedd7fd9cb7024f52704fc;hpb=662821ccd0943292aad10ba81e14006caaa5eceb diff --git a/gcc/cp/error.c b/gcc/cp/error.c index 4329de5e876..f836ecc59ec 100644 --- a/gcc/cp/error.c +++ b/gcc/cp/error.c @@ -1,196 +1,156 @@ /* Call-backs for C++ error reporting. This code is non-reentrant. - Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000 + Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002 Free Software Foundation, Inc. - This file is part of GNU CC. + This file is part of GCC. -GNU CC is free software; you can redistribute it and/or modify +GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. -GNU CC is distributed in the hope that it will be useful, +GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License -along with GNU CC; see the file COPYING. If not, write to +along with GCC; see the file COPYING. If not, write to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "config.h" #include "system.h" +#include "coretypes.h" +#include "tm.h" #include "tree.h" #include "cp-tree.h" -#include "obstack.h" +#include "real.h" #include "toplev.h" +#include "flags.h" #include "diagnostic.h" - -typedef const char *cp_printer (); - -#define obstack_chunk_alloc xmalloc -#define obstack_chunk_free free - -/* Obstack where we build text strings for overloading, etc. */ -static struct obstack scratch_obstack; -static char *scratch_firstobj; - -# define OB_INIT() (scratch_firstobj ? (obstack_free (&scratch_obstack, scratch_firstobj), 0) : 0) -# define OB_PUTC(C) (obstack_1grow (&scratch_obstack, (C))) -# define OB_PUTC2(C1,C2) \ - (obstack_1grow (&scratch_obstack, (C1)), obstack_1grow (&scratch_obstack, (C2))) -# define OB_PUTS(S) (obstack_grow (&scratch_obstack, (S), sizeof (S) - 1)) -# define OB_PUTID(ID) \ - (obstack_grow (&scratch_obstack, IDENTIFIER_POINTER (ID), \ - IDENTIFIER_LENGTH (ID))) -# define OB_PUTCP(S) (obstack_grow (&scratch_obstack, (S), strlen (S))) -# define OB_FINISH() (obstack_1grow (&scratch_obstack, '\0')) -# define OB_PUTI(CST) do { sprintf (digit_buffer, HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT)(CST)); \ - OB_PUTCP (digit_buffer); } while (0) - -# define OB_END_TEMPLATE_ID() \ - (((obstack_next_free (&scratch_obstack) != obstack_base (&scratch_obstack) \ - && obstack_next_free (&scratch_obstack)[-1] == '>') \ - ? OB_PUTC (' ') : (void)0), OB_PUTC ('>')) - -# define NEXT_CODE(t) (TREE_CODE (TREE_TYPE (t))) +#include "langhooks-def.h" enum pad { none, before, after }; -static const char *args_to_string PARAMS ((tree, int)); -static const char *assop_to_string PARAMS ((enum tree_code, int)); -static const char *code_to_string PARAMS ((enum tree_code, int)); -static const char *cv_to_string PARAMS ((tree, int)); -static const char *decl_to_string PARAMS ((tree, int)); -static const char *expr_to_string PARAMS ((tree, int)); -static const char *fndecl_to_string PARAMS ((tree, int)); -static const char *op_to_string PARAMS ((enum tree_code, int)); -static const char *parm_to_string PARAMS ((int, int)); -static const char *type_to_string PARAMS ((tree, int)); - -static void dump_type PARAMS ((tree, enum tree_string_flags)); -static void dump_simple_decl PARAMS ((tree, tree, enum tree_string_flags)); -static void dump_decl PARAMS ((tree, enum tree_string_flags)); -static void dump_template_decl PARAMS ((tree, enum tree_string_flags)); -static void dump_function_decl PARAMS ((tree, enum tree_string_flags)); -static void dump_expr PARAMS ((tree, enum tree_string_flags)); -static void dump_unary_op PARAMS ((const char *, tree, enum tree_string_flags)); -static void dump_binary_op PARAMS ((const char *, tree, enum tree_string_flags)); -static void dump_aggr_type PARAMS ((tree, enum tree_string_flags)); -static enum pad dump_type_prefix PARAMS ((tree, enum tree_string_flags)); -static void dump_type_suffix PARAMS ((tree, enum tree_string_flags)); -static void dump_function_name PARAMS ((tree, enum tree_string_flags)); -static void dump_expr_list PARAMS ((tree, enum tree_string_flags)); -static void dump_global_iord PARAMS ((tree)); -static enum pad dump_qualifiers PARAMS ((tree, enum pad)); -static void dump_char PARAMS ((int)); -static void dump_parameters PARAMS ((tree, enum tree_string_flags)); -static void dump_exception_spec PARAMS ((tree, enum tree_string_flags)); -static const char *aggr_variety PARAMS ((tree)); -static tree ident_fndecl PARAMS ((tree)); -static void dump_template_argument PARAMS ((tree, enum tree_string_flags)); -static void dump_template_argument_list PARAMS ((tree, enum tree_string_flags)); -static void dump_template_parameter PARAMS ((tree, enum tree_string_flags)); -static void dump_template_bindings PARAMS ((tree, tree)); -static void dump_scope PARAMS ((tree, enum tree_string_flags)); -static void dump_template_parms PARAMS ((tree, int, enum tree_string_flags)); - -static const char *function_category PARAMS ((tree)); -static void lang_print_error_function PARAMS ((const char *)); -static void maybe_print_instantiation_context PARAMS ((output_buffer *)); -static void print_instantiation_full_context PARAMS ((output_buffer *)); -static void print_instantiation_partial_context PARAMS ((output_buffer *, tree, - const char *, int)); -static void cp_diagnostic_starter PARAMS ((output_buffer *, - diagnostic_context *)); -static void cp_diagnostic_finalizer PARAMS ((output_buffer *, - diagnostic_context *)); -static void cp_print_error_function PARAMS ((output_buffer *, - diagnostic_context *)); - - -#define A args_to_string -#define C code_to_string -#define D decl_to_string -#define E expr_to_string -#define F fndecl_to_string -#define L language_to_string -#define O op_to_string -#define P parm_to_string -#define Q assop_to_string -#define T type_to_string -#define V cv_to_string - -#define o (cp_printer *) 0 -cp_printer * cp_printers[256] = -{ -/*0 1 2 3 4 5 6 7 8 9 A B C D E F */ - o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, /* 0x00 */ - o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, /* 0x10 */ - o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, /* 0x20 */ - o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, /* 0x30 */ - o, A, o, C, D, E, F, o, o, o, o, o, L, o, o, O, /* 0x40 */ - P, Q, o, o, T, o, V, o, o, o, o, o, o, o, o, o, /* 0x50 */ - o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, /* 0x60 */ - o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, /* 0x70 */ -}; -#undef C -#undef D -#undef E -#undef F -#undef L -#undef O -#undef P -#undef Q -#undef T -#undef V -#undef o +#define sorry_for_unsupported_tree(T) \ + sorry ("`%s' not supported by %s", tree_code_name[(int) TREE_CODE (T)], \ + __FUNCTION__) + +#define print_scope_operator(BUFFER) output_add_string ((BUFFER), "::") +#define print_left_paren(BUFFER) output_add_character ((BUFFER), '(') +#define print_right_paren(BUFFER) output_add_character ((BUFFER), ')') +#define print_left_bracket(BUFFER) output_add_character ((BUFFER), '[') +#define print_right_bracket(BUFFER) output_add_character ((BUFFER), ']') +#define print_template_argument_list_start(BUFFER) \ + print_non_consecutive_character ((BUFFER), '<') +#define print_template_argument_list_end(BUFFER) \ + print_non_consecutive_character ((BUFFER), '>') +#define print_tree_identifier(BUFFER, TID) \ + output_add_string ((BUFFER), IDENTIFIER_POINTER (TID)) +#define print_identifier(BUFFER, ID) output_add_string ((BUFFER), (ID)) +#define separate_with_comma(BUFFER) output_add_string ((BUFFER), ", ") + +/* The global buffer where we dump everything. It is there only for + transitional purpose. It is expected, in the near future, to be + completely removed. */ +static output_buffer scratch_buffer_rec; +static output_buffer *scratch_buffer = &scratch_buffer_rec; + +# define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T))) + +#define reinit_global_formatting_buffer() \ + output_clear_message_text (scratch_buffer) + +static const char *args_to_string (tree, int); +static const char *assop_to_string (enum tree_code, int); +static const char *code_to_string (enum tree_code, int); +static const char *cv_to_string (tree, int); +static const char *decl_to_string (tree, int); +static const char *expr_to_string (tree, int); +static const char *fndecl_to_string (tree, int); +static const char *op_to_string (enum tree_code, int); +static const char *parm_to_string (int, int); +static const char *type_to_string (tree, int); + +static void dump_type (tree, int); +static void dump_typename (tree, int); +static void dump_simple_decl (tree, tree, int); +static void dump_decl (tree, int); +static void dump_template_decl (tree, int); +static void dump_function_decl (tree, int); +static void dump_expr (tree, int); +static void dump_unary_op (const char *, tree, int); +static void dump_binary_op (const char *, tree, int); +static void dump_aggr_type (tree, int); +static enum pad dump_type_prefix (tree, int); +static void dump_type_suffix (tree, int); +static void dump_function_name (tree, int); +static void dump_expr_list (tree, int); +static void dump_global_iord (tree); +static enum pad dump_qualifiers (tree, enum pad); +static void dump_char (int); +static void dump_parameters (tree, int); +static void dump_exception_spec (tree, int); +static const char *class_key_or_enum (tree); +static void dump_template_argument (tree, int); +static void dump_template_argument_list (tree, int); +static void dump_template_parameter (tree, int); +static void 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 *, + tree, const char *, int); +static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *); +static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *); +static void cp_print_error_function (diagnostic_context *, diagnostic_info *); + +static bool cp_printer (output_buffer *, text_info *); +static void print_non_consecutive_character (output_buffer *, int); +static void print_integer (output_buffer *, HOST_WIDE_INT); +static tree locate_error (const char *, va_list); void -init_error () +init_error (void) { - gcc_obstack_init (&scratch_obstack); - scratch_firstobj = (char *)obstack_alloc (&scratch_obstack, 0); + diagnostic_starter (global_dc) = cp_diagnostic_starter; + diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer; + diagnostic_format_decoder (global_dc) = cp_printer; - print_error_function = lang_print_error_function; - lang_diagnostic_starter = cp_diagnostic_starter; - lang_diagnostic_finalizer = cp_diagnostic_finalizer; + init_output_buffer (scratch_buffer, /* prefix */NULL, /* line-width */0); } /* Dump a scope, if deemed necessary. */ static void -dump_scope (scope, flags) - tree scope; - enum tree_string_flags flags; +dump_scope (tree scope, int flags) { + int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF)); + if (scope == NULL_TREE) return; - + if (TREE_CODE (scope) == NAMESPACE_DECL) { if (scope != global_namespace) { - dump_decl (scope, (flags & (TS_PEDANTIC_NAME | TS_FUNC_SCOPE | TS_CHASE_TYPEDEFS)) - | TS_FUNC_NORETURN | TS_DECL_TYPE); - OB_PUTS ("::"); + dump_decl (scope, f); + print_scope_operator (scratch_buffer); } - else if (flags & TS_PEDANTIC_NAME) - OB_PUTS ("::"); } else if (AGGREGATE_TYPE_P (scope)) { - dump_type (scope, (flags & (TS_PEDANTIC_NAME | TS_FUNC_SCOPE | TS_CHASE_TYPEDEFS)) - | TS_FUNC_NORETURN | TS_DECL_TYPE); - OB_PUTS ("::"); + dump_type (scope, f); + print_scope_operator (scratch_buffer); } - else if ((flags & (TS_PEDANTIC_NAME | TS_FUNC_SCOPE)) - && TREE_CODE (scope) == FUNCTION_DECL) + else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL) { - dump_function_decl (scope, (flags & (TS_PEDANTIC_NAME | TS_FUNC_SCOPE | TS_CHASE_TYPEDEFS)) - | TS_FUNC_NORETURN | TS_DECL_TYPE); - OB_PUTS ("::"); + dump_function_decl (scope, f); + print_scope_operator (scratch_buffer); } } @@ -198,9 +158,7 @@ dump_scope (scope, flags) indication of whether we dumped something. */ static enum pad -dump_qualifiers (t, p) - tree t; - enum pad p; +dump_qualifiers (tree t, enum pad p) { static const int masks[] = {TYPE_QUAL_CONST, TYPE_QUAL_VOLATILE, TYPE_QUAL_RESTRICT}; @@ -209,19 +167,19 @@ dump_qualifiers (t, p) int ix; int quals = TYPE_QUALS (t); int do_after = p == after; - + if (quals) { for (ix = 0; ix != 3; ix++) if (masks[ix] & quals) { if (p == before) - OB_PUTC (' '); + output_add_space (scratch_buffer); p = before; - OB_PUTCP (names[ix]); + print_identifier (scratch_buffer, names[ix]); } if (do_after) - OB_PUTC (' '); + output_add_space (scratch_buffer); } else p = none; @@ -235,23 +193,19 @@ static char digit_buffer[128]; /* Dump the template ARGument under control of FLAGS. */ static void -dump_template_argument (arg, flags) - tree arg; - enum tree_string_flags flags; +dump_template_argument (tree arg, int flags) { if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL) - dump_type (arg, flags & ~TS_AGGR_TAGS); + dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM); else - dump_expr (arg, (flags | TS_EXPR_PARENS) & ~TS_AGGR_TAGS); + dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM); } /* Dump a template-argument-list ARGS (always a TREE_VEC) under control of FLAGS. */ static void -dump_template_argument_list (args, flags) - tree args; - enum tree_string_flags flags; +dump_template_argument_list (tree args, int flags) { int n = TREE_VEC_LENGTH (args); int need_comma = 0; @@ -260,7 +214,7 @@ dump_template_argument_list (args, flags) for (i = 0; i< n; ++i) { if (need_comma) - OB_PUTS (", "); + separate_with_comma (scratch_buffer); dump_template_argument (TREE_VEC_ELT (args, i), flags); need_comma = 1; } @@ -269,39 +223,37 @@ dump_template_argument_list (args, flags) /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */ static void -dump_template_parameter (parm, flags) - tree parm; - enum tree_string_flags flags; +dump_template_parameter (tree parm, int flags) { tree p = TREE_VALUE (parm); tree a = TREE_PURPOSE (parm); if (TREE_CODE (p) == TYPE_DECL) { - if (flags & TS_DECL_TYPE) + if (flags & TFF_DECL_SPECIFIERS) { - OB_PUTS ("class"); + print_identifier (scratch_buffer, "class"); if (DECL_NAME (p)) { - OB_PUTC (' '); - OB_PUTID (DECL_NAME (p)); + output_add_space (scratch_buffer); + print_tree_identifier (scratch_buffer, DECL_NAME (p)); } } else if (DECL_NAME (p)) - OB_PUTID (DECL_NAME (p)); + print_tree_identifier (scratch_buffer, DECL_NAME (p)); else - OB_PUTS ("{template default argument error}"); + print_identifier (scratch_buffer, "{template default argument error}"); } else - dump_decl (p, flags | TS_DECL_TYPE); + dump_decl (p, flags | TFF_DECL_SPECIFIERS); - if ((flags & TS_PARM_DEFAULTS) && a != NULL_TREE) + if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE) { - OB_PUTS (" = "); - if (TREE_CODE (a) == TYPE_DECL || TREE_CODE (a) == TEMPLATE_DECL) - dump_type (a, flags & ~TS_CHASE_TYPEDEFS); + output_add_string (scratch_buffer, " = "); + if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL) + dump_type (a, flags & ~TFF_CHASE_TYPEDEF); else - dump_expr (a, flags | TS_EXPR_PARENS); + dump_expr (a, flags | TFF_EXPR_IN_PARENS); } } @@ -310,8 +262,7 @@ dump_template_parameter (parm, flags) TREE_VEC. */ static void -dump_template_bindings (parms, args) - tree parms, args; +dump_template_bindings (tree parms, tree args) { int need_comma = 0; @@ -335,14 +286,14 @@ dump_template_bindings (parms, args) } if (need_comma) - OB_PUTS (", "); - dump_template_parameter (TREE_VEC_ELT (p, i), TS_PLAIN); - OB_PUTS (" = "); + separate_with_comma (scratch_buffer); + dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER); + output_add_string (scratch_buffer, " = "); if (arg) - dump_template_argument (arg, TS_PLAIN); + dump_template_argument (arg, TFF_PLAIN_IDENTIFIER); else - OB_PUTS ("{missing}"); - + print_identifier (scratch_buffer, ""); + ++arg_idx; need_comma = 1; } @@ -351,24 +302,22 @@ dump_template_bindings (parms, args) } } -/* Dump into the obstack a human-readable equivalent of TYPE. FLAGS - controls the format. */ +/* Dump a human-readable equivalent of TYPE. FLAGS controls the + format. */ static void -dump_type (t, flags) - tree t; - enum tree_string_flags flags; +dump_type (tree t, int flags) { if (t == NULL_TREE) return; - + if (TYPE_PTRMEMFUNC_P (t)) goto offset_type; switch (TREE_CODE (t)) { case UNKNOWN_TYPE: - OB_PUTS ("{unknown type}"); + print_identifier (scratch_buffer, ""); break; case TREE_LIST: @@ -377,7 +326,7 @@ dump_type (t, flags) break; case IDENTIFIER_NODE: - OB_PUTID (t); + print_tree_identifier (scratch_buffer, t); break; case TREE_VEC: @@ -391,29 +340,41 @@ dump_type (t, flags) break; case TYPE_DECL: - if (flags & TS_CHASE_TYPEDEFS) + if (flags & TFF_CHASE_TYPEDEF) { dump_type (DECL_ORIGINAL_TYPE (t) ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags); break; } /* else fallthrough */ - + case TEMPLATE_DECL: case NAMESPACE_DECL: - dump_decl (t, flags & ~TS_DECL_TYPE); + dump_decl (t, flags & ~TFF_DECL_SPECIFIERS); break; - + case COMPLEX_TYPE: - OB_PUTS ("complex "); + output_add_string (scratch_buffer, "__complex__ "); dump_type (TREE_TYPE (t), flags); break; + case VECTOR_TYPE: + output_add_string (scratch_buffer, "vector "); + { + /* The subtype of a VECTOR_TYPE is something like intQI_type_node, + which has no name and is not very useful for diagnostics. So + look up the equivalent C type and print its name. */ + tree elt = TREE_TYPE (t); + elt = c_common_type_for_mode (TYPE_MODE (elt), TREE_UNSIGNED (elt)); + dump_type (elt, flags); + } + break; + case INTEGER_TYPE: if (!TREE_UNSIGNED (TYPE_MAIN_VARIANT (t)) && TREE_UNSIGNED (t)) - OB_PUTS ("unsigned "); + output_add_string (scratch_buffer, "unsigned "); else if (TREE_UNSIGNED (TYPE_MAIN_VARIANT (t)) && !TREE_UNSIGNED (t)) - OB_PUTS ("signed "); + output_add_string (scratch_buffer, "signed "); /* fall through. */ case REAL_TYPE: @@ -422,42 +383,43 @@ dump_type (t, flags) { tree type; dump_qualifiers (t, after); - type = flags & TS_CHASE_TYPEDEFS ? TYPE_MAIN_VARIANT (t) : t; + type = flags & TFF_CHASE_TYPEDEF ? TYPE_MAIN_VARIANT (t) : t; if (TYPE_NAME (type) && TYPE_IDENTIFIER (type)) - OB_PUTID (TYPE_IDENTIFIER (type)); + print_tree_identifier (scratch_buffer, TYPE_IDENTIFIER (type)); else /* Types like intQI_type_node and friends have no names. These don't come up in user error messages, but it's nice to be able to print them from the debugger. */ - OB_PUTS ("{anonymous}"); + print_identifier (scratch_buffer, ""); } break; case TEMPLATE_TEMPLATE_PARM: - if (!TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t)) - { - /* For parameters inside template signature. */ - if (TYPE_IDENTIFIER (t)) - OB_PUTID (TYPE_IDENTIFIER (t)); - else - OB_PUTS ("{anonymous template template parameter}"); - } + /* For parameters inside template signature. */ + if (TYPE_IDENTIFIER (t)) + print_tree_identifier (scratch_buffer, TYPE_IDENTIFIER (t)); else - { - tree args = TYPE_TI_ARGS (t); - OB_PUTID (TYPE_IDENTIFIER (t)); - OB_PUTC ('<'); - dump_template_argument_list (args, flags); - OB_END_TEMPLATE_ID (); - } + print_identifier + (scratch_buffer, ""); + break; + + case BOUND_TEMPLATE_TEMPLATE_PARM: + { + tree args = TYPE_TI_ARGS (t); + print_tree_identifier (scratch_buffer, TYPE_IDENTIFIER (t)); + print_template_argument_list_start (scratch_buffer); + dump_template_argument_list (args, flags); + print_template_argument_list_end (scratch_buffer); + } break; case TEMPLATE_TYPE_PARM: dump_qualifiers (t, after); if (TYPE_IDENTIFIER (t)) - OB_PUTID (TYPE_IDENTIFIER (t)); + print_tree_identifier (scratch_buffer, TYPE_IDENTIFIER (t)); else - OB_PUTS ("{anonymous template type parameter}"); + print_identifier + (scratch_buffer, ""); break; /* This is not always necessary for pointers and such, but doing this @@ -475,34 +437,54 @@ dump_type (t, flags) break; } case TYPENAME_TYPE: - OB_PUTS ("typename "); - dump_type (TYPE_CONTEXT (t), flags & ~TS_AGGR_TAGS); - OB_PUTS ("::"); - dump_decl (TYPENAME_TYPE_FULLNAME (t), flags); + dump_qualifiers (t, after); + output_add_string (scratch_buffer, "typename "); + dump_typename (t, flags); + break; + + case UNBOUND_CLASS_TEMPLATE: + dump_type (TYPE_CONTEXT (t), flags); + print_scope_operator (scratch_buffer); + print_identifier (scratch_buffer, "template "); + dump_type (DECL_NAME (TYPE_NAME (t)), flags); break; case TYPEOF_TYPE: - OB_PUTS ("__typeof ("); - dump_expr (TYPE_FIELDS (t), flags & ~TS_EXPR_PARENS); - OB_PUTC (')'); + output_add_string (scratch_buffer, "__typeof ("); + dump_expr (TYPE_FIELDS (t), flags & ~TFF_EXPR_IN_PARENS); + print_right_paren (scratch_buffer); break; default: - sorry ("`%s' not supported by dump_type", - tree_code_name[(int) TREE_CODE (t)]); - /* Fall through to error. */ + sorry_for_unsupported_tree (t); + /* Fall through to error. */ case ERROR_MARK: - OB_PUTS ("{type error}"); + print_identifier (scratch_buffer, ""); break; } } +/* Dump a TYPENAME_TYPE. We need to notice when the context is itself + a TYPENAME_TYPE. */ + +static void +dump_typename (tree t, int flags) +{ + 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); + print_scope_operator (scratch_buffer); + dump_decl (TYPENAME_TYPE_FULLNAME (t), flags); +} + /* Return the name of the supplied aggregate, or enumeral type. */ static const char * -aggr_variety (t) - tree t; +class_key_or_enum (tree t) { if (TREE_CODE (t) == ENUMERAL_TYPE) return "enum"; @@ -518,24 +500,22 @@ aggr_variety (t) in the form `class foo'. */ static void -dump_aggr_type (t, flags) - tree t; - enum tree_string_flags flags; +dump_aggr_type (tree t, int flags) { tree name; - const char *variety = aggr_variety (t); + const char *variety = class_key_or_enum (t); int typdef = 0; int tmplate = 0; dump_qualifiers (t, after); - if (flags & TS_AGGR_TAGS) + if (flags & TFF_CLASS_KEY_OR_ENUM) { - OB_PUTCP (variety); - OB_PUTC (' '); + print_identifier (scratch_buffer, variety); + output_add_space (scratch_buffer); } - - if (flags & TS_CHASE_TYPEDEFS) + + if (flags & TFF_CHASE_TYPEDEF) t = TYPE_MAIN_VARIANT (t); name = TYPE_NAME (t); @@ -549,13 +529,13 @@ dump_aggr_type (t, flags) || TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL || DECL_TEMPLATE_SPECIALIZATION (CLASSTYPE_TI_TEMPLATE (t)) || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t))); - dump_scope (CP_DECL_CONTEXT (name), flags | TS_FUNC_SCOPE); + dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE); if (tmplate) { /* Because the template names are mangled, we have to locate the most general template, and use that name. */ tree tpl = CLASSTYPE_TI_TEMPLATE (t); - + while (DECL_TEMPLATE_INFO (tpl)) tpl = DECL_TI_TEMPLATE (tpl); name = tpl; @@ -565,20 +545,17 @@ dump_aggr_type (t, flags) if (name == 0 || ANON_AGGRNAME_P (name)) { - OB_PUTS ("{anonymous"); - if (!(flags & TS_AGGR_TAGS)) - { - OB_PUTC (' '); - OB_PUTCP (variety); - } - OB_PUTC ('}'); + if (flags & TFF_CLASS_KEY_OR_ENUM) + print_identifier (scratch_buffer, ""); + else + output_printf (scratch_buffer, "", variety); } else - OB_PUTID (name); + print_tree_identifier (scratch_buffer, name); if (tmplate) dump_template_parms (TYPE_TEMPLATE_INFO (t), !CLASSTYPE_USE_TEMPLATE (t), - flags & ~TS_TEMPLATE_PREFIX); + flags & ~TFF_TEMPLATE_HEADER); } /* Dump into the obstack the initial part of the output for a given type. @@ -590,42 +567,42 @@ dump_aggr_type (t, flags) deal with prefix and suffix. Arrays must also do this for DECL nodes, like int a[], and for things like - int *[]&. - + int *[]&. + Return indicates how you should pad an object name after this. I.e. you want to pad non-*, non-& cores, but not pad * or & types. */ static enum pad -dump_type_prefix (t, flags) - tree t; - enum tree_string_flags flags; +dump_type_prefix (tree t, int flags) { enum pad padding = before; - + if (TYPE_PTRMEMFUNC_P (t)) { t = TYPE_PTRMEMFUNC_FN_TYPE (t); goto offset_type; } - + switch (TREE_CODE (t)) { case POINTER_TYPE: case REFERENCE_TYPE: { tree sub = TREE_TYPE (t); - + padding = dump_type_prefix (sub, flags); /* A tree for a member pointer looks like pointer to offset, so let the OFFSET_TYPE case handle it. */ if (!TYPE_PTRMEM_P (t)) { - if (padding != none) - OB_PUTC (' '); if (TREE_CODE (sub) == ARRAY_TYPE) - OB_PUTC ('('); - OB_PUTC ("&*"[TREE_CODE (t) == POINTER_TYPE]); - padding = dump_qualifiers (t, none); + { + output_add_space (scratch_buffer); + print_left_paren (scratch_buffer); + } + output_add_character + (scratch_buffer, "&*"[TREE_CODE (t) == POINTER_TYPE]); + padding = dump_qualifiers (t, before); } } break; @@ -636,11 +613,11 @@ dump_type_prefix (t, flags) if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */ { if (padding != none) - OB_PUTC (' '); + output_add_space (scratch_buffer); dump_type (TYPE_OFFSET_BASETYPE (t), flags); - OB_PUTS ("::"); + print_scope_operator (scratch_buffer); } - OB_PUTC ('*'); + output_add_character (scratch_buffer, '*'); padding = dump_qualifiers (t, none); break; @@ -649,19 +626,19 @@ dump_type_prefix (t, flags) case FUNCTION_TYPE: padding = dump_type_prefix (TREE_TYPE (t), flags); if (padding != none) - OB_PUTC (' '); - OB_PUTC ('('); + output_add_space (scratch_buffer); + print_left_paren (scratch_buffer); padding = none; break; case METHOD_TYPE: padding = dump_type_prefix (TREE_TYPE (t), flags); if (padding != none) - OB_PUTC (' '); - OB_PUTC ('('); + output_add_space (scratch_buffer); + print_left_paren (scratch_buffer); padding = none; dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags); - OB_PUTS ("::"); + print_scope_operator (scratch_buffer); break; case ARRAY_TYPE: @@ -676,6 +653,7 @@ dump_type_prefix (t, flags) case RECORD_TYPE: case TEMPLATE_TYPE_PARM: case TEMPLATE_TEMPLATE_PARM: + case BOUND_TEMPLATE_TEMPLATE_PARM: case TREE_LIST: case TYPE_DECL: case TREE_VEC: @@ -684,16 +662,17 @@ dump_type_prefix (t, flags) case VOID_TYPE: case TYPENAME_TYPE: case COMPLEX_TYPE: + case VECTOR_TYPE: + case TYPEOF_TYPE: dump_type (t, flags); padding = before; break; - - default: - sorry ("`%s' not supported by dump_type_prefix", - tree_code_name[(int) TREE_CODE (t)]); + default: + sorry_for_unsupported_tree (t); + /* fall through. */ case ERROR_MARK: - OB_PUTS ("{typeprefixerror}"); + print_identifier (scratch_buffer, ""); break; } return padding; @@ -703,9 +682,7 @@ dump_type_prefix (t, flags) which appears after the identifier (or function parms). */ static void -dump_type_suffix (t, flags) - tree t; - enum tree_string_flags flags; +dump_type_suffix (tree t, int flags) { if (TYPE_PTRMEMFUNC_P (t)) t = TYPE_PTRMEMFUNC_FN_TYPE (t); @@ -716,7 +693,7 @@ dump_type_suffix (t, flags) case REFERENCE_TYPE: case OFFSET_TYPE: if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE) - OB_PUTC (')'); + print_right_paren (scratch_buffer); dump_type_suffix (TREE_TYPE (t), flags); break; @@ -725,42 +702,44 @@ dump_type_suffix (t, flags) case METHOD_TYPE: { tree arg; - OB_PUTC (')'); + print_right_paren (scratch_buffer); arg = TYPE_ARG_TYPES (t); if (TREE_CODE (t) == METHOD_TYPE) arg = TREE_CHAIN (arg); /* Function pointers don't have default args. Not in standard C++, anyway; they may in g++, but we'll just pretend otherwise. */ - dump_parameters (arg, flags & ~TS_PARM_DEFAULTS); + dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS); if (TREE_CODE (t) == METHOD_TYPE) dump_qualifiers (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), before); - dump_type_suffix (TREE_TYPE (t), flags); dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags); + dump_type_suffix (TREE_TYPE (t), flags); break; } case ARRAY_TYPE: - OB_PUTC ('['); + print_left_bracket (scratch_buffer); if (TYPE_DOMAIN (t)) { if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0)) - OB_PUTI (tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1); + print_integer + (scratch_buffer, + tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1); else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR) dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0), - flags & ~TS_EXPR_PARENS); + flags & ~TFF_EXPR_IN_PARENS); else dump_expr (fold (cp_build_binary_op (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)), integer_one_node)), - flags & ~TS_EXPR_PARENS); + flags & ~TFF_EXPR_IN_PARENS); } - OB_PUTC (']'); + print_right_bracket (scratch_buffer); dump_type_suffix (TREE_TYPE (t), flags); break; - + case ENUMERAL_TYPE: case IDENTIFIER_NODE: case INTEGER_TYPE: @@ -769,6 +748,7 @@ dump_type_suffix (t, flags) case RECORD_TYPE: case TEMPLATE_TYPE_PARM: case TEMPLATE_TEMPLATE_PARM: + case BOUND_TEMPLATE_TEMPLATE_PARM: case TREE_LIST: case TYPE_DECL: case TREE_VEC: @@ -777,12 +757,12 @@ dump_type_suffix (t, flags) case VOID_TYPE: case TYPENAME_TYPE: case COMPLEX_TYPE: + case VECTOR_TYPE: + case TYPEOF_TYPE: break; default: - sorry ("`%s' not supported by dump_type_suffix", - tree_code_name[(int) TREE_CODE (t)]); - + sorry_for_unsupported_tree (t); case ERROR_MARK: /* Don't mark it here, we should have already done in dump_type_prefix. */ @@ -790,87 +770,43 @@ dump_type_suffix (t, flags) } } -/* Return a function declaration which corresponds to the IDENTIFIER_NODE - argument. */ - -static tree -ident_fndecl (t) - tree t; -{ - tree n = lookup_name (t, 0); - - if (n == NULL_TREE) - return NULL_TREE; - - if (TREE_CODE (n) == FUNCTION_DECL) - return n; - else if (TREE_CODE (n) == TREE_LIST - && TREE_CODE (TREE_VALUE (n)) == FUNCTION_DECL) - return TREE_VALUE (n); - - my_friendly_abort (66); - return NULL_TREE; -} - -#ifndef NO_DOLLAR_IN_LABEL -# define GLOBAL_THING "_GLOBAL_$" -#else -# ifndef NO_DOT_IN_LABEL -# define GLOBAL_THING "_GLOBAL_." -# else -# define GLOBAL_THING "_GLOBAL__" -# endif -#endif - -#define GLOBAL_IORD_P(NODE) \ - ! strncmp (IDENTIFIER_POINTER(NODE), GLOBAL_THING, sizeof (GLOBAL_THING) - 1) - static void -dump_global_iord (t) - tree t; +dump_global_iord (tree t) { - const char *name = IDENTIFIER_POINTER (t); + const char *p = NULL; - OB_PUTS ("(static "); - if (name [sizeof (GLOBAL_THING) - 1] == 'I') - OB_PUTS ("initializers"); - else if (name [sizeof (GLOBAL_THING) - 1] == 'D') - OB_PUTS ("destructors"); + if (DECL_GLOBAL_CTOR_P (t)) + p = "initializers"; + else if (DECL_GLOBAL_DTOR_P (t)) + p = "destructors"; else - my_friendly_abort (352); - - OB_PUTS (" for "); - OB_PUTCP (input_filename); - OB_PUTC (')'); + abort (); + + output_printf (scratch_buffer, "(static %s for %s)", p, input_filename); } static void -dump_simple_decl (t, type, flags) - tree t; - tree type; - enum tree_string_flags flags; +dump_simple_decl (tree t, tree type, int flags) { - if (flags & TS_DECL_TYPE) + if (flags & TFF_DECL_SPECIFIERS) { if (dump_type_prefix (type, flags) != none) - OB_PUTC (' '); + output_add_space (scratch_buffer); } if (!DECL_INITIAL (t) || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX) dump_scope (CP_DECL_CONTEXT (t), flags); if (DECL_NAME (t)) dump_decl (DECL_NAME (t), flags); else - OB_PUTS ("{anonymous}"); - if (flags & TS_DECL_TYPE) + print_identifier (scratch_buffer, ""); + if (flags & TFF_DECL_SPECIFIERS) dump_type_suffix (type, flags); } /* Dump a human readable string for the decl T under control of FLAGS. */ static void -dump_decl (t, flags) - tree t; - enum tree_string_flags flags; +dump_decl (tree t, int flags) { if (t == NULL_TREE) return; @@ -882,33 +818,28 @@ dump_decl (t, flags) /* Don't say 'typedef class A' */ if (DECL_ARTIFICIAL (t)) { - if ((flags & TS_DECL_TYPE) + if ((flags & TFF_DECL_SPECIFIERS) && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM) - /* Say `class T' not just `T'. */ - OB_PUTS ("class "); + /* Say `class T' not just `T'. */ + output_add_string (scratch_buffer, "class "); dump_type (TREE_TYPE (t), flags); break; } } - if (flags & TS_DECORATE) - OB_PUTS ("typedef "); - dump_simple_decl (t, DECL_ORIGINAL_TYPE (t) + if (flags & TFF_DECL_SPECIFIERS) + output_add_string (scratch_buffer, "typedef "); + dump_simple_decl (t, DECL_ORIGINAL_TYPE (t) ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags); break; - + case VAR_DECL: if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t))) { - OB_PUTS ("vtable for "); - if (TYPE_P (DECL_CONTEXT (t))) - dump_type (DECL_CONTEXT (t), flags); - else - /* This case can arise with -fno-vtable-thunks. See - expand_upcast_fixups. It's not clear what to print - here. */ - OB_PUTS ("{unknown type}"); + output_add_string (scratch_buffer, "vtable for "); + my_friendly_assert (TYPE_P (DECL_CONTEXT (t)), 20010720); + dump_type (DECL_CONTEXT (t), flags); break; } /* else fall through */ @@ -918,29 +849,29 @@ dump_decl (t, flags) break; case RESULT_DECL: - OB_PUTS ("{return} "); + output_add_string (scratch_buffer, " "); dump_simple_decl (t, TREE_TYPE (t), flags); break; case NAMESPACE_DECL: dump_scope (CP_DECL_CONTEXT (t), flags); if (DECL_NAME (t) == anonymous_namespace_name) - OB_PUTS ("{unnamed}"); + print_identifier (scratch_buffer, ""); else - OB_PUTID (DECL_NAME (t)); + print_tree_identifier (scratch_buffer, DECL_NAME (t)); break; case SCOPE_REF: - dump_decl (TREE_OPERAND (t, 0), flags & ~TS_DECL_TYPE); - OB_PUTS ("::"); + dump_decl (TREE_OPERAND (t, 0), flags & ~TFF_DECL_SPECIFIERS); + print_scope_operator (scratch_buffer); dump_decl (TREE_OPERAND (t, 1), flags); - break; + break; case ARRAY_REF: dump_decl (TREE_OPERAND (t, 0), flags); - OB_PUTC ('['); + print_left_bracket (scratch_buffer); dump_decl (TREE_OPERAND (t, 1), flags); - OB_PUTC (']'); + print_right_bracket (scratch_buffer); break; /* So that we can do dump_decl on an aggr type. */ @@ -951,52 +882,57 @@ dump_decl (t, flags) break; case TYPE_EXPR: - my_friendly_abort (69); + abort (); break; /* These special cases are duplicated here so that other functions - can feed identifiers to cp_error and get them demangled properly. */ + can feed identifiers to error and get them demangled properly. */ case IDENTIFIER_NODE: - { tree f; - if (DESTRUCTOR_NAME_P (t) - && (f = ident_fndecl (t)) - && DECL_LANGUAGE (f) == lang_cplusplus) - { - OB_PUTC ('~'); - dump_decl (DECL_NAME (f), flags); - } - else if (IDENTIFIER_TYPENAME_P (t)) - { - OB_PUTS ("operator "); - /* Not exactly IDENTIFIER_TYPE_VALUE. */ - dump_type (TREE_TYPE (t), flags); - break; - } - else - OB_PUTID (t); - } + if (IDENTIFIER_TYPENAME_P (t)) + { + output_add_string (scratch_buffer, "operator "); + /* Not exactly IDENTIFIER_TYPE_VALUE. */ + dump_type (TREE_TYPE (t), flags); + break; + } + else + print_tree_identifier (scratch_buffer, t); break; case OVERLOAD: + if (OVL_CHAIN (t)) + { + t = OVL_CURRENT (t); + if (DECL_CLASS_SCOPE_P (t)) + { + dump_type (DECL_CONTEXT (t), flags); + output_add_string (scratch_buffer, "::"); + } + else if (DECL_CONTEXT (t)) + { + dump_decl (DECL_CONTEXT (t), flags); + output_add_string (scratch_buffer, "::"); + } + dump_decl (DECL_NAME (t), flags); + break; + } + + /* If there's only one function, just treat it like an ordinary + FUNCTION_DECL. */ t = OVL_CURRENT (t); /* Fall through. */ case FUNCTION_DECL: - if (GLOBAL_IORD_P (DECL_ASSEMBLER_NAME (t))) - dump_global_iord (DECL_ASSEMBLER_NAME (t)); + if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t)) + dump_global_iord (t); else if (! DECL_LANG_SPECIFIC (t)) - OB_PUTS ("{internal}"); - else if (flags & TS_PEDANTIC_NAME) - dump_function_decl (t, flags | TS_FUNC_NORETURN | TS_DECL_TYPE); + print_identifier (scratch_buffer, ""); else dump_function_decl (t, flags); break; case TEMPLATE_DECL: - if (flags & TS_PEDANTIC_NAME) - dump_template_decl (t, flags | TS_FUNC_NORETURN | TS_DECL_TYPE); - else - dump_template_decl (t, flags); + dump_template_decl (t, flags); break; case TEMPLATE_ID_EXPR: @@ -1006,14 +942,14 @@ dump_decl (t, flags) if (is_overloaded_fn (name)) name = DECL_NAME (get_first_fn (name)); dump_decl (name, flags); - OB_PUTC ('<'); + print_template_argument_list_start (scratch_buffer); for (args = TREE_OPERAND (t, 1); args; args = TREE_CHAIN (args)) { dump_template_argument (TREE_VALUE (args), flags); if (TREE_CHAIN (args)) - OB_PUTS (", "); + separate_with_comma (scratch_buffer); } - OB_END_TEMPLATE_ID (); + print_template_argument_list_end (scratch_buffer); } break; @@ -1022,7 +958,7 @@ dump_decl (t, flags) break; case LABEL_DECL: - OB_PUTID (DECL_NAME (t)); + print_tree_identifier (scratch_buffer, DECL_NAME (t)); break; case CONST_DECL: @@ -1033,25 +969,28 @@ dump_decl (t, flags) else if (DECL_NAME (t)) dump_decl (DECL_NAME (t), flags); else if (DECL_INITIAL (t)) - dump_expr (DECL_INITIAL (t), flags | TS_EXPR_PARENS); + dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS); else - OB_PUTS ("enumerator"); + print_identifier (scratch_buffer, ""); break; case USING_DECL: - OB_PUTS ("using "); + output_add_string (scratch_buffer, "using "); dump_type (DECL_INITIAL (t), flags); - OB_PUTS ("::"); - OB_PUTID (DECL_NAME (t)); + print_scope_operator (scratch_buffer); + print_tree_identifier (scratch_buffer, DECL_NAME (t)); + break; + + case BASELINK: + dump_decl (BASELINK_FUNCTIONS (t), flags); break; default: - sorry ("`%s' not supported by dump_decl", - tree_code_name[(int) TREE_CODE (t)]); + sorry_for_unsupported_tree (t); /* Fallthrough to error. */ case ERROR_MARK: - OB_PUTS ("{declaration error}"); + print_identifier (scratch_buffer, ""); break; } } @@ -1060,77 +999,80 @@ dump_decl (t, flags) 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */ static void -dump_template_decl (t, flags) - tree t; - enum tree_string_flags flags; +dump_template_decl (tree t, int flags) { tree orig_parms = DECL_TEMPLATE_PARMS (t); tree parms; - int i; - - if (flags & TS_TEMPLATE_PREFIX) + int i; + + if (flags & TFF_TEMPLATE_HEADER) { - for (parms = orig_parms = nreverse (orig_parms); + for (parms = orig_parms = nreverse (orig_parms); parms; parms = TREE_CHAIN (parms)) { tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms); int len = TREE_VEC_LENGTH (inner_parms); - - OB_PUTS ("template <"); + + output_add_string (scratch_buffer, "template<"); + + /* If we've shown the template prefix, we'd better show the + parameters' and decl's type too. */ + flags |= TFF_DECL_SPECIFIERS; + for (i = 0; i < len; i++) { if (i) - OB_PUTS (", "); + separate_with_comma (scratch_buffer); dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags); } - OB_END_TEMPLATE_ID (); - OB_PUTC (' '); + print_template_argument_list_end (scratch_buffer); + output_add_space (scratch_buffer); } nreverse(orig_parms); - /* If we've shown the template prefix, we'd better show the - decl's type too. */ - flags |= TS_DECL_TYPE; + + if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)) + /* Say `template class TT' not just `template TT'. */ + output_add_string (scratch_buffer, "class "); } + if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL) dump_type (TREE_TYPE (t), - ((flags & ~TS_AGGR_TAGS) | TS_TEMPLATE_PLAIN - | (flags & TS_DECL_TYPE ? TS_AGGR_TAGS : 0))); + ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME + | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0))); else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL) - dump_decl (DECL_TEMPLATE_RESULT (t), flags | TS_TEMPLATE_PLAIN); + dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME); else if (TREE_TYPE (t) == NULL_TREE) - my_friendly_abort (353); + abort (); else switch (NEXT_CODE (t)) { case METHOD_TYPE: case FUNCTION_TYPE: - dump_function_decl (t, flags | TS_TEMPLATE_PLAIN); + dump_function_decl (t, flags | TFF_TEMPLATE_NAME); break; default: - /* This case can occur with some illegal code. */ + /* This case can occur with some invalid code. */ dump_type (TREE_TYPE (t), - (flags & ~TS_AGGR_TAGS) | TS_TEMPLATE_PLAIN - | (flags & TS_DECL_TYPE ? TS_AGGR_TAGS : 0)); + (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME + | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)); } } /* Pretty print a function decl. There are several ways we want to print a - function declaration. The TS_FUNC bits in FLAGS tells us how to behave. - As cp_error can only apply the '#' flag once to give 0 and 1 for V, there - is %D which doesn't print the throw specs, and %F which does. */ + function declaration. The TFF_ bits in FLAGS tells us how to behave. + As error can only apply the '#' flag once to give 0 and 1 for V, there + is %D which doesn't print the throw specs, and %F which does. */ static void -dump_function_decl (t, flags) - tree t; - enum tree_string_flags flags; +dump_function_decl (tree t, int flags) { tree fntype; tree parmtypes; tree cname = NULL_TREE; tree template_args = NULL_TREE; tree template_parms = NULL_TREE; - int show_return = !(flags & TS_FUNC_NORETURN) && (flags & TS_DECL_TYPE); + int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS; if (TREE_CODE (t) == TEMPLATE_DECL) t = DECL_TEMPLATE_RESULT (t); @@ -1150,7 +1092,7 @@ dump_function_decl (t, flags) } fntype = TREE_TYPE (t); - parmtypes = TYPE_ARG_TYPES (fntype); + parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t); if (DECL_CLASS_SCOPE_P (t)) cname = DECL_CONTEXT (t); @@ -1158,110 +1100,100 @@ dump_function_decl (t, flags) else if (TREE_CODE (fntype) == METHOD_TYPE) cname = TREE_TYPE (TREE_VALUE (parmtypes)); - if (!(flags & TS_DECORATE)) + if (!(flags & TFF_DECL_SPECIFIERS)) /* OK */; else if (DECL_STATIC_FUNCTION_P (t)) - OB_PUTS ("static "); - else if (TYPE_POLYMORPHIC_P (t)) - OB_PUTS ("virtual "); - + print_identifier (scratch_buffer, "static "); + else if (DECL_VIRTUAL_P (t)) + print_identifier (scratch_buffer, "virtual "); + /* Print the return type? */ if (show_return) show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t) && !DECL_DESTRUCTOR_P (t); if (show_return) { - if (dump_type_prefix (TREE_TYPE (fntype), flags) != none) - OB_PUTC (' '); + dump_type_prefix (TREE_TYPE (fntype), flags); + output_add_space (scratch_buffer); } /* Print the function name. */ if (cname) { dump_type (cname, flags); - OB_PUTS ("::"); + print_scope_operator (scratch_buffer); } else dump_scope (CP_DECL_CONTEXT (t), flags); dump_function_name (t, flags); - - if (!(flags & TS_DECL_TYPE)) - return; - if (TREE_CODE (fntype) == METHOD_TYPE && parmtypes) - /* Skip "this" parameter. */ - parmtypes = TREE_CHAIN (parmtypes); - - /* Skip past the "in_charge" parameter. */ - if (DECL_HAS_IN_CHARGE_PARM_P (t)) - parmtypes = TREE_CHAIN (parmtypes); - - dump_parameters (parmtypes, flags); - - if (show_return) - dump_type_suffix (TREE_TYPE (fntype), flags); - if (TREE_CODE (fntype) == METHOD_TYPE) - dump_qualifiers (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))), - before); - - if (flags & TS_FUNC_THROW) - dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags); + if (1) + { + dump_parameters (parmtypes, flags); + + if (TREE_CODE (fntype) == METHOD_TYPE) + dump_qualifiers (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))), + before); + + if (flags & TFF_EXCEPTION_SPECIFICATION) + dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags); + + if (show_return) + dump_type_suffix (TREE_TYPE (fntype), flags); + } /* If T is a template instantiation, dump the parameter binding. */ if (template_parms != NULL_TREE && template_args != NULL_TREE) { - OB_PUTS (" [with "); + output_add_string (scratch_buffer, " [with "); dump_template_bindings (template_parms, template_args); - OB_PUTC (']'); + print_right_bracket (scratch_buffer); } } /* Print a parameter list. If this is for a member function, the member object ptr (and any other hidden args) should have - already been removed. */ + already been removed. */ static void -dump_parameters (parmtypes, flags) - tree parmtypes; - enum tree_string_flags flags; +dump_parameters (tree parmtypes, int flags) { int first; - OB_PUTS (" ("); + + print_left_paren (scratch_buffer); for (first = 1; parmtypes != void_list_node; parmtypes = TREE_CHAIN (parmtypes)) { if (!first) - OB_PUTS (", "); + separate_with_comma (scratch_buffer); first = 0; if (!parmtypes) { - OB_PUTS ("..."); + print_identifier (scratch_buffer, "..."); break; } dump_type (TREE_VALUE (parmtypes), flags); - - if ((flags & TS_PARM_DEFAULTS) && TREE_PURPOSE (parmtypes)) + + if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes)) { - OB_PUTS (" = "); - dump_expr (TREE_PURPOSE (parmtypes), flags | TS_EXPR_PARENS); + output_add_string (scratch_buffer, " = "); + dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS); } } - OB_PUTC (')'); + print_right_paren (scratch_buffer); } -/* Print an exception specification. T is the exception specification. */ +/* Print an exception specification. T is the exception specification. */ static void -dump_exception_spec (t, flags) - tree t; - enum tree_string_flags flags; +dump_exception_spec (tree t, int flags) { if (t) { - OB_PUTS (" throw ("); + output_add_string (scratch_buffer, " throw ("); if (TREE_VALUE (t) != NULL_TREE) while (1) { @@ -1269,9 +1201,9 @@ dump_exception_spec (t, flags) t = TREE_CHAIN (t); if (!t) break; - OB_PUTS (", "); + separate_with_comma (scratch_buffer); } - OB_PUTC (')'); + print_right_paren (scratch_buffer); } } @@ -1279,16 +1211,22 @@ dump_exception_spec (t, flags) and destructors properly. */ static void -dump_function_name (t, flags) - tree t; - enum tree_string_flags flags; +dump_function_name (tree t, int flags) { tree name = DECL_NAME (t); + if (TREE_CODE (t) == TEMPLATE_DECL) + t = DECL_TEMPLATE_RESULT (t); + + /* Don't let the user see __comp_ctor et al. */ + if (DECL_CONSTRUCTOR_P (t) + || DECL_DESTRUCTOR_P (t)) + name = constructor_name (DECL_CONTEXT (t)); + if (DECL_DESTRUCTOR_P (t)) { - OB_PUTC ('~'); - dump_decl (name, TS_PLAIN); + output_add_character (scratch_buffer, '~'); + dump_decl (name, TFF_PLAIN_IDENTIFIER); } else if (DECL_CONV_FN_P (t)) { @@ -1298,17 +1236,17 @@ dump_function_name (t, flags) declarations, both will have the same name, yet the types will be different, hence the TREE_TYPE field of the first name will be clobbered by the second. */ - OB_PUTS ("operator "); + output_add_string (scratch_buffer, "operator "); dump_type (TREE_TYPE (TREE_TYPE (t)), flags); } else if (IDENTIFIER_OPNAME_P (name)) - OB_PUTID (name); + print_tree_identifier (scratch_buffer, name); else dump_decl (name, flags); if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t) && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t) - && (DECL_TEMPLATE_SPECIALIZATION (t) + && (DECL_TEMPLATE_SPECIALIZATION (t) || TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL || DECL_TEMPLATE_SPECIALIZATION (DECL_TI_TEMPLATE (t)) || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t)))) @@ -1322,17 +1260,14 @@ dump_function_name (t, flags) decoration. */ static void -dump_template_parms (info, primary, flags) - tree info; - int primary; - enum tree_string_flags flags; +dump_template_parms (tree info, int primary, int flags) { tree args = info ? TI_ARGS (info) : NULL_TREE; - - if (primary && flags & TS_TEMPLATE_PLAIN) + + if (primary && flags & TFF_TEMPLATE_NAME) return; - flags &= ~(TS_AGGR_TAGS | TS_TEMPLATE_PLAIN); - OB_PUTC ('<'); + flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME); + print_template_argument_list_start (scratch_buffer); /* Be careful only to print things when we have them, so as not to crash producing error messages. */ @@ -1341,13 +1276,13 @@ dump_template_parms (info, primary, flags) int len = 0; int ix = 0; int need_comma = 0; - + if (TREE_CODE (args) == TREE_VEC) { if (TREE_VEC_LENGTH (args) > 0 - && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC) - args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1); - + && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC) + args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1); + len = TREE_VEC_LENGTH (args); } else if (TREE_CODE (args) == TREE_LIST) @@ -1366,10 +1301,10 @@ dump_template_parms (info, primary, flags) args = TREE_CHAIN (args); } if (need_comma) - OB_PUTS (", "); - + separate_with_comma (scratch_buffer); + if (!arg) - OB_PUTS ("{template parameter error}"); + print_identifier (scratch_buffer, "