1 /* Call-backs for C++ error reporting.
2 This code is non-reentrant.
3 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002,
4 2003, 2004 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "coretypes.h"
31 #include "diagnostic.h"
32 #include "langhooks-def.h"
33 #include "cxx-pretty-print.h"
35 enum pad { none, before, after };
37 #define pp_template_argument_list_start(PP) \
38 pp_non_consecutive_character (PP, '<')
39 #define pp_template_argument_list_end(PP) \
40 pp_non_consecutive_character (PP, '>')
41 #define pp_separate_with_comma(PP) pp_string (PP, ", ")
43 /* The global buffer where we dump everything. It is there only for
44 transitional purpose. It is expected, in the near future, to be
45 completely removed. */
46 static cxx_pretty_printer scratch_pretty_printer;
47 #define cxx_pp (&scratch_pretty_printer)
49 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
51 #define reinit_global_formatting_buffer() \
52 output_clear_message_text (scratch_buffer)
54 static const char *args_to_string (tree, int);
55 static const char *assop_to_string (enum tree_code);
56 static const char *code_to_string (enum tree_code);
57 static const char *cv_to_string (tree, int);
58 static const char *decl_to_string (tree, int);
59 static const char *expr_to_string (tree);
60 static const char *fndecl_to_string (tree, int);
61 static const char *op_to_string (enum tree_code);
62 static const char *parm_to_string (int);
63 static const char *type_to_string (tree, int);
65 static void dump_type (tree, int);
66 static void dump_typename (tree, int);
67 static void dump_simple_decl (tree, tree, int);
68 static void dump_decl (tree, int);
69 static void dump_template_decl (tree, int);
70 static void dump_function_decl (tree, int);
71 static void dump_expr (tree, int);
72 static void dump_unary_op (const char *, tree, int);
73 static void dump_binary_op (const char *, tree, int);
74 static void dump_aggr_type (tree, int);
75 static enum pad dump_type_prefix (tree, int);
76 static void dump_type_suffix (tree, int);
77 static void dump_function_name (tree, int);
78 static void dump_expr_list (tree, int);
79 static void dump_global_iord (tree);
80 static enum pad dump_qualifiers (tree, enum pad);
81 static void dump_parameters (tree, int);
82 static void dump_exception_spec (tree, int);
83 static const char *class_key_or_enum (tree);
84 static void dump_template_argument (tree, int);
85 static void dump_template_argument_list (tree, int);
86 static void dump_template_parameter (tree, int);
87 static void dump_template_bindings (tree, tree);
88 static void dump_scope (tree, int);
89 static void dump_template_parms (tree, int, int);
91 static const char *function_category (tree);
92 static void maybe_print_instantiation_context (diagnostic_context *);
93 static void print_instantiation_full_context (diagnostic_context *);
94 static void print_instantiation_partial_context (diagnostic_context *,
96 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
97 static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
98 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
100 static bool cp_printer (pretty_printer *, text_info *);
101 static void pp_non_consecutive_character (cxx_pretty_printer *, int);
102 static tree locate_error (const char *, va_list);
103 static location_t location_of (tree);
108 diagnostic_starter (global_dc) = cp_diagnostic_starter;
109 diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer;
110 diagnostic_format_decoder (global_dc) = cp_printer;
112 pp_construct (pp_base (cxx_pp), NULL, 0);
113 pp_cxx_pretty_printer_init (cxx_pp);
116 /* Dump a scope, if deemed necessary. */
119 dump_scope (tree scope, int flags)
121 int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF));
123 if (scope == NULL_TREE)
126 if (TREE_CODE (scope) == NAMESPACE_DECL)
128 if (scope != global_namespace)
130 dump_decl (scope, f);
131 pp_colon_colon (cxx_pp);
134 else if (AGGREGATE_TYPE_P (scope))
136 dump_type (scope, f);
137 pp_colon_colon (cxx_pp);
139 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
141 dump_function_decl (scope, f);
142 pp_colon_colon (cxx_pp);
146 /* Dump type qualifiers, providing padding as requested. Return an
147 indication of whether we dumped something. */
150 dump_qualifiers (tree t, enum pad p)
152 static const int masks[] =
153 {TYPE_QUAL_CONST, TYPE_QUAL_VOLATILE, TYPE_QUAL_RESTRICT};
154 static const char *const names[] =
155 {"const", "volatile", "__restrict"};
157 int quals = TYPE_QUALS (t);
158 int do_after = p == after;
162 for (ix = 0; ix != 3; ix++)
163 if (masks[ix] & quals)
168 pp_identifier (cxx_pp, names[ix]);
178 /* Dump the template ARGument under control of FLAGS. */
181 dump_template_argument (tree arg, int flags)
183 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
184 dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
186 dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
189 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
193 dump_template_argument_list (tree args, int flags)
195 int n = TREE_VEC_LENGTH (args);
199 for (i = 0; i< n; ++i)
202 pp_separate_with_comma (cxx_pp);
203 dump_template_argument (TREE_VEC_ELT (args, i), flags);
208 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
211 dump_template_parameter (tree parm, int flags)
213 tree p = TREE_VALUE (parm);
214 tree a = TREE_PURPOSE (parm);
216 if (TREE_CODE (p) == TYPE_DECL)
218 if (flags & TFF_DECL_SPECIFIERS)
220 pp_identifier (cxx_pp, "class");
224 pp_tree_identifier (cxx_pp, DECL_NAME (p));
227 else if (DECL_NAME (p))
228 pp_tree_identifier (cxx_pp, DECL_NAME (p));
230 pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
233 dump_decl (p, flags | TFF_DECL_SPECIFIERS);
235 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
237 pp_string (cxx_pp, " = ");
238 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
239 dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
241 dump_expr (a, flags | TFF_EXPR_IN_PARENS);
245 /* Dump, under control of FLAGS, a template-parameter-list binding.
246 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
250 dump_template_bindings (tree parms, tree args)
256 tree p = TREE_VALUE (parms);
257 int lvl = TMPL_PARMS_DEPTH (parms);
261 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
263 tree arg = NULL_TREE;
265 /* Don't crash if we had an invalid argument list. */
266 if (TMPL_ARGS_DEPTH (args) >= lvl)
268 tree lvl_args = TMPL_ARGS_LEVEL (args, lvl);
269 if (NUM_TMPL_ARGS (lvl_args) > arg_idx)
270 arg = TREE_VEC_ELT (lvl_args, arg_idx);
274 pp_separate_with_comma (cxx_pp);
275 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
276 pp_string (cxx_pp, " = ");
278 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
280 pp_identifier (cxx_pp, "<missing>");
286 parms = TREE_CHAIN (parms);
290 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
294 dump_type (tree t, int flags)
299 if (TYPE_PTRMEMFUNC_P (t))
302 switch (TREE_CODE (t))
305 pp_identifier (cxx_pp, "<unknown type>");
309 /* A list of function parms. */
310 dump_parameters (t, flags);
313 case IDENTIFIER_NODE:
314 pp_tree_identifier (cxx_pp, t);
318 dump_type (BINFO_TYPE (t), flags);
324 dump_aggr_type (t, flags);
328 if (flags & TFF_CHASE_TYPEDEF)
330 dump_type (DECL_ORIGINAL_TYPE (t)
331 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
334 /* Else fall through. */
338 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
347 pp_base (cxx_pp)->padding = pp_none;
348 pp_type_specifier_seq (cxx_pp, t);
351 case TEMPLATE_TEMPLATE_PARM:
352 /* For parameters inside template signature. */
353 if (TYPE_IDENTIFIER (t))
354 pp_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
356 pp_cxx_canonical_template_parameter (cxx_pp, t);
359 case BOUND_TEMPLATE_TEMPLATE_PARM:
361 tree args = TYPE_TI_ARGS (t);
362 pp_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
363 pp_template_argument_list_start (cxx_pp);
364 dump_template_argument_list (args, flags);
365 pp_template_argument_list_end (cxx_pp);
369 case TEMPLATE_TYPE_PARM:
370 dump_qualifiers (t, after);
371 if (TYPE_IDENTIFIER (t))
372 pp_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
374 pp_cxx_canonical_template_parameter
375 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
378 /* This is not always necessary for pointers and such, but doing this
379 reduces code size. */
388 dump_type_prefix (t, flags);
389 dump_type_suffix (t, flags);
393 dump_qualifiers (t, after);
394 pp_string (cxx_pp, "typename ");
395 dump_typename (t, flags);
398 case UNBOUND_CLASS_TEMPLATE:
399 dump_type (TYPE_CONTEXT (t), flags);
400 pp_colon_colon (cxx_pp);
401 pp_identifier (cxx_pp, "template ");
402 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
406 pp_string (cxx_pp, "__typeof (");
407 dump_expr (TYPE_FIELDS (t), flags & ~TFF_EXPR_IN_PARENS);
408 pp_right_paren (cxx_pp);
412 pp_unsupported_tree (cxx_pp, t);
413 /* Fall through to error. */
416 pp_identifier (cxx_pp, "<type error>");
421 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
425 dump_typename (tree t, int flags)
427 tree ctx = TYPE_CONTEXT (t);
429 if (TREE_CODE (ctx) == TYPENAME_TYPE)
430 dump_typename (ctx, flags);
432 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
433 pp_colon_colon (cxx_pp);
434 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
437 /* Return the name of the supplied aggregate, or enumeral type. */
440 class_key_or_enum (tree t)
442 if (TREE_CODE (t) == ENUMERAL_TYPE)
444 else if (TREE_CODE (t) == UNION_TYPE)
446 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
452 /* Print out a class declaration T under the control of FLAGS,
453 in the form `class foo'. */
456 dump_aggr_type (tree t, int flags)
459 const char *variety = class_key_or_enum (t);
463 dump_qualifiers (t, after);
465 if (flags & TFF_CLASS_KEY_OR_ENUM)
467 pp_identifier (cxx_pp, variety);
471 if (flags & TFF_CHASE_TYPEDEF)
472 t = TYPE_MAIN_VARIANT (t);
474 name = TYPE_NAME (t);
478 typdef = !DECL_ARTIFICIAL (name);
479 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
480 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
481 && (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
482 || TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
483 || DECL_TEMPLATE_SPECIALIZATION (CLASSTYPE_TI_TEMPLATE (t))
484 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
485 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
488 /* Because the template names are mangled, we have to locate
489 the most general template, and use that name. */
490 tree tpl = CLASSTYPE_TI_TEMPLATE (t);
492 while (DECL_TEMPLATE_INFO (tpl))
493 tpl = DECL_TI_TEMPLATE (tpl);
496 name = DECL_NAME (name);
499 if (name == 0 || ANON_AGGRNAME_P (name))
501 if (flags & TFF_CLASS_KEY_OR_ENUM)
502 pp_identifier (cxx_pp, "<anonymous>");
504 pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety);
507 pp_tree_identifier (cxx_pp, name);
509 dump_template_parms (TYPE_TEMPLATE_INFO (t),
510 !CLASSTYPE_USE_TEMPLATE (t),
511 flags & ~TFF_TEMPLATE_HEADER);
514 /* Dump into the obstack the initial part of the output for a given type.
515 This is necessary when dealing with things like functions returning
518 return type of `int (* fee ())()': pointer -> function -> int. Both
519 pointer (and reference and offset) and function (and member) types must
520 deal with prefix and suffix.
522 Arrays must also do this for DECL nodes, like int a[], and for things like
525 Return indicates how you should pad an object name after this. I.e. you
526 want to pad non-*, non-& cores, but not pad * or & types. */
529 dump_type_prefix (tree t, int flags)
531 enum pad padding = before;
533 if (TYPE_PTRMEMFUNC_P (t))
535 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
539 switch (TREE_CODE (t))
544 tree sub = TREE_TYPE (t);
546 padding = dump_type_prefix (sub, flags);
547 if (TREE_CODE (sub) == ARRAY_TYPE)
550 pp_left_paren (cxx_pp);
552 pp_character (cxx_pp, "&*"[TREE_CODE (t) == POINTER_TYPE]);
553 padding = dump_qualifiers (t, before);
559 padding = dump_type_prefix (TREE_TYPE (t), flags);
560 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
564 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
565 pp_colon_colon (cxx_pp);
568 padding = dump_qualifiers (t, none);
571 /* Can only be reached through function pointer -- this would not be
572 correct if FUNCTION_DECLs used it. */
574 padding = dump_type_prefix (TREE_TYPE (t), flags);
577 pp_left_paren (cxx_pp);
582 padding = dump_type_prefix (TREE_TYPE (t), flags);
585 pp_left_paren (cxx_pp);
587 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
588 pp_colon_colon (cxx_pp);
592 padding = dump_type_prefix (TREE_TYPE (t), flags);
596 case IDENTIFIER_NODE:
601 case TEMPLATE_TYPE_PARM:
602 case TEMPLATE_TEMPLATE_PARM:
603 case BOUND_TEMPLATE_TEMPLATE_PARM:
614 dump_type (t, flags);
619 pp_unsupported_tree (cxx_pp, t);
622 pp_identifier (cxx_pp, "<typeprefixerror>");
628 /* Dump the suffix of type T, under control of FLAGS. This is the part
629 which appears after the identifier (or function parms). */
632 dump_type_suffix (tree t, int flags)
634 if (TYPE_PTRMEMFUNC_P (t))
635 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
637 switch (TREE_CODE (t))
642 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
643 pp_right_paren (cxx_pp);
644 dump_type_suffix (TREE_TYPE (t), flags);
647 /* Can only be reached through function pointer. */
652 pp_right_paren (cxx_pp);
653 arg = TYPE_ARG_TYPES (t);
654 if (TREE_CODE (t) == METHOD_TYPE)
655 arg = TREE_CHAIN (arg);
657 /* Function pointers don't have default args. Not in standard C++,
658 anyway; they may in g++, but we'll just pretend otherwise. */
659 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
661 if (TREE_CODE (t) == METHOD_TYPE)
663 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), before);
664 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
665 dump_type_suffix (TREE_TYPE (t), flags);
670 pp_left_bracket (cxx_pp);
673 if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0))
675 (cxx_pp, tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1);
676 else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR)
677 dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0),
678 flags & ~TFF_EXPR_IN_PARENS);
680 dump_expr (fold (cp_build_binary_op
681 (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)),
683 flags & ~TFF_EXPR_IN_PARENS);
685 pp_right_bracket (cxx_pp);
686 dump_type_suffix (TREE_TYPE (t), flags);
690 case IDENTIFIER_NODE:
695 case TEMPLATE_TYPE_PARM:
696 case TEMPLATE_TEMPLATE_PARM:
697 case BOUND_TEMPLATE_TEMPLATE_PARM:
711 pp_unsupported_tree (cxx_pp, t);
713 /* Don't mark it here, we should have already done in
720 dump_global_iord (tree t)
722 const char *p = NULL;
724 if (DECL_GLOBAL_CTOR_P (t))
726 else if (DECL_GLOBAL_DTOR_P (t))
731 pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename);
735 dump_simple_decl (tree t, tree type, int flags)
737 if (flags & TFF_DECL_SPECIFIERS)
739 if (dump_type_prefix (type, flags) != none)
742 if (!DECL_INITIAL (t) || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX)
743 dump_scope (CP_DECL_CONTEXT (t), flags);
745 dump_decl (DECL_NAME (t), flags);
747 pp_identifier (cxx_pp, "<anonymous>");
748 if (flags & TFF_DECL_SPECIFIERS)
749 dump_type_suffix (type, flags);
752 /* Dump a human readable string for the decl T under control of FLAGS. */
755 dump_decl (tree t, int flags)
760 switch (TREE_CODE (t))
764 /* Don't say 'typedef class A' */
765 if (DECL_ARTIFICIAL (t))
767 if ((flags & TFF_DECL_SPECIFIERS)
768 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
769 /* Say `class T' not just `T'. */
770 pp_string (cxx_pp, "class ");
772 dump_type (TREE_TYPE (t), flags);
776 if (flags & TFF_DECL_SPECIFIERS)
777 pp_string (cxx_pp, "typedef ");
778 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
779 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
784 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
786 pp_string (cxx_pp, "vtable for ");
787 my_friendly_assert (TYPE_P (DECL_CONTEXT (t)), 20010720);
788 dump_type (DECL_CONTEXT (t), flags);
791 /* Else fall through. */
795 dump_simple_decl (t, TREE_TYPE (t), flags);
799 pp_string (cxx_pp, "<return value> ");
800 dump_simple_decl (t, TREE_TYPE (t), flags);
804 if (flags & TFF_DECL_SPECIFIERS)
805 pp_cxx_declaration (cxx_pp, t);
808 dump_scope (CP_DECL_CONTEXT (t), flags);
809 if (DECL_NAME (t) == NULL_TREE)
810 pp_identifier (cxx_pp, "<unnamed>");
812 pp_tree_identifier (cxx_pp, DECL_NAME (t));
817 dump_decl (TREE_OPERAND (t, 0), flags & ~TFF_DECL_SPECIFIERS);
818 pp_colon_colon (cxx_pp);
819 dump_decl (TREE_OPERAND (t, 1), flags);
823 dump_decl (TREE_OPERAND (t, 0), flags);
824 pp_left_bracket (cxx_pp);
825 dump_decl (TREE_OPERAND (t, 1), flags);
826 pp_right_bracket (cxx_pp);
829 /* So that we can do dump_decl on an aggr type. */
833 dump_type (t, flags);
837 /* This is a pseudo destructor call which has not been folded into
838 a PSEUDO_DTOR_EXPR yet. */
839 pp_complement (cxx_pp);
840 dump_type (TREE_OPERAND (t, 0), flags);
847 /* These special cases are duplicated here so that other functions
848 can feed identifiers to error and get them demangled properly. */
849 case IDENTIFIER_NODE:
850 if (IDENTIFIER_TYPENAME_P (t))
852 pp_string (cxx_pp, "operator ");
853 /* Not exactly IDENTIFIER_TYPE_VALUE. */
854 dump_type (TREE_TYPE (t), flags);
858 pp_tree_identifier (cxx_pp, t);
865 if (DECL_CLASS_SCOPE_P (t))
867 dump_type (DECL_CONTEXT (t), flags);
868 pp_colon_colon (cxx_pp);
870 else if (DECL_CONTEXT (t))
872 dump_decl (DECL_CONTEXT (t), flags);
873 pp_colon_colon (cxx_pp);
875 dump_decl (DECL_NAME (t), flags);
879 /* If there's only one function, just treat it like an ordinary
885 if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
886 dump_global_iord (t);
887 else if (! DECL_LANG_SPECIFIC (t))
888 pp_identifier (cxx_pp, "<internal>");
890 dump_function_decl (t, flags);
894 dump_template_decl (t, flags);
897 case TEMPLATE_ID_EXPR:
899 tree name = TREE_OPERAND (t, 0);
901 if (is_overloaded_fn (name))
902 name = DECL_NAME (get_first_fn (name));
903 dump_decl (name, flags);
904 pp_template_argument_list_start (cxx_pp);
905 if (TREE_OPERAND (t, 1))
906 dump_template_argument_list (TREE_OPERAND (t, 1), flags);
907 pp_template_argument_list_end (cxx_pp);
912 pp_tree_identifier (cxx_pp, DECL_NAME (t));
916 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
917 || (DECL_INITIAL (t) &&
918 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
919 dump_simple_decl (t, TREE_TYPE (t), flags);
920 else if (DECL_NAME (t))
921 dump_decl (DECL_NAME (t), flags);
922 else if (DECL_INITIAL (t))
923 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
925 pp_identifier (cxx_pp, "<enumerator>");
929 pp_string (cxx_pp, "using ");
930 dump_type (DECL_INITIAL (t), flags);
931 pp_colon_colon (cxx_pp);
932 dump_decl (DECL_NAME (t), flags);
936 dump_decl (BASELINK_FUNCTIONS (t), flags);
939 case NON_DEPENDENT_EXPR:
940 dump_expr (t, flags);
943 case TEMPLATE_TYPE_PARM:
944 if (flags & TFF_DECL_SPECIFIERS)
945 pp_cxx_declaration (cxx_pp, t);
947 pp_type_id (cxx_pp, t);
951 pp_unsupported_tree (cxx_pp, t);
952 /* Fall through to error. */
955 pp_identifier (cxx_pp, "<declaration error>");
960 /* Dump a template declaration T under control of FLAGS. This means the
961 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
964 dump_template_decl (tree t, int flags)
966 tree orig_parms = DECL_TEMPLATE_PARMS (t);
970 if (flags & TFF_TEMPLATE_HEADER)
972 for (parms = orig_parms = nreverse (orig_parms);
974 parms = TREE_CHAIN (parms))
976 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
977 int len = TREE_VEC_LENGTH (inner_parms);
979 pp_string (cxx_pp, "template<");
981 /* If we've shown the template prefix, we'd better show the
982 parameters' and decl's type too. */
983 flags |= TFF_DECL_SPECIFIERS;
985 for (i = 0; i < len; i++)
988 pp_separate_with_comma (cxx_pp);
989 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
991 pp_template_argument_list_end (cxx_pp);
994 nreverse(orig_parms);
996 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
997 /* Say `template<arg> class TT' not just `template<arg> TT'. */
998 pp_string (cxx_pp, "class ");
1001 if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
1002 dump_type (TREE_TYPE (t),
1003 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1004 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1005 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
1006 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1007 else if (TREE_TYPE (t) == NULL_TREE)
1010 switch (NEXT_CODE (t))
1014 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1017 /* This case can occur with some invalid code. */
1018 dump_type (TREE_TYPE (t),
1019 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1020 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0));
1024 /* Pretty print a function decl. There are several ways we want to print a
1025 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1026 As error can only apply the '#' flag once to give 0 and 1 for V, there
1027 is %D which doesn't print the throw specs, and %F which does. */
1030 dump_function_decl (tree t, int flags)
1034 tree cname = NULL_TREE;
1035 tree template_args = NULL_TREE;
1036 tree template_parms = NULL_TREE;
1037 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1039 if (TREE_CODE (t) == TEMPLATE_DECL)
1040 t = DECL_TEMPLATE_RESULT (t);
1042 /* Pretty print template instantiations only. */
1043 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t))
1047 template_args = DECL_TI_ARGS (t);
1048 tmpl = most_general_template (t);
1049 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1051 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1056 fntype = TREE_TYPE (t);
1057 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1059 if (DECL_CLASS_SCOPE_P (t))
1060 cname = DECL_CONTEXT (t);
1061 /* This is for partially instantiated template methods. */
1062 else if (TREE_CODE (fntype) == METHOD_TYPE)
1063 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1065 if (!(flags & TFF_DECL_SPECIFIERS))
1067 else if (DECL_STATIC_FUNCTION_P (t))
1068 pp_identifier (cxx_pp, "static ");
1069 else if (DECL_VIRTUAL_P (t))
1070 pp_identifier (cxx_pp, "virtual ");
1072 /* Print the return type? */
1074 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1075 && !DECL_DESTRUCTOR_P (t);
1078 dump_type_prefix (TREE_TYPE (fntype), flags);
1082 /* Print the function name. */
1085 dump_type (cname, flags);
1086 pp_colon_colon (cxx_pp);
1089 dump_scope (CP_DECL_CONTEXT (t), flags);
1091 dump_function_name (t, flags);
1093 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1095 dump_parameters (parmtypes, flags);
1097 if (TREE_CODE (fntype) == METHOD_TYPE)
1098 dump_qualifiers (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))),
1101 if (flags & TFF_EXCEPTION_SPECIFICATION)
1102 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
1105 dump_type_suffix (TREE_TYPE (fntype), flags);
1108 /* If T is a template instantiation, dump the parameter binding. */
1109 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1111 pp_string (cxx_pp, " [with ");
1112 dump_template_bindings (template_parms, template_args);
1113 pp_right_bracket (cxx_pp);
1117 /* Print a parameter list. If this is for a member function, the
1118 member object ptr (and any other hidden args) should have
1119 already been removed. */
1122 dump_parameters (tree parmtypes, int flags)
1126 pp_left_paren (cxx_pp);
1128 for (first = 1; parmtypes != void_list_node;
1129 parmtypes = TREE_CHAIN (parmtypes))
1132 pp_separate_with_comma (cxx_pp);
1136 pp_identifier (cxx_pp, "...");
1139 dump_type (TREE_VALUE (parmtypes), flags);
1141 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1143 pp_string (cxx_pp, " = ");
1144 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1148 pp_right_paren (cxx_pp);
1151 /* Print an exception specification. T is the exception specification. */
1154 dump_exception_spec (tree t, int flags)
1158 pp_string (cxx_pp, " throw (");
1159 if (TREE_VALUE (t) != NULL_TREE)
1162 dump_type (TREE_VALUE (t), flags);
1166 pp_separate_with_comma (cxx_pp);
1168 pp_right_paren (cxx_pp);
1172 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1173 and destructors properly. */
1176 dump_function_name (tree t, int flags)
1178 tree name = DECL_NAME (t);
1180 if (TREE_CODE (t) == TEMPLATE_DECL)
1181 t = DECL_TEMPLATE_RESULT (t);
1183 /* Don't let the user see __comp_ctor et al. */
1184 if (DECL_CONSTRUCTOR_P (t)
1185 || DECL_DESTRUCTOR_P (t))
1186 name = constructor_name (DECL_CONTEXT (t));
1188 if (DECL_DESTRUCTOR_P (t))
1190 pp_complement (cxx_pp);
1191 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1193 else if (DECL_CONV_FN_P (t))
1195 /* This cannot use the hack that the operator's return
1196 type is stashed off of its name because it may be
1197 used for error reporting. In the case of conflicting
1198 declarations, both will have the same name, yet
1199 the types will be different, hence the TREE_TYPE field
1200 of the first name will be clobbered by the second. */
1201 pp_string (cxx_pp, "operator ");
1202 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1204 else if (IDENTIFIER_OPNAME_P (name))
1205 pp_tree_identifier (cxx_pp, name);
1207 dump_decl (name, flags);
1209 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
1210 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1211 && (DECL_TEMPLATE_SPECIALIZATION (t)
1212 || TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1213 || DECL_TEMPLATE_SPECIALIZATION (DECL_TI_TEMPLATE (t))
1214 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1215 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1218 /* Dump the template parameters from the template info INFO under control of
1219 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1220 specialization (partial or complete). For partial specializations we show
1221 the specialized parameter values. For a primary template we show no
1225 dump_template_parms (tree info, int primary, int flags)
1227 tree args = info ? TI_ARGS (info) : NULL_TREE;
1229 if (primary && flags & TFF_TEMPLATE_NAME)
1231 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1232 pp_template_argument_list_start (cxx_pp);
1234 /* Be careful only to print things when we have them, so as not
1235 to crash producing error messages. */
1236 if (args && !primary)
1240 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
1241 args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
1243 len = TREE_VEC_LENGTH (args);
1245 for (ix = 0; ix != len; ix++)
1247 tree arg = TREE_VEC_ELT (args, ix);
1250 pp_separate_with_comma (cxx_pp);
1253 pp_identifier (cxx_pp, "<template parameter error>");
1255 dump_template_argument (arg, flags);
1260 tree tpl = TI_TEMPLATE (info);
1261 tree parms = DECL_TEMPLATE_PARMS (tpl);
1264 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1265 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1267 for (ix = 0; ix != len; ix++)
1269 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1272 pp_separate_with_comma (cxx_pp);
1274 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1277 pp_template_argument_list_end (cxx_pp);
1280 /* Print out a list of initializers (subr of dump_expr). */
1283 dump_expr_list (tree l, int flags)
1287 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1290 pp_separate_with_comma (cxx_pp);
1294 /* Print out an expression E under control of FLAGS. */
1297 dump_expr (tree t, int flags)
1302 switch (TREE_CODE (t))
1310 case NAMESPACE_DECL:
1312 case IDENTIFIER_NODE:
1313 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1319 pp_c_constant (pp_c_base (cxx_pp), t);
1323 pp_identifier (cxx_pp, "throw");
1324 dump_expr (TREE_OPERAND (t, 0), flags);
1328 pp_ampersand (cxx_pp);
1329 dump_type (PTRMEM_CST_CLASS (t), flags);
1330 pp_colon_colon (cxx_pp);
1331 pp_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1335 pp_left_paren (cxx_pp);
1336 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1337 pp_separate_with_comma (cxx_pp);
1338 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1339 pp_right_paren (cxx_pp);
1343 pp_left_paren (cxx_pp);
1344 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1345 pp_string (cxx_pp, " ? ");
1346 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1347 pp_string (cxx_pp, " : ");
1348 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1349 pp_right_paren (cxx_pp);
1353 if (TREE_HAS_CONSTRUCTOR (t))
1355 pp_string (cxx_pp, "new ");
1356 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1359 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1362 case AGGR_INIT_EXPR:
1364 tree fn = NULL_TREE;
1366 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
1367 fn = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
1369 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1371 if (DECL_CONSTRUCTOR_P (fn))
1372 pp_tree_identifier (cxx_pp, TYPE_IDENTIFIER (TREE_TYPE (t)));
1377 dump_expr (TREE_OPERAND (t, 0), 0);
1379 pp_left_paren (cxx_pp);
1380 if (TREE_OPERAND (t, 1))
1381 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1382 pp_right_paren (cxx_pp);
1387 tree fn = TREE_OPERAND (t, 0);
1388 tree args = TREE_OPERAND (t, 1);
1390 if (TREE_CODE (fn) == ADDR_EXPR)
1391 fn = TREE_OPERAND (fn, 0);
1393 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1395 tree ob = TREE_VALUE (args);
1396 if (TREE_CODE (ob) == ADDR_EXPR)
1398 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1401 else if (TREE_CODE (ob) != PARM_DECL
1402 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1404 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1407 args = TREE_CHAIN (args);
1409 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1410 pp_left_paren (cxx_pp);
1411 dump_expr_list (args, flags);
1412 pp_right_paren (cxx_pp);
1418 tree type = TREE_OPERAND (t, 1);
1419 tree init = TREE_OPERAND (t, 2);
1420 if (NEW_EXPR_USE_GLOBAL (t))
1421 pp_colon_colon (cxx_pp);
1422 pp_string (cxx_pp, "new ");
1423 if (TREE_OPERAND (t, 0))
1425 pp_left_paren (cxx_pp);
1426 dump_expr_list (TREE_OPERAND (t, 0), flags);
1427 pp_string (cxx_pp, ") ");
1429 if (TREE_CODE (type) == ARRAY_REF)
1430 type = build_cplus_array_type
1431 (TREE_OPERAND (type, 0),
1432 build_index_type (fold (build (MINUS_EXPR, integer_type_node,
1433 TREE_OPERAND (type, 1),
1434 integer_one_node))));
1435 dump_type (type, flags);
1438 pp_left_paren (cxx_pp);
1439 if (TREE_CODE (init) == TREE_LIST)
1440 dump_expr_list (init, flags);
1441 else if (init == void_zero_node)
1442 /* This representation indicates an empty initializer,
1443 e.g.: "new int()". */
1446 dump_expr (init, flags);
1447 pp_right_paren (cxx_pp);
1453 /* Note that this only works for G++ target exprs. If somebody
1454 builds a general TARGET_EXPR, there's no way to represent that
1455 it initializes anything other that the parameter slot for the
1456 default argument. Note we may have cleared out the first
1457 operand in expand_expr, so don't go killing ourselves. */
1458 if (TREE_OPERAND (t, 1))
1459 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1467 case TRUNC_DIV_EXPR:
1468 case TRUNC_MOD_EXPR:
1476 case TRUTH_ANDIF_EXPR:
1477 case TRUTH_ORIF_EXPR:
1484 case EXACT_DIV_EXPR:
1485 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1489 case FLOOR_DIV_EXPR:
1490 case ROUND_DIV_EXPR:
1491 dump_binary_op ("/", t, flags);
1495 case FLOOR_MOD_EXPR:
1496 case ROUND_MOD_EXPR:
1497 dump_binary_op ("%", t, flags);
1502 tree ob = TREE_OPERAND (t, 0);
1503 if (TREE_CODE (ob) == INDIRECT_REF)
1505 ob = TREE_OPERAND (ob, 0);
1506 if (TREE_CODE (ob) != PARM_DECL
1507 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1509 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1515 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1518 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1523 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1524 pp_left_bracket (cxx_pp);
1525 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1526 pp_right_bracket (cxx_pp);
1530 if (TREE_TYPE (t) && VOID_TYPE_P (TREE_TYPE (t)))
1532 pp_left_paren (cxx_pp);
1533 dump_type (TREE_TYPE (t), flags);
1534 pp_right_paren (cxx_pp);
1535 dump_expr (TREE_OPERAND (t, 0), flags);
1538 dump_unary_op ("+", t, flags);
1542 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1543 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1544 /* An ADDR_EXPR can have reference type. In that case, we
1545 shouldn't print the `&' doing so indicates to the user
1546 that the expression has pointer type. */
1548 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1549 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1551 dump_unary_op ("&", t, flags);
1555 if (TREE_HAS_CONSTRUCTOR (t))
1557 t = TREE_OPERAND (t, 0);
1558 my_friendly_assert (TREE_CODE (t) == CALL_EXPR, 237);
1559 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1560 pp_left_paren (cxx_pp);
1561 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1562 pp_right_paren (cxx_pp);
1566 if (TREE_OPERAND (t,0) != NULL_TREE
1567 && TREE_TYPE (TREE_OPERAND (t, 0))
1568 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1569 dump_expr (TREE_OPERAND (t, 0), flags);
1571 dump_unary_op ("*", t, flags);
1577 case TRUTH_NOT_EXPR:
1578 case PREDECREMENT_EXPR:
1579 case PREINCREMENT_EXPR:
1580 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1583 case POSTDECREMENT_EXPR:
1584 case POSTINCREMENT_EXPR:
1585 pp_left_paren (cxx_pp);
1586 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1587 pp_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1588 pp_right_paren (cxx_pp);
1591 case NON_LVALUE_EXPR:
1592 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1593 should be another level of INDIRECT_REF so that I don't have to do
1595 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1597 tree next = TREE_TYPE (TREE_TYPE (t));
1599 while (TREE_CODE (next) == POINTER_TYPE)
1600 next = TREE_TYPE (next);
1602 if (TREE_CODE (next) == FUNCTION_TYPE)
1604 if (flags & TFF_EXPR_IN_PARENS)
1605 pp_left_paren (cxx_pp);
1607 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1608 if (flags & TFF_EXPR_IN_PARENS)
1609 pp_right_paren (cxx_pp);
1612 /* Else fall through. */
1614 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1619 tree op = TREE_OPERAND (t, 0);
1621 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1623 /* It is a cast, but we cannot tell whether it is a
1624 reinterpret or static cast. Use the C style notation. */
1625 if (flags & TFF_EXPR_IN_PARENS)
1626 pp_left_paren (cxx_pp);
1627 pp_left_paren (cxx_pp);
1628 dump_type (TREE_TYPE (t), flags);
1629 pp_right_paren (cxx_pp);
1630 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1631 if (flags & TFF_EXPR_IN_PARENS)
1632 pp_right_paren (cxx_pp);
1635 dump_expr (op, flags);
1639 case EXPR_WITH_FILE_LOCATION:
1640 dump_expr (EXPR_WFL_NODE (t), flags);
1644 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1646 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1648 if (integer_zerop (idx))
1650 /* A NULL pointer-to-member constant. */
1651 pp_left_paren (cxx_pp);
1652 pp_left_paren (cxx_pp);
1653 dump_type (TREE_TYPE (t), flags);
1654 pp_right_paren (cxx_pp);
1655 pp_string (cxx_pp, ")0)");
1658 else if (host_integerp (idx, 0))
1661 unsigned HOST_WIDE_INT n;
1663 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1664 t = TYPE_METHOD_BASETYPE (t);
1665 virtuals = TYPE_BINFO_VIRTUALS (TYPE_MAIN_VARIANT (t));
1667 n = tree_low_cst (idx, 0);
1669 /* Map vtable index back one, to allow for the null pointer to
1673 while (n > 0 && virtuals)
1676 virtuals = TREE_CHAIN (virtuals);
1680 dump_expr (BV_FN (virtuals),
1681 flags | TFF_EXPR_IN_PARENS);
1686 if (TREE_TYPE (t) && !CONSTRUCTOR_ELTS (t))
1688 dump_type (TREE_TYPE (t), 0);
1689 pp_left_paren (cxx_pp);
1690 pp_right_paren (cxx_pp);
1694 pp_left_brace (cxx_pp);
1695 dump_expr_list (CONSTRUCTOR_ELTS (t), flags);
1696 pp_right_brace (cxx_pp);
1703 tree ob = TREE_OPERAND (t, 0);
1704 if (is_dummy_object (ob))
1706 t = TREE_OPERAND (t, 1);
1707 if (TREE_CODE (t) == FUNCTION_DECL)
1709 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1710 else if (BASELINK_P (t))
1711 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1712 flags | TFF_EXPR_IN_PARENS);
1714 dump_decl (t, flags);
1718 if (TREE_CODE (ob) == INDIRECT_REF)
1720 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1721 pp_string (cxx_pp, "->*");
1725 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1726 pp_string (cxx_pp, ".*");
1728 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1733 case TEMPLATE_PARM_INDEX:
1734 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1738 dump_type (TREE_OPERAND (t, 0), flags);
1739 pp_colon_colon (cxx_pp);
1740 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1744 if (TREE_OPERAND (t, 0) == NULL_TREE
1745 || TREE_CHAIN (TREE_OPERAND (t, 0)))
1747 dump_type (TREE_TYPE (t), flags);
1748 pp_left_paren (cxx_pp);
1749 dump_expr_list (TREE_OPERAND (t, 0), flags);
1750 pp_right_paren (cxx_pp);
1754 pp_left_paren (cxx_pp);
1755 dump_type (TREE_TYPE (t), flags);
1756 pp_string (cxx_pp, ")(");
1757 dump_expr_list (TREE_OPERAND (t, 0), flags);
1758 pp_right_paren (cxx_pp);
1762 case STATIC_CAST_EXPR:
1763 pp_string (cxx_pp, "static_cast<");
1765 case REINTERPRET_CAST_EXPR:
1766 pp_string (cxx_pp, "reinterpret_cast<");
1768 case CONST_CAST_EXPR:
1769 pp_string (cxx_pp, "const_cast<");
1771 case DYNAMIC_CAST_EXPR:
1772 pp_string (cxx_pp, "dynamic_cast<");
1774 dump_type (TREE_TYPE (t), flags);
1775 pp_string (cxx_pp, ">(");
1776 dump_expr (TREE_OPERAND (t, 0), flags);
1777 pp_right_paren (cxx_pp);
1781 dump_expr (TREE_OPERAND (t, 0), flags);
1787 if (TREE_CODE (t) == SIZEOF_EXPR)
1788 pp_string (cxx_pp, "sizeof (");
1791 my_friendly_assert (TREE_CODE (t) == ALIGNOF_EXPR, 0);
1792 pp_string (cxx_pp, "__alignof__ (");
1794 if (TYPE_P (TREE_OPERAND (t, 0)))
1795 dump_type (TREE_OPERAND (t, 0), flags);
1797 dump_expr (TREE_OPERAND (t, 0), flags);
1798 pp_right_paren (cxx_pp);
1803 pp_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
1805 dump_expr (TREE_OPERAND (t, 0), flags);
1809 pp_identifier (cxx_pp, "<unparsed>");
1812 case TRY_CATCH_EXPR:
1813 case WITH_CLEANUP_EXPR:
1814 case CLEANUP_POINT_EXPR:
1815 dump_expr (TREE_OPERAND (t, 0), flags);
1818 case PSEUDO_DTOR_EXPR:
1819 dump_expr (TREE_OPERAND (t, 2), flags);
1821 dump_type (TREE_OPERAND (t, 0), flags);
1822 pp_colon_colon (cxx_pp);
1823 pp_complement (cxx_pp);
1824 dump_type (TREE_OPERAND (t, 1), flags);
1827 case TEMPLATE_ID_EXPR:
1828 dump_decl (t, flags);
1832 /* We don't yet have a way of dumping statements in a
1833 human-readable format. */
1834 pp_string (cxx_pp, "({...})");
1838 pp_left_brace (cxx_pp);
1839 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1840 pp_right_brace (cxx_pp);
1844 pp_string (cxx_pp, "while (1) { ");
1845 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1846 pp_right_brace (cxx_pp);
1850 pp_string (cxx_pp, "if (");
1851 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1852 pp_string (cxx_pp, ") break; ");
1856 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
1859 case EMPTY_CLASS_EXPR:
1860 dump_type (TREE_TYPE (t), flags);
1861 pp_left_paren (cxx_pp);
1862 pp_right_paren (cxx_pp);
1865 case NON_DEPENDENT_EXPR:
1866 dump_expr (TREE_OPERAND (t, 0), flags);
1869 /* This list is incomplete, but should suffice for now.
1870 It is very important that `sorry' does not call
1871 `report_error_function'. That could cause an infinite loop. */
1873 pp_unsupported_tree (cxx_pp, t);
1874 /* fall through to ERROR_MARK... */
1876 pp_identifier (cxx_pp, "<expression error>");
1882 dump_binary_op (const char *opstring, tree t, int flags)
1884 pp_left_paren (cxx_pp);
1885 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1888 pp_identifier (cxx_pp, opstring);
1890 pp_identifier (cxx_pp, "<unknown operator>");
1892 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1893 pp_right_paren (cxx_pp);
1897 dump_unary_op (const char *opstring, tree t, int flags)
1899 if (flags & TFF_EXPR_IN_PARENS)
1900 pp_left_paren (cxx_pp);
1901 pp_identifier (cxx_pp, opstring);
1902 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1903 if (flags & TFF_EXPR_IN_PARENS)
1904 pp_right_paren (cxx_pp);
1907 /* Exported interface to stringifying types, exprs and decls under TFF_*
1911 type_as_string (tree typ, int flags)
1913 pp_clear_output_area (cxx_pp);
1914 dump_type (typ, flags);
1915 return pp_formatted_text (cxx_pp);
1919 expr_as_string (tree decl, int flags)
1921 pp_clear_output_area (cxx_pp);
1922 dump_expr (decl, flags);
1923 return pp_formatted_text (cxx_pp);
1927 decl_as_string (tree decl, int flags)
1929 pp_clear_output_area (cxx_pp);
1930 dump_decl (decl, flags);
1931 return pp_formatted_text (cxx_pp);
1935 context_as_string (tree context, int flags)
1937 pp_clear_output_area (cxx_pp);
1938 dump_scope (context, flags);
1939 return pp_formatted_text (cxx_pp);
1942 /* Generate the three forms of printable names for cxx_printable_name. */
1945 lang_decl_name (tree decl, int v)
1948 return decl_as_string (decl, TFF_DECL_SPECIFIERS);
1950 pp_clear_output_area (cxx_pp);
1951 if (v == 1 && DECL_CLASS_SCOPE_P (decl))
1953 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
1954 pp_colon_colon (cxx_pp);
1957 if (TREE_CODE (decl) == FUNCTION_DECL)
1958 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
1960 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
1962 return pp_formatted_text (cxx_pp);
1966 location_of (tree t)
1968 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
1969 t = DECL_CONTEXT (t);
1970 else if (TYPE_P (t))
1971 t = TYPE_MAIN_DECL (t);
1972 else if (TREE_CODE (t) == OVERLOAD)
1973 t = OVL_FUNCTION (t);
1975 return DECL_SOURCE_LOCATION (t);
1978 /* Now the interfaces from error et al to dump_type et al. Each takes an
1979 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
1983 decl_to_string (tree decl, int verbose)
1987 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
1988 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
1989 flags = TFF_CLASS_KEY_OR_ENUM;
1991 flags |= TFF_DECL_SPECIFIERS;
1992 else if (TREE_CODE (decl) == FUNCTION_DECL)
1993 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
1994 flags |= TFF_TEMPLATE_HEADER;
1996 pp_clear_output_area (cxx_pp);
1997 dump_decl (decl, flags);
1998 return pp_formatted_text (cxx_pp);
2002 expr_to_string (tree decl)
2004 pp_clear_output_area (cxx_pp);
2005 dump_expr (decl, 0);
2006 return pp_formatted_text (cxx_pp);
2010 fndecl_to_string (tree fndecl, int verbose)
2014 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS;
2016 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2017 pp_clear_output_area (cxx_pp);
2018 dump_decl (fndecl, flags);
2019 return pp_formatted_text (cxx_pp);
2024 code_to_string (enum tree_code c)
2026 return tree_code_name [c];
2030 language_to_string (enum languages c)
2037 case lang_cplusplus:
2049 /* Return the proper printed version of a parameter to a C++ function. */
2052 parm_to_string (int p)
2054 pp_clear_output_area (cxx_pp);
2056 pp_string (cxx_pp, "'this'");
2058 pp_decimal_int (cxx_pp, p + 1);
2059 return pp_formatted_text (cxx_pp);
2063 op_to_string (enum tree_code p)
2065 tree id = operator_name_info[(int) p].identifier;
2066 return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2070 type_to_string (tree typ, int verbose)
2074 flags |= TFF_CLASS_KEY_OR_ENUM;
2075 flags |= TFF_TEMPLATE_HEADER;
2077 pp_clear_output_area (cxx_pp);
2078 dump_type (typ, flags);
2079 return pp_formatted_text (cxx_pp);
2083 assop_to_string (enum tree_code p)
2085 tree id = assignment_operator_name_info[(int) p].identifier;
2086 return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2090 args_to_string (tree p, int verbose)
2094 flags |= TFF_CLASS_KEY_OR_ENUM;
2099 if (TYPE_P (TREE_VALUE (p)))
2100 return type_as_string (p, flags);
2102 pp_clear_output_area (cxx_pp);
2103 for (; p; p = TREE_CHAIN (p))
2105 if (TREE_VALUE (p) == null_node)
2106 pp_identifier (cxx_pp, "NULL");
2108 dump_type (error_type (TREE_VALUE (p)), flags);
2110 pp_separate_with_comma (cxx_pp);
2112 return pp_formatted_text (cxx_pp);
2116 cv_to_string (tree p, int v)
2118 pp_clear_output_area (cxx_pp);
2119 dump_qualifiers (p, v ? before : none);
2120 return pp_formatted_text (cxx_pp);
2123 /* Langhook for print_error_function. */
2125 cxx_print_error_function (diagnostic_context *context, const char *file)
2127 lhd_print_error_function (context, file);
2128 pp_base_set_prefix (context->printer, file);
2129 maybe_print_instantiation_context (context);
2133 cp_diagnostic_starter (diagnostic_context *context,
2134 diagnostic_info *diagnostic)
2136 diagnostic_report_current_module (context);
2137 cp_print_error_function (context, diagnostic);
2138 maybe_print_instantiation_context (context);
2139 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2143 cp_diagnostic_finalizer (diagnostic_context *context,
2144 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2146 pp_base_destroy_prefix (context->printer);
2149 /* Print current function onto BUFFER, in the process of reporting
2150 a diagnostic message. Called from cp_diagnostic_starter. */
2152 cp_print_error_function (diagnostic_context *context,
2153 diagnostic_info *diagnostic)
2155 if (diagnostic_last_function_changed (context))
2157 const char *old_prefix = context->printer->prefix;
2158 char *new_prefix = diagnostic->location.file
2159 ? file_name_as_prefix (diagnostic->location.file)
2162 pp_base_set_prefix (context->printer, new_prefix);
2164 if (current_function_decl == NULL)
2165 pp_base_string (context->printer, "At global scope:");
2167 pp_printf (context->printer, "In %s `%s':",
2168 function_category (current_function_decl),
2169 cxx_printable_name (current_function_decl, 2));
2170 pp_base_newline (context->printer);
2172 diagnostic_set_last_function (context);
2173 pp_base_destroy_prefix (context->printer);
2174 context->printer->prefix = old_prefix;
2178 /* Returns a description of FUNCTION using standard terminology. */
2180 function_category (tree fn)
2182 if (DECL_FUNCTION_MEMBER_P (fn))
2184 if (DECL_STATIC_FUNCTION_P (fn))
2185 return "static member function";
2186 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2187 return "copy constructor";
2188 else if (DECL_CONSTRUCTOR_P (fn))
2189 return "constructor";
2190 else if (DECL_DESTRUCTOR_P (fn))
2191 return "destructor";
2193 return "member function";
2199 /* Report the full context of a current template instantiation,
2202 print_instantiation_full_context (diagnostic_context *context)
2204 tree p = current_instantiation ();
2205 location_t location = input_location;
2209 if (current_function_decl != TINST_DECL (p)
2210 && current_function_decl != NULL_TREE)
2211 /* We can get here during the processing of some synthesized
2212 method. Then, TINST_DECL (p) will be the function that's causing
2217 if (current_function_decl == TINST_DECL (p))
2218 /* Avoid redundancy with the the "In function" line. */;
2220 pp_verbatim (context->printer,
2221 "%s: In instantiation of `%s':\n", location.file,
2222 decl_as_string (TINST_DECL (p),
2223 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2225 location.line = TINST_LINE (p);
2226 location.file = TINST_FILE (p);
2231 print_instantiation_partial_context (context, p, location);
2234 /* Same as above but less verbose. */
2236 print_instantiation_partial_context (diagnostic_context *context,
2237 tree t, location_t loc)
2239 for (; t; t = TREE_CHAIN (t))
2241 pp_verbatim (context->printer, "%s:%d: instantiated from `%s'\n",
2243 decl_as_string (TINST_DECL (t),
2244 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2245 loc.line = TINST_LINE (t);
2246 loc.file = TINST_FILE (t);
2248 pp_verbatim (context->printer, "%s:%d: instantiated from here\n",
2249 loc.file, loc.line);
2252 /* Called from cp_thing to print the template context for an error. */
2254 maybe_print_instantiation_context (diagnostic_context *context)
2256 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2259 record_last_problematic_instantiation ();
2260 print_instantiation_full_context (context);
2263 /* Report the bare minimum context of a template instantiation. */
2265 print_instantiation_context (void)
2267 print_instantiation_partial_context
2268 (global_dc, current_instantiation (), input_location);
2269 diagnostic_flush_buffer (global_dc);
2272 /* Called from output_format -- during diagnostic message processing --
2273 to handle C++ specific format specifier with the following meanings:
2274 %A function argument-list.
2278 %F function declaration.
2279 %L language as used in extern "lang".
2281 %P function parameter whose position is indicated by an integer.
2282 %Q assignment operator.
2286 cp_printer (pretty_printer *pp, text_info *text)
2290 #define next_tree va_arg (*text->args_ptr, tree)
2291 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2292 #define next_lang va_arg (*text->args_ptr, enum languages)
2293 #define next_int va_arg (*text->args_ptr, int)
2295 if (*text->format_spec == '+')
2296 ++text->format_spec;
2297 if (*text->format_spec == '#')
2300 ++text->format_spec;
2303 switch (*text->format_spec)
2305 case 'A': result = args_to_string (next_tree, verbose); break;
2306 case 'C': result = code_to_string (next_tcode); break;
2307 case 'D': result = decl_to_string (next_tree, verbose); break;
2308 case 'E': result = expr_to_string (next_tree); break;
2309 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2310 case 'L': result = language_to_string (next_lang); break;
2311 case 'O': result = op_to_string (next_tcode); break;
2312 case 'P': result = parm_to_string (next_int); break;
2313 case 'Q': result = assop_to_string (next_tcode); break;
2314 case 'T': result = type_to_string (next_tree, verbose); break;
2315 case 'V': result = cv_to_string (next_tree, verbose); break;
2321 pp_base_string (pp, result);
2330 pp_non_consecutive_character (cxx_pretty_printer *pp, int c)
2332 const char *p = pp_last_position_in_text (pp);
2334 if (p != NULL && *p == c)
2336 pp_character (pp, c);
2339 /* These are temporary wrapper functions which handle the historic
2340 behavior of cp_*_at. */
2343 locate_error (const char *msgid, va_list ap)
2349 for (f = msgid; *f; f++)
2362 /* Just ignore these possibilities. */
2365 case 'd': (void) va_arg (ap, int); break;
2366 case 's': (void) va_arg (ap, char *); break;
2367 case 'L': (void) va_arg (ap, enum languages); break;
2370 case 'Q': (void) va_arg (ap, enum tree_code); break;
2372 /* These take a tree, which may be where the error is
2380 t = va_arg (ap, tree);
2386 errorcount = 0; /* damn ICE suppression */
2387 internal_error ("unexpected letter `%c' in locate_error\n", *f);
2393 here = va_arg (ap, tree);
2400 cp_error_at (const char *msgid, ...)
2403 diagnostic_info diagnostic;
2406 va_start (ap, msgid);
2407 here = locate_error (msgid, ap);
2410 va_start (ap, msgid);
2411 diagnostic_set_info (&diagnostic, msgid, &ap,
2412 location_of (here), DK_ERROR);
2413 report_diagnostic (&diagnostic);
2418 cp_warning_at (const char *msgid, ...)
2421 diagnostic_info diagnostic;
2424 va_start (ap, msgid);
2425 here = locate_error (msgid, ap);
2428 va_start (ap, msgid);
2429 diagnostic_set_info (&diagnostic, msgid, &ap,
2430 location_of (here), DK_WARNING);
2431 report_diagnostic (&diagnostic);
2436 cp_pedwarn_at (const char *msgid, ...)
2439 diagnostic_info diagnostic;
2442 va_start (ap, msgid);
2443 here = locate_error (msgid, ap);
2446 va_start (ap, msgid);
2447 diagnostic_set_info (&diagnostic, msgid, &ap,
2448 location_of (here), pedantic_error_kind());
2449 report_diagnostic (&diagnostic);