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, 2005 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, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
24 #include "coretypes.h"
31 #include "diagnostic.h"
32 #include "langhooks-def.h"
33 #include "cxx-pretty-print.h"
35 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
37 /* The global buffer where we dump everything. It is there only for
38 transitional purpose. It is expected, in the near future, to be
39 completely removed. */
40 static cxx_pretty_printer scratch_pretty_printer;
41 #define cxx_pp (&scratch_pretty_printer)
43 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
45 static const char *args_to_string (tree, int);
46 static const char *assop_to_string (enum tree_code);
47 static const char *code_to_string (enum tree_code);
48 static const char *cv_to_string (tree, int);
49 static const char *decl_to_string (tree, int);
50 static const char *expr_to_string (tree);
51 static const char *fndecl_to_string (tree, int);
52 static const char *op_to_string (enum tree_code);
53 static const char *parm_to_string (int);
54 static const char *type_to_string (tree, int);
56 static void dump_type (tree, int);
57 static void dump_typename (tree, int);
58 static void dump_simple_decl (tree, tree, int);
59 static void dump_decl (tree, int);
60 static void dump_template_decl (tree, int);
61 static void dump_function_decl (tree, int);
62 static void dump_expr (tree, int);
63 static void dump_unary_op (const char *, tree, int);
64 static void dump_binary_op (const char *, tree, int);
65 static void dump_aggr_type (tree, int);
66 static void dump_type_prefix (tree, int);
67 static void dump_type_suffix (tree, int);
68 static void dump_function_name (tree, int);
69 static void dump_expr_list (tree, int);
70 static void dump_global_iord (tree);
71 static void dump_parameters (tree, int);
72 static void dump_exception_spec (tree, int);
73 static void dump_template_argument (tree, int);
74 static void dump_template_argument_list (tree, int);
75 static void dump_template_parameter (tree, int);
76 static void dump_template_bindings (tree, tree);
77 static void dump_scope (tree, int);
78 static void dump_template_parms (tree, int, int);
80 static const char *function_category (tree);
81 static void maybe_print_instantiation_context (diagnostic_context *);
82 static void print_instantiation_full_context (diagnostic_context *);
83 static void print_instantiation_partial_context (diagnostic_context *,
85 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
86 static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
87 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
89 static bool cp_printer (pretty_printer *, text_info *, const char *,
90 int, bool, bool, bool);
91 static location_t location_of (tree);
96 diagnostic_starter (global_dc) = cp_diagnostic_starter;
97 diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer;
98 diagnostic_format_decoder (global_dc) = cp_printer;
100 pp_construct (pp_base (cxx_pp), NULL, 0);
101 pp_cxx_pretty_printer_init (cxx_pp);
104 /* Dump a scope, if deemed necessary. */
107 dump_scope (tree scope, int flags)
109 int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF));
111 if (scope == NULL_TREE)
114 if (TREE_CODE (scope) == NAMESPACE_DECL)
116 if (scope != global_namespace)
118 dump_decl (scope, f);
119 pp_cxx_colon_colon (cxx_pp);
122 else if (AGGREGATE_TYPE_P (scope))
124 dump_type (scope, f);
125 pp_cxx_colon_colon (cxx_pp);
127 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
129 dump_function_decl (scope, f);
130 pp_cxx_colon_colon (cxx_pp);
134 /* Dump the template ARGument under control of FLAGS. */
137 dump_template_argument (tree arg, int flags)
139 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
140 dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
142 dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
145 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
149 dump_template_argument_list (tree args, int flags)
151 int n = TREE_VEC_LENGTH (args);
155 for (i = 0; i< n; ++i)
158 pp_separate_with_comma (cxx_pp);
159 dump_template_argument (TREE_VEC_ELT (args, i), flags);
164 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
167 dump_template_parameter (tree parm, int flags)
169 tree p = TREE_VALUE (parm);
170 tree a = TREE_PURPOSE (parm);
172 if (TREE_CODE (p) == TYPE_DECL)
174 if (flags & TFF_DECL_SPECIFIERS)
176 pp_cxx_identifier (cxx_pp, "class");
178 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
180 else if (DECL_NAME (p))
181 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
183 pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
186 dump_decl (p, flags | TFF_DECL_SPECIFIERS);
188 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
190 pp_cxx_whitespace (cxx_pp);
192 pp_cxx_whitespace (cxx_pp);
193 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
194 dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
196 dump_expr (a, flags | TFF_EXPR_IN_PARENS);
200 /* Dump, under control of FLAGS, a template-parameter-list binding.
201 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
205 dump_template_bindings (tree parms, tree args)
211 tree p = TREE_VALUE (parms);
212 int lvl = TMPL_PARMS_DEPTH (parms);
216 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
218 tree arg = NULL_TREE;
220 /* Don't crash if we had an invalid argument list. */
221 if (TMPL_ARGS_DEPTH (args) >= lvl)
223 tree lvl_args = TMPL_ARGS_LEVEL (args, lvl);
224 if (NUM_TMPL_ARGS (lvl_args) > arg_idx)
225 arg = TREE_VEC_ELT (lvl_args, arg_idx);
229 pp_separate_with_comma (cxx_pp);
230 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
231 pp_cxx_whitespace (cxx_pp);
233 pp_cxx_whitespace (cxx_pp);
235 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
237 pp_identifier (cxx_pp, "<missing>");
243 parms = TREE_CHAIN (parms);
247 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
251 dump_type (tree t, int flags)
256 if (TYPE_PTRMEMFUNC_P (t))
259 switch (TREE_CODE (t))
262 pp_identifier (cxx_pp, "<unknown type>");
266 /* A list of function parms. */
267 dump_parameters (t, flags);
270 case IDENTIFIER_NODE:
271 pp_cxx_tree_identifier (cxx_pp, t);
275 dump_type (BINFO_TYPE (t), flags);
281 dump_aggr_type (t, flags);
285 if (flags & TFF_CHASE_TYPEDEF)
287 dump_type (DECL_ORIGINAL_TYPE (t)
288 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
291 /* Else fall through. */
295 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
304 pp_type_specifier_seq (cxx_pp, t);
307 case TEMPLATE_TEMPLATE_PARM:
308 /* For parameters inside template signature. */
309 if (TYPE_IDENTIFIER (t))
310 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
312 pp_cxx_canonical_template_parameter (cxx_pp, t);
315 case BOUND_TEMPLATE_TEMPLATE_PARM:
317 tree args = TYPE_TI_ARGS (t);
318 pp_cxx_cv_qualifier_seq (cxx_pp, t);
319 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
320 pp_cxx_begin_template_argument_list (cxx_pp);
321 dump_template_argument_list (args, flags);
322 pp_cxx_end_template_argument_list (cxx_pp);
326 case TEMPLATE_TYPE_PARM:
327 pp_cxx_cv_qualifier_seq (cxx_pp, t);
328 if (TYPE_IDENTIFIER (t))
329 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
331 pp_cxx_canonical_template_parameter
332 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
335 /* This is not always necessary for pointers and such, but doing this
336 reduces code size. */
345 dump_type_prefix (t, flags);
346 dump_type_suffix (t, flags);
350 pp_cxx_cv_qualifier_seq (cxx_pp, t);
351 pp_cxx_identifier (cxx_pp,
352 TYPENAME_IS_ENUM_P (t) ? "enum"
353 : TYPENAME_IS_CLASS_P (t) ? "class"
355 dump_typename (t, flags);
358 case UNBOUND_CLASS_TEMPLATE:
359 dump_type (TYPE_CONTEXT (t), flags);
360 pp_cxx_colon_colon (cxx_pp);
361 pp_cxx_identifier (cxx_pp, "template");
362 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
366 pp_cxx_identifier (cxx_pp, "__typeof__");
367 pp_cxx_whitespace (cxx_pp);
368 pp_cxx_left_paren (cxx_pp);
369 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
370 pp_cxx_right_paren (cxx_pp);
374 pp_unsupported_tree (cxx_pp, t);
375 /* Fall through to error. */
378 pp_identifier (cxx_pp, "<type error>");
383 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
387 dump_typename (tree t, int flags)
389 tree ctx = TYPE_CONTEXT (t);
391 if (TREE_CODE (ctx) == TYPENAME_TYPE)
392 dump_typename (ctx, flags);
394 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
395 pp_cxx_colon_colon (cxx_pp);
396 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
399 /* Return the name of the supplied aggregate, or enumeral type. */
402 class_key_or_enum_as_string (tree t)
404 if (TREE_CODE (t) == ENUMERAL_TYPE)
406 else if (TREE_CODE (t) == UNION_TYPE)
408 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
414 /* Print out a class declaration T under the control of FLAGS,
415 in the form `class foo'. */
418 dump_aggr_type (tree t, int flags)
421 const char *variety = class_key_or_enum_as_string (t);
425 pp_cxx_cv_qualifier_seq (cxx_pp, t);
427 if (flags & TFF_CLASS_KEY_OR_ENUM)
428 pp_cxx_identifier (cxx_pp, variety);
430 if (flags & TFF_CHASE_TYPEDEF)
431 t = TYPE_MAIN_VARIANT (t);
433 name = TYPE_NAME (t);
437 typdef = !DECL_ARTIFICIAL (name);
438 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
439 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
440 && (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
441 || TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
442 || DECL_TEMPLATE_SPECIALIZATION (CLASSTYPE_TI_TEMPLATE (t))
443 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
444 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
447 /* Because the template names are mangled, we have to locate
448 the most general template, and use that name. */
449 tree tpl = CLASSTYPE_TI_TEMPLATE (t);
451 while (DECL_TEMPLATE_INFO (tpl))
452 tpl = DECL_TI_TEMPLATE (tpl);
455 name = DECL_NAME (name);
458 if (name == 0 || ANON_AGGRNAME_P (name))
460 if (flags & TFF_CLASS_KEY_OR_ENUM)
461 pp_identifier (cxx_pp, "<anonymous>");
463 pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety);
466 pp_cxx_tree_identifier (cxx_pp, name);
468 dump_template_parms (TYPE_TEMPLATE_INFO (t),
469 !CLASSTYPE_USE_TEMPLATE (t),
470 flags & ~TFF_TEMPLATE_HEADER);
473 /* Dump into the obstack the initial part of the output for a given type.
474 This is necessary when dealing with things like functions returning
477 return type of `int (* fee ())()': pointer -> function -> int. Both
478 pointer (and reference and offset) and function (and member) types must
479 deal with prefix and suffix.
481 Arrays must also do this for DECL nodes, like int a[], and for things like
485 dump_type_prefix (tree t, int flags)
487 if (TYPE_PTRMEMFUNC_P (t))
489 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
493 switch (TREE_CODE (t))
498 tree sub = TREE_TYPE (t);
500 dump_type_prefix (sub, flags);
501 if (TREE_CODE (sub) == ARRAY_TYPE)
503 pp_cxx_whitespace (cxx_pp);
504 pp_cxx_left_paren (cxx_pp);
506 pp_character (cxx_pp, "&*"[TREE_CODE (t) == POINTER_TYPE]);
507 pp_base (cxx_pp)->padding = pp_before;
508 pp_cxx_cv_qualifier_seq (cxx_pp, t);
514 dump_type_prefix (TREE_TYPE (t), flags);
515 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
517 pp_maybe_space (cxx_pp);
518 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
519 pp_cxx_left_paren (cxx_pp);
520 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
521 pp_cxx_colon_colon (cxx_pp);
523 pp_cxx_star (cxx_pp);
524 pp_cxx_cv_qualifier_seq (cxx_pp, t);
525 pp_base (cxx_pp)->padding = pp_before;
528 /* Can only be reached through function pointer -- this would not be
529 correct if FUNCTION_DECLs used it. */
531 dump_type_prefix (TREE_TYPE (t), flags);
532 pp_maybe_space (cxx_pp);
533 pp_cxx_left_paren (cxx_pp);
537 dump_type_prefix (TREE_TYPE (t), flags);
538 pp_maybe_space (cxx_pp);
539 pp_cxx_left_paren (cxx_pp);
540 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
541 pp_cxx_colon_colon (cxx_pp);
545 dump_type_prefix (TREE_TYPE (t), flags);
549 case IDENTIFIER_NODE:
554 case TEMPLATE_TYPE_PARM:
555 case TEMPLATE_TEMPLATE_PARM:
556 case BOUND_TEMPLATE_TEMPLATE_PARM:
567 dump_type (t, flags);
568 pp_base (cxx_pp)->padding = pp_before;
572 pp_unsupported_tree (cxx_pp, t);
575 pp_identifier (cxx_pp, "<typeprefixerror>");
580 /* Dump the suffix of type T, under control of FLAGS. This is the part
581 which appears after the identifier (or function parms). */
584 dump_type_suffix (tree t, int flags)
586 if (TYPE_PTRMEMFUNC_P (t))
587 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
589 switch (TREE_CODE (t))
594 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
595 pp_cxx_right_paren (cxx_pp);
596 dump_type_suffix (TREE_TYPE (t), flags);
599 /* Can only be reached through function pointer. */
604 pp_cxx_right_paren (cxx_pp);
605 arg = TYPE_ARG_TYPES (t);
606 if (TREE_CODE (t) == METHOD_TYPE)
607 arg = TREE_CHAIN (arg);
609 /* Function pointers don't have default args. Not in standard C++,
610 anyway; they may in g++, but we'll just pretend otherwise. */
611 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
613 if (TREE_CODE (t) == METHOD_TYPE)
614 pp_cxx_cv_qualifier_seq
615 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
617 pp_cxx_cv_qualifier_seq(cxx_pp, t);
618 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
619 dump_type_suffix (TREE_TYPE (t), flags);
624 pp_maybe_space (cxx_pp);
625 pp_cxx_left_bracket (cxx_pp);
628 if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0))
630 (cxx_pp, tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1);
631 else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR)
632 dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0),
633 flags & ~TFF_EXPR_IN_PARENS);
635 dump_expr (fold (cp_build_binary_op
636 (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)),
638 flags & ~TFF_EXPR_IN_PARENS);
640 pp_cxx_right_bracket (cxx_pp);
641 dump_type_suffix (TREE_TYPE (t), flags);
645 case IDENTIFIER_NODE:
650 case TEMPLATE_TYPE_PARM:
651 case TEMPLATE_TEMPLATE_PARM:
652 case BOUND_TEMPLATE_TEMPLATE_PARM:
666 pp_unsupported_tree (cxx_pp, t);
668 /* Don't mark it here, we should have already done in
675 dump_global_iord (tree t)
677 const char *p = NULL;
679 if (DECL_GLOBAL_CTOR_P (t))
681 else if (DECL_GLOBAL_DTOR_P (t))
686 pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename);
690 dump_simple_decl (tree t, tree type, int flags)
692 if (flags & TFF_DECL_SPECIFIERS)
694 dump_type_prefix (type, flags);
695 pp_maybe_space (cxx_pp);
697 if (!DECL_INITIAL (t) || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX)
698 dump_scope (CP_DECL_CONTEXT (t), flags);
700 dump_decl (DECL_NAME (t), flags);
702 pp_identifier (cxx_pp, "<anonymous>");
703 if (flags & TFF_DECL_SPECIFIERS)
704 dump_type_suffix (type, flags);
707 /* Dump a human readable string for the decl T under control of FLAGS. */
710 dump_decl (tree t, int flags)
715 switch (TREE_CODE (t))
718 /* Don't say 'typedef class A' */
719 if (DECL_ARTIFICIAL (t))
721 if ((flags & TFF_DECL_SPECIFIERS)
722 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
723 /* Say `class T' not just `T'. */
724 pp_cxx_identifier (cxx_pp, "class");
726 dump_type (TREE_TYPE (t), flags);
729 if (flags & TFF_DECL_SPECIFIERS)
730 pp_cxx_identifier (cxx_pp, "typedef");
731 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
732 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
737 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
739 pp_string (cxx_pp, "vtable for ");
740 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
741 dump_type (DECL_CONTEXT (t), flags);
744 /* Else fall through. */
748 dump_simple_decl (t, TREE_TYPE (t), flags);
752 pp_string (cxx_pp, "<return value> ");
753 dump_simple_decl (t, TREE_TYPE (t), flags);
757 if (flags & TFF_DECL_SPECIFIERS)
758 pp_cxx_declaration (cxx_pp, t);
761 dump_scope (CP_DECL_CONTEXT (t), flags);
762 if (DECL_NAME (t) == NULL_TREE)
763 pp_identifier (cxx_pp, "<unnamed>");
765 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
770 pp_expression (cxx_pp, t);
774 dump_decl (TREE_OPERAND (t, 0), flags);
775 pp_cxx_left_bracket (cxx_pp);
776 dump_decl (TREE_OPERAND (t, 1), flags);
777 pp_cxx_right_bracket (cxx_pp);
780 /* So that we can do dump_decl on an aggr type. */
784 dump_type (t, flags);
788 /* This is a pseudo destructor call which has not been folded into
789 a PSEUDO_DTOR_EXPR yet. */
790 pp_cxx_complement (cxx_pp);
791 dump_type (TREE_OPERAND (t, 0), flags);
798 /* These special cases are duplicated here so that other functions
799 can feed identifiers to error and get them demangled properly. */
800 case IDENTIFIER_NODE:
801 if (IDENTIFIER_TYPENAME_P (t))
803 pp_cxx_identifier (cxx_pp, "operator");
804 /* Not exactly IDENTIFIER_TYPE_VALUE. */
805 dump_type (TREE_TYPE (t), flags);
809 pp_cxx_tree_identifier (cxx_pp, t);
816 if (DECL_CLASS_SCOPE_P (t))
818 dump_type (DECL_CONTEXT (t), flags);
819 pp_cxx_colon_colon (cxx_pp);
821 else if (DECL_CONTEXT (t))
823 dump_decl (DECL_CONTEXT (t), flags);
824 pp_cxx_colon_colon (cxx_pp);
826 dump_decl (DECL_NAME (t), flags);
830 /* If there's only one function, just treat it like an ordinary
836 if (! DECL_LANG_SPECIFIC (t))
837 pp_identifier (cxx_pp, "<built-in>");
838 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
839 dump_global_iord (t);
841 dump_function_decl (t, flags);
845 dump_template_decl (t, flags);
848 case TEMPLATE_ID_EXPR:
850 tree name = TREE_OPERAND (t, 0);
852 if (is_overloaded_fn (name))
853 name = DECL_NAME (get_first_fn (name));
854 dump_decl (name, flags);
855 pp_cxx_begin_template_argument_list (cxx_pp);
856 if (TREE_OPERAND (t, 1))
857 dump_template_argument_list (TREE_OPERAND (t, 1), flags);
858 pp_cxx_end_template_argument_list (cxx_pp);
863 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
867 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
868 || (DECL_INITIAL (t) &&
869 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
870 dump_simple_decl (t, TREE_TYPE (t), flags);
871 else if (DECL_NAME (t))
872 dump_decl (DECL_NAME (t), flags);
873 else if (DECL_INITIAL (t))
874 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
876 pp_identifier (cxx_pp, "<enumerator>");
880 pp_cxx_identifier (cxx_pp, "using");
881 dump_type (DECL_INITIAL (t), flags);
882 pp_cxx_colon_colon (cxx_pp);
883 dump_decl (DECL_NAME (t), flags);
887 dump_decl (BASELINK_FUNCTIONS (t), flags);
890 case NON_DEPENDENT_EXPR:
891 dump_expr (t, flags);
894 case TEMPLATE_TYPE_PARM:
895 if (flags & TFF_DECL_SPECIFIERS)
896 pp_cxx_declaration (cxx_pp, t);
898 pp_type_id (cxx_pp, t);
902 pp_unsupported_tree (cxx_pp, t);
903 /* Fall through to error. */
906 pp_identifier (cxx_pp, "<declaration error>");
911 /* Dump a template declaration T under control of FLAGS. This means the
912 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
915 dump_template_decl (tree t, int flags)
917 tree orig_parms = DECL_TEMPLATE_PARMS (t);
921 if (flags & TFF_TEMPLATE_HEADER)
923 for (parms = orig_parms = nreverse (orig_parms);
925 parms = TREE_CHAIN (parms))
927 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
928 int len = TREE_VEC_LENGTH (inner_parms);
930 pp_cxx_identifier (cxx_pp, "template");
931 pp_cxx_begin_template_argument_list (cxx_pp);
933 /* If we've shown the template prefix, we'd better show the
934 parameters' and decl's type too. */
935 flags |= TFF_DECL_SPECIFIERS;
937 for (i = 0; i < len; i++)
940 pp_separate_with_comma (cxx_pp);
941 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
943 pp_cxx_end_template_argument_list (cxx_pp);
944 pp_cxx_whitespace (cxx_pp);
946 nreverse(orig_parms);
948 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
949 /* Say `template<arg> class TT' not just `template<arg> TT'. */
950 pp_cxx_identifier (cxx_pp, "class");
953 if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
954 dump_type (TREE_TYPE (t),
955 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
956 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
957 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
958 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
961 gcc_assert (TREE_TYPE (t));
962 switch (NEXT_CODE (t))
966 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
969 /* This case can occur with some invalid code. */
970 dump_type (TREE_TYPE (t),
971 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
972 | (flags & TFF_DECL_SPECIFIERS
973 ? TFF_CLASS_KEY_OR_ENUM : 0));
978 /* Pretty print a function decl. There are several ways we want to print a
979 function declaration. The TFF_ bits in FLAGS tells us how to behave.
980 As error can only apply the '#' flag once to give 0 and 1 for V, there
981 is %D which doesn't print the throw specs, and %F which does. */
984 dump_function_decl (tree t, int flags)
988 tree cname = NULL_TREE;
989 tree template_args = NULL_TREE;
990 tree template_parms = NULL_TREE;
991 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
993 if (TREE_CODE (t) == TEMPLATE_DECL)
994 t = DECL_TEMPLATE_RESULT (t);
996 /* Pretty print template instantiations only. */
997 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t))
1001 template_args = DECL_TI_ARGS (t);
1002 tmpl = most_general_template (t);
1003 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1005 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1010 fntype = TREE_TYPE (t);
1011 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1013 if (DECL_CLASS_SCOPE_P (t))
1014 cname = DECL_CONTEXT (t);
1015 /* This is for partially instantiated template methods. */
1016 else if (TREE_CODE (fntype) == METHOD_TYPE)
1017 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1019 if (!(flags & TFF_DECL_SPECIFIERS))
1021 else if (DECL_STATIC_FUNCTION_P (t))
1022 pp_cxx_identifier (cxx_pp, "static");
1023 else if (DECL_VIRTUAL_P (t))
1024 pp_cxx_identifier (cxx_pp, "virtual");
1026 /* Print the return type? */
1028 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1029 && !DECL_DESTRUCTOR_P (t);
1031 dump_type_prefix (TREE_TYPE (fntype), flags);
1033 /* Print the function name. */
1036 dump_type (cname, flags);
1037 pp_cxx_colon_colon (cxx_pp);
1040 dump_scope (CP_DECL_CONTEXT (t), flags);
1042 dump_function_name (t, flags);
1044 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1046 dump_parameters (parmtypes, flags);
1048 if (TREE_CODE (fntype) == METHOD_TYPE)
1050 pp_base (cxx_pp)->padding = pp_before;
1051 pp_cxx_cv_qualifier_seq
1052 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1055 if (flags & TFF_EXCEPTION_SPECIFICATION)
1057 pp_base (cxx_pp)->padding = pp_before;
1058 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
1062 dump_type_suffix (TREE_TYPE (fntype), flags);
1065 /* If T is a template instantiation, dump the parameter binding. */
1066 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1068 pp_cxx_whitespace (cxx_pp);
1069 pp_cxx_left_bracket (cxx_pp);
1070 pp_cxx_identifier (cxx_pp, "with");
1071 pp_cxx_whitespace (cxx_pp);
1072 dump_template_bindings (template_parms, template_args);
1073 pp_cxx_right_bracket (cxx_pp);
1077 /* Print a parameter list. If this is for a member function, the
1078 member object ptr (and any other hidden args) should have
1079 already been removed. */
1082 dump_parameters (tree parmtypes, int flags)
1086 pp_cxx_left_paren (cxx_pp);
1088 for (first = 1; parmtypes != void_list_node;
1089 parmtypes = TREE_CHAIN (parmtypes))
1092 pp_separate_with_comma (cxx_pp);
1096 pp_cxx_identifier (cxx_pp, "...");
1099 dump_type (TREE_VALUE (parmtypes), flags);
1101 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1103 pp_cxx_whitespace (cxx_pp);
1105 pp_cxx_whitespace (cxx_pp);
1106 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1110 pp_cxx_right_paren (cxx_pp);
1113 /* Print an exception specification. T is the exception specification. */
1116 dump_exception_spec (tree t, int flags)
1120 pp_cxx_identifier (cxx_pp, "throw");
1121 pp_cxx_whitespace (cxx_pp);
1122 pp_cxx_left_paren (cxx_pp);
1123 if (TREE_VALUE (t) != NULL_TREE)
1126 dump_type (TREE_VALUE (t), flags);
1130 pp_separate_with_comma (cxx_pp);
1132 pp_cxx_right_paren (cxx_pp);
1136 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1137 and destructors properly. */
1140 dump_function_name (tree t, int flags)
1142 tree name = DECL_NAME (t);
1144 /* We can get here with a decl that was synthesized by language-
1145 independent machinery (e.g. coverage.c) in which case it won't
1146 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1147 will crash. In this case it is safe just to print out the
1149 if (!DECL_LANG_SPECIFIC (t))
1151 pp_cxx_tree_identifier (cxx_pp, name);
1155 if (TREE_CODE (t) == TEMPLATE_DECL)
1156 t = DECL_TEMPLATE_RESULT (t);
1158 /* Don't let the user see __comp_ctor et al. */
1159 if (DECL_CONSTRUCTOR_P (t)
1160 || DECL_DESTRUCTOR_P (t))
1161 name = constructor_name (DECL_CONTEXT (t));
1163 if (DECL_DESTRUCTOR_P (t))
1165 pp_cxx_complement (cxx_pp);
1166 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1168 else if (DECL_CONV_FN_P (t))
1170 /* This cannot use the hack that the operator's return
1171 type is stashed off of its name because it may be
1172 used for error reporting. In the case of conflicting
1173 declarations, both will have the same name, yet
1174 the types will be different, hence the TREE_TYPE field
1175 of the first name will be clobbered by the second. */
1176 pp_cxx_identifier (cxx_pp, "operator");
1177 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1179 else if (IDENTIFIER_OPNAME_P (name))
1180 pp_cxx_tree_identifier (cxx_pp, name);
1182 dump_decl (name, flags);
1184 if (DECL_TEMPLATE_INFO (t)
1185 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1186 && (DECL_TEMPLATE_SPECIALIZATION (t)
1187 || TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1188 || DECL_TEMPLATE_SPECIALIZATION (DECL_TI_TEMPLATE (t))
1189 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1190 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1193 /* Dump the template parameters from the template info INFO under control of
1194 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1195 specialization (partial or complete). For partial specializations we show
1196 the specialized parameter values. For a primary template we show no
1200 dump_template_parms (tree info, int primary, int flags)
1202 tree args = info ? TI_ARGS (info) : NULL_TREE;
1204 if (primary && flags & TFF_TEMPLATE_NAME)
1206 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1207 pp_cxx_begin_template_argument_list (cxx_pp);
1209 /* Be careful only to print things when we have them, so as not
1210 to crash producing error messages. */
1211 if (args && !primary)
1215 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
1216 args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
1218 len = TREE_VEC_LENGTH (args);
1220 for (ix = 0; ix != len; ix++)
1222 tree arg = TREE_VEC_ELT (args, ix);
1225 pp_separate_with_comma (cxx_pp);
1228 pp_identifier (cxx_pp, "<template parameter error>");
1230 dump_template_argument (arg, flags);
1235 tree tpl = TI_TEMPLATE (info);
1236 tree parms = DECL_TEMPLATE_PARMS (tpl);
1239 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1240 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1242 for (ix = 0; ix != len; ix++)
1244 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1247 pp_separate_with_comma (cxx_pp);
1249 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1252 pp_cxx_end_template_argument_list (cxx_pp);
1255 /* Print out a list of initializers (subr of dump_expr). */
1258 dump_expr_list (tree l, int flags)
1262 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1265 pp_separate_with_comma (cxx_pp);
1269 /* Print out an expression E under control of FLAGS. */
1272 dump_expr (tree t, int flags)
1277 switch (TREE_CODE (t))
1285 case NAMESPACE_DECL:
1287 case IDENTIFIER_NODE:
1288 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1292 if (PAREN_STRING_LITERAL_P (t))
1293 pp_cxx_left_paren (cxx_pp);
1294 pp_c_constant (pp_c_base (cxx_pp), t);
1295 if (PAREN_STRING_LITERAL_P (t))
1296 pp_cxx_right_paren (cxx_pp);
1301 pp_c_constant (pp_c_base (cxx_pp), t);
1305 pp_cxx_identifier (cxx_pp, "throw");
1306 dump_expr (TREE_OPERAND (t, 0), flags);
1310 pp_ampersand (cxx_pp);
1311 dump_type (PTRMEM_CST_CLASS (t), flags);
1312 pp_cxx_colon_colon (cxx_pp);
1313 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1317 pp_cxx_left_paren (cxx_pp);
1318 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1319 pp_separate_with_comma (cxx_pp);
1320 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1321 pp_cxx_right_paren (cxx_pp);
1325 pp_cxx_left_paren (cxx_pp);
1326 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1327 pp_string (cxx_pp, " ? ");
1328 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1329 pp_string (cxx_pp, " : ");
1330 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1331 pp_cxx_right_paren (cxx_pp);
1335 if (TREE_HAS_CONSTRUCTOR (t))
1337 pp_cxx_identifier (cxx_pp, "new");
1338 pp_cxx_whitespace (cxx_pp);
1339 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1342 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1345 case AGGR_INIT_EXPR:
1347 tree fn = NULL_TREE;
1349 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
1350 fn = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
1352 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1354 if (DECL_CONSTRUCTOR_P (fn))
1355 dump_type (DECL_CONTEXT (fn), flags);
1360 dump_expr (TREE_OPERAND (t, 0), 0);
1362 pp_cxx_left_paren (cxx_pp);
1363 if (TREE_OPERAND (t, 1))
1364 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1365 pp_cxx_right_paren (cxx_pp);
1370 tree fn = TREE_OPERAND (t, 0);
1371 tree args = TREE_OPERAND (t, 1);
1373 if (TREE_CODE (fn) == ADDR_EXPR)
1374 fn = TREE_OPERAND (fn, 0);
1376 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1378 tree ob = TREE_VALUE (args);
1379 if (TREE_CODE (ob) == ADDR_EXPR)
1381 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1384 else if (TREE_CODE (ob) != PARM_DECL
1385 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1387 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1390 args = TREE_CHAIN (args);
1392 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1393 pp_cxx_left_paren (cxx_pp);
1394 dump_expr_list (args, flags);
1395 pp_cxx_right_paren (cxx_pp);
1401 tree type = TREE_OPERAND (t, 1);
1402 tree init = TREE_OPERAND (t, 2);
1403 if (NEW_EXPR_USE_GLOBAL (t))
1404 pp_cxx_colon_colon (cxx_pp);
1405 pp_cxx_identifier (cxx_pp, "new");
1406 if (TREE_OPERAND (t, 0))
1408 pp_cxx_left_paren (cxx_pp);
1409 dump_expr_list (TREE_OPERAND (t, 0), flags);
1410 pp_cxx_right_paren (cxx_pp);
1411 pp_cxx_whitespace (cxx_pp);
1413 if (TREE_CODE (type) == ARRAY_REF)
1414 type = build_cplus_array_type
1415 (TREE_OPERAND (type, 0),
1416 build_index_type (fold_build2 (MINUS_EXPR, integer_type_node,
1417 TREE_OPERAND (type, 1),
1418 integer_one_node)));
1419 dump_type (type, flags);
1422 pp_cxx_left_paren (cxx_pp);
1423 if (TREE_CODE (init) == TREE_LIST)
1424 dump_expr_list (init, flags);
1425 else if (init == void_zero_node)
1426 /* This representation indicates an empty initializer,
1427 e.g.: "new int()". */
1430 dump_expr (init, flags);
1431 pp_cxx_right_paren (cxx_pp);
1437 /* Note that this only works for G++ target exprs. If somebody
1438 builds a general TARGET_EXPR, there's no way to represent that
1439 it initializes anything other that the parameter slot for the
1440 default argument. Note we may have cleared out the first
1441 operand in expand_expr, so don't go killing ourselves. */
1442 if (TREE_OPERAND (t, 1))
1443 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1451 case TRUNC_DIV_EXPR:
1452 case TRUNC_MOD_EXPR:
1460 case TRUTH_ANDIF_EXPR:
1461 case TRUTH_ORIF_EXPR:
1468 case EXACT_DIV_EXPR:
1469 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1473 case FLOOR_DIV_EXPR:
1474 case ROUND_DIV_EXPR:
1476 dump_binary_op ("/", t, flags);
1480 case FLOOR_MOD_EXPR:
1481 case ROUND_MOD_EXPR:
1482 dump_binary_op ("%", t, flags);
1487 tree ob = TREE_OPERAND (t, 0);
1488 if (TREE_CODE (ob) == INDIRECT_REF)
1490 ob = TREE_OPERAND (ob, 0);
1491 if (TREE_CODE (ob) != PARM_DECL
1493 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1495 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1496 pp_cxx_arrow (cxx_pp);
1501 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1502 pp_cxx_dot (cxx_pp);
1504 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1509 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1510 pp_cxx_left_bracket (cxx_pp);
1511 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1512 pp_cxx_right_bracket (cxx_pp);
1515 case UNARY_PLUS_EXPR:
1516 dump_unary_op ("+", t, flags);
1520 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1521 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1522 /* An ADDR_EXPR can have reference type. In that case, we
1523 shouldn't print the `&' doing so indicates to the user
1524 that the expression has pointer type. */
1526 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1527 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1529 dump_unary_op ("&", t, flags);
1533 if (TREE_HAS_CONSTRUCTOR (t))
1535 t = TREE_OPERAND (t, 0);
1536 gcc_assert (TREE_CODE (t) == CALL_EXPR);
1537 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1538 pp_cxx_left_paren (cxx_pp);
1539 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1540 pp_cxx_right_paren (cxx_pp);
1544 if (TREE_OPERAND (t,0) != NULL_TREE
1545 && TREE_TYPE (TREE_OPERAND (t, 0))
1546 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1547 dump_expr (TREE_OPERAND (t, 0), flags);
1549 dump_unary_op ("*", t, flags);
1555 case TRUTH_NOT_EXPR:
1556 case PREDECREMENT_EXPR:
1557 case PREINCREMENT_EXPR:
1558 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1561 case POSTDECREMENT_EXPR:
1562 case POSTINCREMENT_EXPR:
1563 pp_cxx_left_paren (cxx_pp);
1564 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1565 pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1566 pp_cxx_right_paren (cxx_pp);
1569 case NON_LVALUE_EXPR:
1570 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1571 should be another level of INDIRECT_REF so that I don't have to do
1573 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1575 tree next = TREE_TYPE (TREE_TYPE (t));
1577 while (TREE_CODE (next) == POINTER_TYPE)
1578 next = TREE_TYPE (next);
1580 if (TREE_CODE (next) == FUNCTION_TYPE)
1582 if (flags & TFF_EXPR_IN_PARENS)
1583 pp_cxx_left_paren (cxx_pp);
1584 pp_cxx_star (cxx_pp);
1585 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1586 if (flags & TFF_EXPR_IN_PARENS)
1587 pp_cxx_right_paren (cxx_pp);
1590 /* Else fall through. */
1592 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1598 tree op = TREE_OPERAND (t, 0);
1600 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1602 /* It is a cast, but we cannot tell whether it is a
1603 reinterpret or static cast. Use the C style notation. */
1604 if (flags & TFF_EXPR_IN_PARENS)
1605 pp_cxx_left_paren (cxx_pp);
1606 pp_cxx_left_paren (cxx_pp);
1607 dump_type (TREE_TYPE (t), flags);
1608 pp_cxx_right_paren (cxx_pp);
1609 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1610 if (flags & TFF_EXPR_IN_PARENS)
1611 pp_cxx_right_paren (cxx_pp);
1614 dump_expr (op, flags);
1619 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1621 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1623 if (integer_zerop (idx))
1625 /* A NULL pointer-to-member constant. */
1626 pp_cxx_left_paren (cxx_pp);
1627 pp_cxx_left_paren (cxx_pp);
1628 dump_type (TREE_TYPE (t), flags);
1629 pp_cxx_right_paren (cxx_pp);
1630 pp_character (cxx_pp, '0');
1631 pp_cxx_right_paren (cxx_pp);
1634 else if (host_integerp (idx, 0))
1637 unsigned HOST_WIDE_INT n;
1639 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1640 t = TYPE_METHOD_BASETYPE (t);
1641 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1643 n = tree_low_cst (idx, 0);
1645 /* Map vtable index back one, to allow for the null pointer to
1649 while (n > 0 && virtuals)
1652 virtuals = TREE_CHAIN (virtuals);
1656 dump_expr (BV_FN (virtuals),
1657 flags | TFF_EXPR_IN_PARENS);
1662 if (TREE_TYPE (t) && !CONSTRUCTOR_ELTS (t))
1664 dump_type (TREE_TYPE (t), 0);
1665 pp_cxx_left_paren (cxx_pp);
1666 pp_cxx_right_paren (cxx_pp);
1670 pp_cxx_left_brace (cxx_pp);
1671 dump_expr_list (CONSTRUCTOR_ELTS (t), flags);
1672 pp_cxx_right_brace (cxx_pp);
1679 tree ob = TREE_OPERAND (t, 0);
1680 if (is_dummy_object (ob))
1682 t = TREE_OPERAND (t, 1);
1683 if (TREE_CODE (t) == FUNCTION_DECL)
1685 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1686 else if (BASELINK_P (t))
1687 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1688 flags | TFF_EXPR_IN_PARENS);
1690 dump_decl (t, flags);
1694 if (TREE_CODE (ob) == INDIRECT_REF)
1696 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1697 pp_cxx_arrow (cxx_pp);
1698 pp_cxx_star (cxx_pp);
1702 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1703 pp_cxx_dot (cxx_pp);
1704 pp_cxx_star (cxx_pp);
1706 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1711 case TEMPLATE_PARM_INDEX:
1712 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1716 pp_expression (cxx_pp, t);
1720 if (TREE_OPERAND (t, 0) == NULL_TREE
1721 || TREE_CHAIN (TREE_OPERAND (t, 0)))
1723 dump_type (TREE_TYPE (t), flags);
1724 pp_cxx_left_paren (cxx_pp);
1725 dump_expr_list (TREE_OPERAND (t, 0), flags);
1726 pp_cxx_right_paren (cxx_pp);
1730 pp_cxx_left_paren (cxx_pp);
1731 dump_type (TREE_TYPE (t), flags);
1732 pp_cxx_right_paren (cxx_pp);
1733 pp_cxx_left_paren (cxx_pp);
1734 dump_expr_list (TREE_OPERAND (t, 0), flags);
1735 pp_cxx_right_paren (cxx_pp);
1739 case STATIC_CAST_EXPR:
1740 pp_cxx_identifier (cxx_pp, "static_cast");
1742 case REINTERPRET_CAST_EXPR:
1743 pp_cxx_identifier (cxx_pp, "reinterpret_cast");
1745 case CONST_CAST_EXPR:
1746 pp_cxx_identifier (cxx_pp, "const_cast");
1748 case DYNAMIC_CAST_EXPR:
1749 pp_cxx_identifier (cxx_pp, "dynamic_cast");
1751 pp_cxx_begin_template_argument_list (cxx_pp);
1752 dump_type (TREE_TYPE (t), flags);
1753 pp_cxx_end_template_argument_list (cxx_pp);
1754 pp_cxx_left_paren (cxx_pp);
1755 dump_expr (TREE_OPERAND (t, 0), flags);
1756 pp_cxx_right_paren (cxx_pp);
1760 dump_expr (TREE_OPERAND (t, 0), flags);
1761 pp_cxx_arrow (cxx_pp);
1766 if (TREE_CODE (t) == SIZEOF_EXPR)
1767 pp_cxx_identifier (cxx_pp, "sizeof");
1770 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
1771 pp_cxx_identifier (cxx_pp, "__alignof__");
1773 pp_cxx_whitespace (cxx_pp);
1774 pp_cxx_left_paren (cxx_pp);
1775 if (TYPE_P (TREE_OPERAND (t, 0)))
1776 dump_type (TREE_OPERAND (t, 0), flags);
1778 dump_expr (TREE_OPERAND (t, 0), flags);
1779 pp_cxx_right_paren (cxx_pp);
1784 pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
1785 pp_cxx_whitespace (cxx_pp);
1786 dump_expr (TREE_OPERAND (t, 0), flags);
1790 pp_identifier (cxx_pp, "<unparsed>");
1793 case TRY_CATCH_EXPR:
1794 case WITH_CLEANUP_EXPR:
1795 case CLEANUP_POINT_EXPR:
1796 dump_expr (TREE_OPERAND (t, 0), flags);
1799 case PSEUDO_DTOR_EXPR:
1800 dump_expr (TREE_OPERAND (t, 2), flags);
1801 pp_cxx_dot (cxx_pp);
1802 dump_type (TREE_OPERAND (t, 0), flags);
1803 pp_cxx_colon_colon (cxx_pp);
1804 pp_cxx_complement (cxx_pp);
1805 dump_type (TREE_OPERAND (t, 1), flags);
1808 case TEMPLATE_ID_EXPR:
1809 dump_decl (t, flags);
1814 case STATEMENT_LIST:
1815 /* We don't yet have a way of dumping statements in a
1816 human-readable format. */
1817 pp_string (cxx_pp, "({...})");
1821 pp_string (cxx_pp, "while (1) { ");
1822 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1823 pp_cxx_right_brace (cxx_pp);
1827 pp_string (cxx_pp, "if (");
1828 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1829 pp_string (cxx_pp, ") break; ");
1833 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
1836 case EMPTY_CLASS_EXPR:
1837 dump_type (TREE_TYPE (t), flags);
1838 pp_cxx_left_paren (cxx_pp);
1839 pp_cxx_right_paren (cxx_pp);
1842 case NON_DEPENDENT_EXPR:
1843 dump_expr (TREE_OPERAND (t, 0), flags);
1846 /* This list is incomplete, but should suffice for now.
1847 It is very important that `sorry' does not call
1848 `report_error_function'. That could cause an infinite loop. */
1850 pp_unsupported_tree (cxx_pp, t);
1851 /* fall through to ERROR_MARK... */
1853 pp_identifier (cxx_pp, "<expression error>");
1859 dump_binary_op (const char *opstring, tree t, int flags)
1861 pp_cxx_left_paren (cxx_pp);
1862 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1863 pp_cxx_whitespace (cxx_pp);
1865 pp_cxx_identifier (cxx_pp, opstring);
1867 pp_identifier (cxx_pp, "<unknown operator>");
1868 pp_cxx_whitespace (cxx_pp);
1869 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1870 pp_cxx_right_paren (cxx_pp);
1874 dump_unary_op (const char *opstring, tree t, int flags)
1876 if (flags & TFF_EXPR_IN_PARENS)
1877 pp_cxx_left_paren (cxx_pp);
1878 pp_cxx_identifier (cxx_pp, opstring);
1879 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1880 if (flags & TFF_EXPR_IN_PARENS)
1881 pp_cxx_right_paren (cxx_pp);
1885 reinit_cxx_pp (void)
1887 pp_clear_output_area (cxx_pp);
1888 pp_base (cxx_pp)->padding = pp_none;
1889 pp_indentation (cxx_pp) = 0;
1890 pp_needs_newline (cxx_pp) = false;
1891 cxx_pp->enclosing_scope = 0;
1895 /* Exported interface to stringifying types, exprs and decls under TFF_*
1899 type_as_string (tree typ, int flags)
1902 dump_type (typ, flags);
1903 return pp_formatted_text (cxx_pp);
1907 expr_as_string (tree decl, int flags)
1910 dump_expr (decl, flags);
1911 return pp_formatted_text (cxx_pp);
1915 decl_as_string (tree decl, int flags)
1918 dump_decl (decl, flags);
1919 return pp_formatted_text (cxx_pp);
1922 /* Generate the three forms of printable names for cxx_printable_name. */
1925 lang_decl_name (tree decl, int v)
1928 return decl_as_string (decl, TFF_DECL_SPECIFIERS);
1931 if (v == 1 && DECL_CLASS_SCOPE_P (decl))
1933 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
1934 pp_cxx_colon_colon (cxx_pp);
1937 if (TREE_CODE (decl) == FUNCTION_DECL)
1938 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
1940 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
1942 return pp_formatted_text (cxx_pp);
1945 /* Return the location of a tree passed to %+ formats. */
1948 location_of (tree t)
1950 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
1951 t = DECL_CONTEXT (t);
1952 else if (TYPE_P (t))
1953 t = TYPE_MAIN_DECL (t);
1954 else if (TREE_CODE (t) == OVERLOAD)
1955 t = OVL_FUNCTION (t);
1957 return DECL_SOURCE_LOCATION (t);
1960 /* Now the interfaces from error et al to dump_type et al. Each takes an
1961 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
1965 decl_to_string (tree decl, int verbose)
1969 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
1970 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
1971 flags = TFF_CLASS_KEY_OR_ENUM;
1973 flags |= TFF_DECL_SPECIFIERS;
1974 else if (TREE_CODE (decl) == FUNCTION_DECL)
1975 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
1976 flags |= TFF_TEMPLATE_HEADER;
1979 dump_decl (decl, flags);
1980 return pp_formatted_text (cxx_pp);
1984 expr_to_string (tree decl)
1987 dump_expr (decl, 0);
1988 return pp_formatted_text (cxx_pp);
1992 fndecl_to_string (tree fndecl, int verbose)
1996 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS;
1998 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2000 dump_decl (fndecl, flags);
2001 return pp_formatted_text (cxx_pp);
2006 code_to_string (enum tree_code c)
2008 return tree_code_name [c];
2012 language_to_string (enum languages c)
2019 case lang_cplusplus:
2031 /* Return the proper printed version of a parameter to a C++ function. */
2034 parm_to_string (int p)
2038 pp_string (cxx_pp, "'this'");
2040 pp_decimal_int (cxx_pp, p + 1);
2041 return pp_formatted_text (cxx_pp);
2045 op_to_string (enum tree_code p)
2047 tree id = operator_name_info[(int) p].identifier;
2048 return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2052 type_to_string (tree typ, int verbose)
2056 flags |= TFF_CLASS_KEY_OR_ENUM;
2057 flags |= TFF_TEMPLATE_HEADER;
2060 dump_type (typ, flags);
2061 return pp_formatted_text (cxx_pp);
2065 assop_to_string (enum tree_code p)
2067 tree id = assignment_operator_name_info[(int) p].identifier;
2068 return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2072 args_to_string (tree p, int verbose)
2076 flags |= TFF_CLASS_KEY_OR_ENUM;
2081 if (TYPE_P (TREE_VALUE (p)))
2082 return type_as_string (p, flags);
2085 for (; p; p = TREE_CHAIN (p))
2087 if (TREE_VALUE (p) == null_node)
2088 pp_cxx_identifier (cxx_pp, "NULL");
2090 dump_type (error_type (TREE_VALUE (p)), flags);
2092 pp_separate_with_comma (cxx_pp);
2094 return pp_formatted_text (cxx_pp);
2098 cv_to_string (tree p, int v)
2101 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2102 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2103 return pp_formatted_text (cxx_pp);
2106 /* Langhook for print_error_function. */
2108 cxx_print_error_function (diagnostic_context *context, const char *file)
2110 lhd_print_error_function (context, file);
2111 pp_base_set_prefix (context->printer, file);
2112 maybe_print_instantiation_context (context);
2116 cp_diagnostic_starter (diagnostic_context *context,
2117 diagnostic_info *diagnostic)
2119 diagnostic_report_current_module (context);
2120 cp_print_error_function (context, diagnostic);
2121 maybe_print_instantiation_context (context);
2122 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2126 cp_diagnostic_finalizer (diagnostic_context *context,
2127 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2129 pp_base_destroy_prefix (context->printer);
2132 /* Print current function onto BUFFER, in the process of reporting
2133 a diagnostic message. Called from cp_diagnostic_starter. */
2135 cp_print_error_function (diagnostic_context *context,
2136 diagnostic_info *diagnostic)
2138 if (diagnostic_last_function_changed (context))
2140 const char *old_prefix = context->printer->prefix;
2141 const char *file = LOCATION_FILE (diagnostic->location);
2142 char *new_prefix = file ? file_name_as_prefix (file) : NULL;
2144 pp_base_set_prefix (context->printer, new_prefix);
2146 if (current_function_decl == NULL)
2147 pp_base_string (context->printer, "At global scope:");
2149 pp_printf (context->printer, "In %s %qs:",
2150 function_category (current_function_decl),
2151 cxx_printable_name (current_function_decl, 2));
2152 pp_base_newline (context->printer);
2154 diagnostic_set_last_function (context);
2155 pp_base_destroy_prefix (context->printer);
2156 context->printer->prefix = old_prefix;
2160 /* Returns a description of FUNCTION using standard terminology. */
2162 function_category (tree fn)
2164 if (DECL_FUNCTION_MEMBER_P (fn))
2166 if (DECL_STATIC_FUNCTION_P (fn))
2167 return "static member function";
2168 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2169 return "copy constructor";
2170 else if (DECL_CONSTRUCTOR_P (fn))
2171 return "constructor";
2172 else if (DECL_DESTRUCTOR_P (fn))
2173 return "destructor";
2175 return "member function";
2181 /* Report the full context of a current template instantiation,
2184 print_instantiation_full_context (diagnostic_context *context)
2186 tree p = current_instantiation ();
2187 location_t location = input_location;
2191 if (current_function_decl != TINST_DECL (p)
2192 && current_function_decl != NULL_TREE)
2193 /* We can get here during the processing of some synthesized
2194 method. Then, TINST_DECL (p) will be the function that's causing
2199 if (current_function_decl == TINST_DECL (p))
2200 /* Avoid redundancy with the "In function" line. */;
2202 pp_verbatim (context->printer,
2203 "%s: In instantiation of %qs:\n",
2204 LOCATION_FILE (location),
2205 decl_as_string (TINST_DECL (p),
2206 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2208 location = TINST_LOCATION (p);
2213 print_instantiation_partial_context (context, p, location);
2216 /* Same as above but less verbose. */
2218 print_instantiation_partial_context (diagnostic_context *context,
2219 tree t, location_t loc)
2221 expanded_location xloc;
2222 for (; ; t = TREE_CHAIN (t))
2224 xloc = expand_location (loc);
2227 pp_verbatim (context->printer, "%s:%d: instantiated from %qs\n",
2228 xloc.file, xloc.line,
2229 decl_as_string (TINST_DECL (t),
2230 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2231 loc = TINST_LOCATION (t);
2233 pp_verbatim (context->printer, "%s:%d: instantiated from here",
2234 xloc.file, xloc.line);
2235 pp_base_newline (context->printer);
2238 /* Called from cp_thing to print the template context for an error. */
2240 maybe_print_instantiation_context (diagnostic_context *context)
2242 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2245 record_last_problematic_instantiation ();
2246 print_instantiation_full_context (context);
2249 /* Report the bare minimum context of a template instantiation. */
2251 print_instantiation_context (void)
2253 print_instantiation_partial_context
2254 (global_dc, current_instantiation (), input_location);
2255 diagnostic_flush_buffer (global_dc);
2258 /* Called from output_format -- during diagnostic message processing --
2259 to handle C++ specific format specifier with the following meanings:
2260 %A function argument-list.
2264 %F function declaration.
2265 %L language as used in extern "lang".
2267 %P function parameter whose position is indicated by an integer.
2268 %Q assignment operator.
2272 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2273 int precision, bool wide, bool set_locus, bool verbose)
2277 #define next_tree (t = va_arg (*text->args_ptr, tree))
2278 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2279 #define next_lang va_arg (*text->args_ptr, enum languages)
2280 #define next_int va_arg (*text->args_ptr, int)
2282 if (precision != 0 || wide)
2285 if (text->locus == NULL)
2290 case 'A': result = args_to_string (next_tree, verbose); break;
2291 case 'C': result = code_to_string (next_tcode); break;
2292 case 'D': result = decl_to_string (next_tree, verbose); break;
2293 case 'E': result = expr_to_string (next_tree); break;
2294 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2295 case 'L': result = language_to_string (next_lang); break;
2296 case 'O': result = op_to_string (next_tcode); break;
2297 case 'P': result = parm_to_string (next_int); break;
2298 case 'Q': result = assop_to_string (next_tcode); break;
2299 case 'T': result = type_to_string (next_tree, verbose); break;
2300 case 'V': result = cv_to_string (next_tree, verbose); break;
2306 pp_base_string (pp, result);
2307 if (set_locus && t != NULL)
2308 *text->locus = location_of (t);