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, 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 #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 *);
90 static tree locate_error (const char *, va_list);
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
1492 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1494 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1495 pp_cxx_arrow (cxx_pp);
1500 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1501 pp_cxx_dot (cxx_pp);
1503 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1508 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1509 pp_cxx_left_bracket (cxx_pp);
1510 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1511 pp_cxx_right_bracket (cxx_pp);
1514 case UNARY_PLUS_EXPR:
1515 dump_unary_op ("+", t, flags);
1519 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1520 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1521 /* An ADDR_EXPR can have reference type. In that case, we
1522 shouldn't print the `&' doing so indicates to the user
1523 that the expression has pointer type. */
1525 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1526 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1528 dump_unary_op ("&", t, flags);
1532 if (TREE_HAS_CONSTRUCTOR (t))
1534 t = TREE_OPERAND (t, 0);
1535 gcc_assert (TREE_CODE (t) == CALL_EXPR);
1536 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1537 pp_cxx_left_paren (cxx_pp);
1538 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1539 pp_cxx_right_paren (cxx_pp);
1543 if (TREE_OPERAND (t,0) != NULL_TREE
1544 && TREE_TYPE (TREE_OPERAND (t, 0))
1545 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1546 dump_expr (TREE_OPERAND (t, 0), flags);
1548 dump_unary_op ("*", t, flags);
1554 case TRUTH_NOT_EXPR:
1555 case PREDECREMENT_EXPR:
1556 case PREINCREMENT_EXPR:
1557 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1560 case POSTDECREMENT_EXPR:
1561 case POSTINCREMENT_EXPR:
1562 pp_cxx_left_paren (cxx_pp);
1563 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1564 pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1565 pp_cxx_right_paren (cxx_pp);
1568 case NON_LVALUE_EXPR:
1569 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1570 should be another level of INDIRECT_REF so that I don't have to do
1572 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1574 tree next = TREE_TYPE (TREE_TYPE (t));
1576 while (TREE_CODE (next) == POINTER_TYPE)
1577 next = TREE_TYPE (next);
1579 if (TREE_CODE (next) == FUNCTION_TYPE)
1581 if (flags & TFF_EXPR_IN_PARENS)
1582 pp_cxx_left_paren (cxx_pp);
1583 pp_cxx_star (cxx_pp);
1584 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1585 if (flags & TFF_EXPR_IN_PARENS)
1586 pp_cxx_right_paren (cxx_pp);
1589 /* Else fall through. */
1591 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1597 tree op = TREE_OPERAND (t, 0);
1599 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1601 /* It is a cast, but we cannot tell whether it is a
1602 reinterpret or static cast. Use the C style notation. */
1603 if (flags & TFF_EXPR_IN_PARENS)
1604 pp_cxx_left_paren (cxx_pp);
1605 pp_cxx_left_paren (cxx_pp);
1606 dump_type (TREE_TYPE (t), flags);
1607 pp_cxx_right_paren (cxx_pp);
1608 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1609 if (flags & TFF_EXPR_IN_PARENS)
1610 pp_cxx_right_paren (cxx_pp);
1613 dump_expr (op, flags);
1618 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1620 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1622 if (integer_zerop (idx))
1624 /* A NULL pointer-to-member constant. */
1625 pp_cxx_left_paren (cxx_pp);
1626 pp_cxx_left_paren (cxx_pp);
1627 dump_type (TREE_TYPE (t), flags);
1628 pp_cxx_right_paren (cxx_pp);
1629 pp_character (cxx_pp, '0');
1630 pp_cxx_right_paren (cxx_pp);
1633 else if (host_integerp (idx, 0))
1636 unsigned HOST_WIDE_INT n;
1638 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1639 t = TYPE_METHOD_BASETYPE (t);
1640 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1642 n = tree_low_cst (idx, 0);
1644 /* Map vtable index back one, to allow for the null pointer to
1648 while (n > 0 && virtuals)
1651 virtuals = TREE_CHAIN (virtuals);
1655 dump_expr (BV_FN (virtuals),
1656 flags | TFF_EXPR_IN_PARENS);
1661 if (TREE_TYPE (t) && !CONSTRUCTOR_ELTS (t))
1663 dump_type (TREE_TYPE (t), 0);
1664 pp_cxx_left_paren (cxx_pp);
1665 pp_cxx_right_paren (cxx_pp);
1669 pp_cxx_left_brace (cxx_pp);
1670 dump_expr_list (CONSTRUCTOR_ELTS (t), flags);
1671 pp_cxx_right_brace (cxx_pp);
1678 tree ob = TREE_OPERAND (t, 0);
1679 if (is_dummy_object (ob))
1681 t = TREE_OPERAND (t, 1);
1682 if (TREE_CODE (t) == FUNCTION_DECL)
1684 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1685 else if (BASELINK_P (t))
1686 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1687 flags | TFF_EXPR_IN_PARENS);
1689 dump_decl (t, flags);
1693 if (TREE_CODE (ob) == INDIRECT_REF)
1695 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1696 pp_cxx_arrow (cxx_pp);
1697 pp_cxx_star (cxx_pp);
1701 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1702 pp_cxx_dot (cxx_pp);
1703 pp_cxx_star (cxx_pp);
1705 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1710 case TEMPLATE_PARM_INDEX:
1711 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1715 pp_expression (cxx_pp, t);
1719 if (TREE_OPERAND (t, 0) == NULL_TREE
1720 || TREE_CHAIN (TREE_OPERAND (t, 0)))
1722 dump_type (TREE_TYPE (t), flags);
1723 pp_cxx_left_paren (cxx_pp);
1724 dump_expr_list (TREE_OPERAND (t, 0), flags);
1725 pp_cxx_right_paren (cxx_pp);
1729 pp_cxx_left_paren (cxx_pp);
1730 dump_type (TREE_TYPE (t), flags);
1731 pp_cxx_right_paren (cxx_pp);
1732 pp_cxx_left_paren (cxx_pp);
1733 dump_expr_list (TREE_OPERAND (t, 0), flags);
1734 pp_cxx_right_paren (cxx_pp);
1738 case STATIC_CAST_EXPR:
1739 pp_cxx_identifier (cxx_pp, "static_cast");
1741 case REINTERPRET_CAST_EXPR:
1742 pp_cxx_identifier (cxx_pp, "reinterpret_cast");
1744 case CONST_CAST_EXPR:
1745 pp_cxx_identifier (cxx_pp, "const_cast");
1747 case DYNAMIC_CAST_EXPR:
1748 pp_cxx_identifier (cxx_pp, "dynamic_cast");
1750 pp_cxx_begin_template_argument_list (cxx_pp);
1751 dump_type (TREE_TYPE (t), flags);
1752 pp_cxx_end_template_argument_list (cxx_pp);
1753 pp_cxx_left_paren (cxx_pp);
1754 dump_expr (TREE_OPERAND (t, 0), flags);
1755 pp_cxx_right_paren (cxx_pp);
1759 dump_expr (TREE_OPERAND (t, 0), flags);
1760 pp_cxx_arrow (cxx_pp);
1765 if (TREE_CODE (t) == SIZEOF_EXPR)
1766 pp_cxx_identifier (cxx_pp, "sizeof");
1769 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
1770 pp_cxx_identifier (cxx_pp, "__alignof__");
1772 pp_cxx_whitespace (cxx_pp);
1773 pp_cxx_left_paren (cxx_pp);
1774 if (TYPE_P (TREE_OPERAND (t, 0)))
1775 dump_type (TREE_OPERAND (t, 0), flags);
1777 dump_expr (TREE_OPERAND (t, 0), flags);
1778 pp_cxx_right_paren (cxx_pp);
1783 pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
1784 pp_cxx_whitespace (cxx_pp);
1785 dump_expr (TREE_OPERAND (t, 0), flags);
1789 pp_identifier (cxx_pp, "<unparsed>");
1792 case TRY_CATCH_EXPR:
1793 case WITH_CLEANUP_EXPR:
1794 case CLEANUP_POINT_EXPR:
1795 dump_expr (TREE_OPERAND (t, 0), flags);
1798 case PSEUDO_DTOR_EXPR:
1799 dump_expr (TREE_OPERAND (t, 2), flags);
1800 pp_cxx_dot (cxx_pp);
1801 dump_type (TREE_OPERAND (t, 0), flags);
1802 pp_cxx_colon_colon (cxx_pp);
1803 pp_cxx_complement (cxx_pp);
1804 dump_type (TREE_OPERAND (t, 1), flags);
1807 case TEMPLATE_ID_EXPR:
1808 dump_decl (t, flags);
1813 case STATEMENT_LIST:
1814 /* We don't yet have a way of dumping statements in a
1815 human-readable format. */
1816 pp_string (cxx_pp, "({...})");
1820 pp_string (cxx_pp, "while (1) { ");
1821 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1822 pp_cxx_right_brace (cxx_pp);
1826 pp_string (cxx_pp, "if (");
1827 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1828 pp_string (cxx_pp, ") break; ");
1832 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
1835 case EMPTY_CLASS_EXPR:
1836 dump_type (TREE_TYPE (t), flags);
1837 pp_cxx_left_paren (cxx_pp);
1838 pp_cxx_right_paren (cxx_pp);
1841 case NON_DEPENDENT_EXPR:
1842 dump_expr (TREE_OPERAND (t, 0), flags);
1845 /* This list is incomplete, but should suffice for now.
1846 It is very important that `sorry' does not call
1847 `report_error_function'. That could cause an infinite loop. */
1849 pp_unsupported_tree (cxx_pp, t);
1850 /* fall through to ERROR_MARK... */
1852 pp_identifier (cxx_pp, "<expression error>");
1858 dump_binary_op (const char *opstring, tree t, int flags)
1860 pp_cxx_left_paren (cxx_pp);
1861 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1862 pp_cxx_whitespace (cxx_pp);
1864 pp_cxx_identifier (cxx_pp, opstring);
1866 pp_identifier (cxx_pp, "<unknown operator>");
1867 pp_cxx_whitespace (cxx_pp);
1868 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1869 pp_cxx_right_paren (cxx_pp);
1873 dump_unary_op (const char *opstring, tree t, int flags)
1875 if (flags & TFF_EXPR_IN_PARENS)
1876 pp_cxx_left_paren (cxx_pp);
1877 pp_cxx_identifier (cxx_pp, opstring);
1878 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1879 if (flags & TFF_EXPR_IN_PARENS)
1880 pp_cxx_right_paren (cxx_pp);
1884 reinit_cxx_pp (void)
1886 pp_clear_output_area (cxx_pp);
1887 pp_base (cxx_pp)->padding = pp_none;
1888 pp_indentation (cxx_pp) = 0;
1889 pp_needs_newline (cxx_pp) = false;
1890 cxx_pp->enclosing_scope = 0;
1894 /* Exported interface to stringifying types, exprs and decls under TFF_*
1898 type_as_string (tree typ, int flags)
1901 dump_type (typ, flags);
1902 return pp_formatted_text (cxx_pp);
1906 expr_as_string (tree decl, int flags)
1909 dump_expr (decl, flags);
1910 return pp_formatted_text (cxx_pp);
1914 decl_as_string (tree decl, int flags)
1917 dump_decl (decl, flags);
1918 return pp_formatted_text (cxx_pp);
1921 /* Generate the three forms of printable names for cxx_printable_name. */
1924 lang_decl_name (tree decl, int v)
1927 return decl_as_string (decl, TFF_DECL_SPECIFIERS);
1930 if (v == 1 && DECL_CLASS_SCOPE_P (decl))
1932 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
1933 pp_cxx_colon_colon (cxx_pp);
1936 if (TREE_CODE (decl) == FUNCTION_DECL)
1937 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
1939 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
1941 return pp_formatted_text (cxx_pp);
1945 location_of (tree t)
1947 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
1948 t = DECL_CONTEXT (t);
1949 else if (TYPE_P (t))
1950 t = TYPE_MAIN_DECL (t);
1951 else if (TREE_CODE (t) == OVERLOAD)
1952 t = OVL_FUNCTION (t);
1954 return DECL_SOURCE_LOCATION (t);
1957 /* Now the interfaces from error et al to dump_type et al. Each takes an
1958 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
1962 decl_to_string (tree decl, int verbose)
1966 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
1967 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
1968 flags = TFF_CLASS_KEY_OR_ENUM;
1970 flags |= TFF_DECL_SPECIFIERS;
1971 else if (TREE_CODE (decl) == FUNCTION_DECL)
1972 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
1973 flags |= TFF_TEMPLATE_HEADER;
1976 dump_decl (decl, flags);
1977 return pp_formatted_text (cxx_pp);
1981 expr_to_string (tree decl)
1984 dump_expr (decl, 0);
1985 return pp_formatted_text (cxx_pp);
1989 fndecl_to_string (tree fndecl, int verbose)
1993 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS;
1995 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
1997 dump_decl (fndecl, flags);
1998 return pp_formatted_text (cxx_pp);
2003 code_to_string (enum tree_code c)
2005 return tree_code_name [c];
2009 language_to_string (enum languages c)
2016 case lang_cplusplus:
2028 /* Return the proper printed version of a parameter to a C++ function. */
2031 parm_to_string (int p)
2035 pp_string (cxx_pp, "'this'");
2037 pp_decimal_int (cxx_pp, p + 1);
2038 return pp_formatted_text (cxx_pp);
2042 op_to_string (enum tree_code p)
2044 tree id = operator_name_info[(int) p].identifier;
2045 return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2049 type_to_string (tree typ, int verbose)
2053 flags |= TFF_CLASS_KEY_OR_ENUM;
2054 flags |= TFF_TEMPLATE_HEADER;
2057 dump_type (typ, flags);
2058 return pp_formatted_text (cxx_pp);
2062 assop_to_string (enum tree_code p)
2064 tree id = assignment_operator_name_info[(int) p].identifier;
2065 return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2069 args_to_string (tree p, int verbose)
2073 flags |= TFF_CLASS_KEY_OR_ENUM;
2078 if (TYPE_P (TREE_VALUE (p)))
2079 return type_as_string (p, flags);
2082 for (; p; p = TREE_CHAIN (p))
2084 if (TREE_VALUE (p) == null_node)
2085 pp_cxx_identifier (cxx_pp, "NULL");
2087 dump_type (error_type (TREE_VALUE (p)), flags);
2089 pp_separate_with_comma (cxx_pp);
2091 return pp_formatted_text (cxx_pp);
2095 cv_to_string (tree p, int v)
2098 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2099 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2100 return pp_formatted_text (cxx_pp);
2103 /* Langhook for print_error_function. */
2105 cxx_print_error_function (diagnostic_context *context, const char *file)
2107 lhd_print_error_function (context, file);
2108 pp_base_set_prefix (context->printer, file);
2109 maybe_print_instantiation_context (context);
2113 cp_diagnostic_starter (diagnostic_context *context,
2114 diagnostic_info *diagnostic)
2116 diagnostic_report_current_module (context);
2117 cp_print_error_function (context, diagnostic);
2118 maybe_print_instantiation_context (context);
2119 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2123 cp_diagnostic_finalizer (diagnostic_context *context,
2124 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2126 pp_base_destroy_prefix (context->printer);
2129 /* Print current function onto BUFFER, in the process of reporting
2130 a diagnostic message. Called from cp_diagnostic_starter. */
2132 cp_print_error_function (diagnostic_context *context,
2133 diagnostic_info *diagnostic)
2135 if (diagnostic_last_function_changed (context))
2137 const char *old_prefix = context->printer->prefix;
2138 const char *file = LOCATION_FILE (diagnostic->location);
2139 char *new_prefix = file ? file_name_as_prefix (file) : NULL;
2141 pp_base_set_prefix (context->printer, new_prefix);
2143 if (current_function_decl == NULL)
2144 pp_base_string (context->printer, "At global scope:");
2146 pp_printf (context->printer, "In %s %qs:",
2147 function_category (current_function_decl),
2148 cxx_printable_name (current_function_decl, 2));
2149 pp_base_newline (context->printer);
2151 diagnostic_set_last_function (context);
2152 pp_base_destroy_prefix (context->printer);
2153 context->printer->prefix = old_prefix;
2157 /* Returns a description of FUNCTION using standard terminology. */
2159 function_category (tree fn)
2161 if (DECL_FUNCTION_MEMBER_P (fn))
2163 if (DECL_STATIC_FUNCTION_P (fn))
2164 return "static member function";
2165 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2166 return "copy constructor";
2167 else if (DECL_CONSTRUCTOR_P (fn))
2168 return "constructor";
2169 else if (DECL_DESTRUCTOR_P (fn))
2170 return "destructor";
2172 return "member function";
2178 /* Report the full context of a current template instantiation,
2181 print_instantiation_full_context (diagnostic_context *context)
2183 tree p = current_instantiation ();
2184 location_t location = input_location;
2188 if (current_function_decl != TINST_DECL (p)
2189 && current_function_decl != NULL_TREE)
2190 /* We can get here during the processing of some synthesized
2191 method. Then, TINST_DECL (p) will be the function that's causing
2196 if (current_function_decl == TINST_DECL (p))
2197 /* Avoid redundancy with the "In function" line. */;
2199 pp_verbatim (context->printer,
2200 "%s: In instantiation of %qs:\n",
2201 LOCATION_FILE (location),
2202 decl_as_string (TINST_DECL (p),
2203 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2205 location = TINST_LOCATION (p);
2210 print_instantiation_partial_context (context, p, location);
2213 /* Same as above but less verbose. */
2215 print_instantiation_partial_context (diagnostic_context *context,
2216 tree t, location_t loc)
2218 expanded_location xloc;
2219 for (; ; t = TREE_CHAIN (t))
2221 xloc = expand_location (loc);
2224 pp_verbatim (context->printer, "%s:%d: instantiated from %qs\n",
2225 xloc.file, xloc.line,
2226 decl_as_string (TINST_DECL (t),
2227 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2228 loc = TINST_LOCATION (t);
2230 pp_verbatim (context->printer, "%s:%d: instantiated from here\n",
2231 xloc.file, xloc.line);
2234 /* Called from cp_thing to print the template context for an error. */
2236 maybe_print_instantiation_context (diagnostic_context *context)
2238 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2241 record_last_problematic_instantiation ();
2242 print_instantiation_full_context (context);
2245 /* Report the bare minimum context of a template instantiation. */
2247 print_instantiation_context (void)
2249 print_instantiation_partial_context
2250 (global_dc, current_instantiation (), input_location);
2251 diagnostic_flush_buffer (global_dc);
2254 /* Called from output_format -- during diagnostic message processing --
2255 to handle C++ specific format specifier with the following meanings:
2256 %A function argument-list.
2260 %F function declaration.
2261 %L language as used in extern "lang".
2263 %P function parameter whose position is indicated by an integer.
2264 %Q assignment operator.
2268 cp_printer (pretty_printer *pp, text_info *text)
2272 #define next_tree va_arg (*text->args_ptr, tree)
2273 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2274 #define next_lang va_arg (*text->args_ptr, enum languages)
2275 #define next_int va_arg (*text->args_ptr, int)
2277 if (*text->format_spec == '+')
2278 ++text->format_spec;
2279 if (*text->format_spec == '#')
2282 ++text->format_spec;
2285 switch (*text->format_spec)
2287 case 'A': result = args_to_string (next_tree, verbose); break;
2288 case 'C': result = code_to_string (next_tcode); break;
2289 case 'D': result = decl_to_string (next_tree, verbose); break;
2290 case 'E': result = expr_to_string (next_tree); break;
2291 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2292 case 'L': result = language_to_string (next_lang); break;
2293 case 'O': result = op_to_string (next_tcode); break;
2294 case 'P': result = parm_to_string (next_int); break;
2295 case 'Q': result = assop_to_string (next_tcode); break;
2296 case 'T': result = type_to_string (next_tree, verbose); break;
2297 case 'V': result = cv_to_string (next_tree, verbose); break;
2303 pp_base_string (pp, result);
2311 /* These are temporary wrapper functions which handle the historic
2312 behavior of cp_*_at. */
2315 locate_error (const char *gmsgid, va_list ap)
2321 for (f = gmsgid; *f; f++)
2327 ++f; /* ignore quoting flag. */
2339 /* Just ignore these possibilities. */
2342 case 'd': (void) va_arg (ap, int); break;
2343 case 's': (void) va_arg (ap, char *); break;
2344 case 'L': (void) va_arg (ap, enum languages); break;
2347 case 'Q': (void) va_arg (ap, enum tree_code); break;
2349 /* These take a tree, which may be where the error is
2357 t = va_arg (ap, tree);
2363 errorcount = 0; /* damn ICE suppression */
2364 internal_error ("unexpected letter %qc in locate_error\n", *f);
2370 here = va_arg (ap, tree);
2377 cp_error_at (const char *gmsgid, ...)
2380 diagnostic_info diagnostic;
2383 va_start (ap, gmsgid);
2384 here = locate_error (gmsgid, ap);
2387 va_start (ap, gmsgid);
2388 diagnostic_set_info (&diagnostic, gmsgid, &ap,
2389 input_location, DK_ERROR);
2390 cp_diagnostic_starter (global_dc, &diagnostic);
2391 diagnostic_set_info (&diagnostic, gmsgid, &ap,
2392 location_of (here), DK_ERROR);
2393 report_diagnostic (&diagnostic);
2398 cp_warning_at (const char *gmsgid, ...)
2401 diagnostic_info diagnostic;
2404 va_start (ap, gmsgid);
2405 here = locate_error (gmsgid, ap);
2408 va_start (ap, gmsgid);
2409 diagnostic_set_info (&diagnostic, gmsgid, &ap,
2410 location_of (here), DK_WARNING);
2411 report_diagnostic (&diagnostic);
2416 cp_pedwarn_at (const char *gmsgid, ...)
2419 diagnostic_info diagnostic;
2422 va_start (ap, gmsgid);
2423 here = locate_error (gmsgid, ap);
2426 va_start (ap, gmsgid);
2427 diagnostic_set_info (&diagnostic, gmsgid, &ap,
2428 location_of (here), pedantic_error_kind());
2429 report_diagnostic (&diagnostic);