1 /* Call-backs for C++ error reporting.
2 This code is non-reentrant.
3 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002,
4 2003, 2004 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "coretypes.h"
31 #include "diagnostic.h"
32 #include "langhooks-def.h"
33 #include "cxx-pretty-print.h"
35 #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 const char *class_key_or_enum (tree);
74 static void dump_template_argument (tree, int);
75 static void dump_template_argument_list (tree, int);
76 static void dump_template_parameter (tree, int);
77 static void dump_template_bindings (tree, tree);
78 static void dump_scope (tree, int);
79 static void dump_template_parms (tree, int, int);
81 static const char *function_category (tree);
82 static void maybe_print_instantiation_context (diagnostic_context *);
83 static void print_instantiation_full_context (diagnostic_context *);
84 static void print_instantiation_partial_context (diagnostic_context *,
86 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
87 static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
88 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
90 static bool cp_printer (pretty_printer *, text_info *);
91 static tree locate_error (const char *, va_list);
92 static location_t location_of (tree);
97 diagnostic_starter (global_dc) = cp_diagnostic_starter;
98 diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer;
99 diagnostic_format_decoder (global_dc) = cp_printer;
101 pp_construct (pp_base (cxx_pp), NULL, 0);
102 pp_cxx_pretty_printer_init (cxx_pp);
105 /* Dump a scope, if deemed necessary. */
108 dump_scope (tree scope, int flags)
110 int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF));
112 if (scope == NULL_TREE)
115 if (TREE_CODE (scope) == NAMESPACE_DECL)
117 if (scope != global_namespace)
119 dump_decl (scope, f);
120 pp_cxx_colon_colon (cxx_pp);
123 else if (AGGREGATE_TYPE_P (scope))
125 dump_type (scope, f);
126 pp_cxx_colon_colon (cxx_pp);
128 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
130 dump_function_decl (scope, f);
131 pp_cxx_colon_colon (cxx_pp);
135 /* Dump the template ARGument under control of FLAGS. */
138 dump_template_argument (tree arg, int flags)
140 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
141 dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
143 dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
146 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
150 dump_template_argument_list (tree args, int flags)
152 int n = TREE_VEC_LENGTH (args);
156 for (i = 0; i< n; ++i)
159 pp_separate_with_comma (cxx_pp);
160 dump_template_argument (TREE_VEC_ELT (args, i), flags);
165 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
168 dump_template_parameter (tree parm, int flags)
170 tree p = TREE_VALUE (parm);
171 tree a = TREE_PURPOSE (parm);
173 if (TREE_CODE (p) == TYPE_DECL)
175 if (flags & TFF_DECL_SPECIFIERS)
177 pp_cxx_identifier (cxx_pp, "class");
179 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
181 else if (DECL_NAME (p))
182 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
184 pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
187 dump_decl (p, flags | TFF_DECL_SPECIFIERS);
189 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
191 pp_cxx_whitespace (cxx_pp);
193 pp_cxx_whitespace (cxx_pp);
194 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
195 dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
197 dump_expr (a, flags | TFF_EXPR_IN_PARENS);
201 /* Dump, under control of FLAGS, a template-parameter-list binding.
202 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
206 dump_template_bindings (tree parms, tree args)
212 tree p = TREE_VALUE (parms);
213 int lvl = TMPL_PARMS_DEPTH (parms);
217 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
219 tree arg = NULL_TREE;
221 /* Don't crash if we had an invalid argument list. */
222 if (TMPL_ARGS_DEPTH (args) >= lvl)
224 tree lvl_args = TMPL_ARGS_LEVEL (args, lvl);
225 if (NUM_TMPL_ARGS (lvl_args) > arg_idx)
226 arg = TREE_VEC_ELT (lvl_args, arg_idx);
230 pp_separate_with_comma (cxx_pp);
231 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
232 pp_cxx_whitespace (cxx_pp);
234 pp_cxx_whitespace (cxx_pp);
236 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
238 pp_identifier (cxx_pp, "<missing>");
244 parms = TREE_CHAIN (parms);
248 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
252 dump_type (tree t, int flags)
257 if (TYPE_PTRMEMFUNC_P (t))
260 switch (TREE_CODE (t))
263 pp_identifier (cxx_pp, "<unknown type>");
267 /* A list of function parms. */
268 dump_parameters (t, flags);
271 case IDENTIFIER_NODE:
272 pp_cxx_tree_identifier (cxx_pp, t);
276 dump_type (BINFO_TYPE (t), flags);
282 dump_aggr_type (t, flags);
286 if (flags & TFF_CHASE_TYPEDEF)
288 dump_type (DECL_ORIGINAL_TYPE (t)
289 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
292 /* Else fall through. */
296 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
305 pp_type_specifier_seq (cxx_pp, t);
308 case TEMPLATE_TEMPLATE_PARM:
309 /* For parameters inside template signature. */
310 if (TYPE_IDENTIFIER (t))
311 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
313 pp_cxx_canonical_template_parameter (cxx_pp, t);
316 case BOUND_TEMPLATE_TEMPLATE_PARM:
318 tree args = TYPE_TI_ARGS (t);
319 pp_cxx_cv_qualifier_seq (cxx_pp, t);
320 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
321 pp_cxx_begin_template_argument_list (cxx_pp);
322 dump_template_argument_list (args, flags);
323 pp_cxx_end_template_argument_list (cxx_pp);
327 case TEMPLATE_TYPE_PARM:
328 pp_cxx_cv_qualifier_seq (cxx_pp, t);
329 if (TYPE_IDENTIFIER (t))
330 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
332 pp_cxx_canonical_template_parameter
333 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
336 /* This is not always necessary for pointers and such, but doing this
337 reduces code size. */
346 dump_type_prefix (t, flags);
347 dump_type_suffix (t, flags);
351 pp_cxx_cv_qualifier_seq (cxx_pp, t);
352 pp_cxx_identifier (cxx_pp, "typename");
353 dump_typename (t, flags);
356 case UNBOUND_CLASS_TEMPLATE:
357 dump_type (TYPE_CONTEXT (t), flags);
358 pp_cxx_colon_colon (cxx_pp);
359 pp_cxx_identifier (cxx_pp, "template");
360 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
364 pp_cxx_identifier (cxx_pp, "__typeof__");
365 pp_cxx_whitespace (cxx_pp);
366 pp_cxx_left_paren (cxx_pp);
367 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
368 pp_cxx_right_paren (cxx_pp);
372 pp_unsupported_tree (cxx_pp, t);
373 /* Fall through to error. */
376 pp_identifier (cxx_pp, "<type error>");
381 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
385 dump_typename (tree t, int flags)
387 tree ctx = TYPE_CONTEXT (t);
389 if (TREE_CODE (ctx) == TYPENAME_TYPE)
390 dump_typename (ctx, flags);
392 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
393 pp_cxx_colon_colon (cxx_pp);
394 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
397 /* Return the name of the supplied aggregate, or enumeral type. */
400 class_key_or_enum (tree t)
402 if (TREE_CODE (t) == ENUMERAL_TYPE)
404 else if (TREE_CODE (t) == UNION_TYPE)
406 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
412 /* Print out a class declaration T under the control of FLAGS,
413 in the form `class foo'. */
416 dump_aggr_type (tree t, int flags)
419 const char *variety = class_key_or_enum (t);
423 pp_cxx_cv_qualifier_seq (cxx_pp, t);
425 if (flags & TFF_CLASS_KEY_OR_ENUM)
426 pp_cxx_identifier (cxx_pp, variety);
428 if (flags & TFF_CHASE_TYPEDEF)
429 t = TYPE_MAIN_VARIANT (t);
431 name = TYPE_NAME (t);
435 typdef = !DECL_ARTIFICIAL (name);
436 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
437 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
438 && (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
439 || TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
440 || DECL_TEMPLATE_SPECIALIZATION (CLASSTYPE_TI_TEMPLATE (t))
441 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
442 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
445 /* Because the template names are mangled, we have to locate
446 the most general template, and use that name. */
447 tree tpl = CLASSTYPE_TI_TEMPLATE (t);
449 while (DECL_TEMPLATE_INFO (tpl))
450 tpl = DECL_TI_TEMPLATE (tpl);
453 name = DECL_NAME (name);
456 if (name == 0 || ANON_AGGRNAME_P (name))
458 if (flags & TFF_CLASS_KEY_OR_ENUM)
459 pp_identifier (cxx_pp, "<anonymous>");
461 pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety);
464 pp_cxx_tree_identifier (cxx_pp, name);
466 dump_template_parms (TYPE_TEMPLATE_INFO (t),
467 !CLASSTYPE_USE_TEMPLATE (t),
468 flags & ~TFF_TEMPLATE_HEADER);
471 /* Dump into the obstack the initial part of the output for a given type.
472 This is necessary when dealing with things like functions returning
475 return type of `int (* fee ())()': pointer -> function -> int. Both
476 pointer (and reference and offset) and function (and member) types must
477 deal with prefix and suffix.
479 Arrays must also do this for DECL nodes, like int a[], and for things like
483 dump_type_prefix (tree t, int flags)
485 if (TYPE_PTRMEMFUNC_P (t))
487 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
491 switch (TREE_CODE (t))
496 tree sub = TREE_TYPE (t);
498 dump_type_prefix (sub, flags);
499 if (TREE_CODE (sub) == ARRAY_TYPE)
501 pp_cxx_whitespace (cxx_pp);
502 pp_cxx_left_paren (cxx_pp);
504 pp_character (cxx_pp, "&*"[TREE_CODE (t) == POINTER_TYPE]);
505 pp_base (cxx_pp)->padding = pp_before;
506 pp_cxx_cv_qualifier_seq (cxx_pp, t);
512 dump_type_prefix (TREE_TYPE (t), flags);
513 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
515 pp_maybe_space (cxx_pp);
516 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
517 pp_cxx_left_paren (cxx_pp);
518 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
519 pp_cxx_colon_colon (cxx_pp);
521 pp_cxx_star (cxx_pp);
522 pp_cxx_cv_qualifier_seq (cxx_pp, t);
523 pp_base (cxx_pp)->padding = pp_before;
526 /* Can only be reached through function pointer -- this would not be
527 correct if FUNCTION_DECLs used it. */
529 dump_type_prefix (TREE_TYPE (t), flags);
530 pp_maybe_space (cxx_pp);
531 pp_cxx_left_paren (cxx_pp);
535 dump_type_prefix (TREE_TYPE (t), flags);
536 pp_maybe_space (cxx_pp);
537 pp_cxx_left_paren (cxx_pp);
538 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
539 pp_cxx_colon_colon (cxx_pp);
543 dump_type_prefix (TREE_TYPE (t), flags);
547 case IDENTIFIER_NODE:
552 case TEMPLATE_TYPE_PARM:
553 case TEMPLATE_TEMPLATE_PARM:
554 case BOUND_TEMPLATE_TEMPLATE_PARM:
565 dump_type (t, flags);
566 pp_base (cxx_pp)->padding = pp_before;
570 pp_unsupported_tree (cxx_pp, t);
573 pp_identifier (cxx_pp, "<typeprefixerror>");
578 /* Dump the suffix of type T, under control of FLAGS. This is the part
579 which appears after the identifier (or function parms). */
582 dump_type_suffix (tree t, int flags)
584 if (TYPE_PTRMEMFUNC_P (t))
585 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
587 switch (TREE_CODE (t))
592 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
593 pp_cxx_right_paren (cxx_pp);
594 dump_type_suffix (TREE_TYPE (t), flags);
597 /* Can only be reached through function pointer. */
602 pp_cxx_right_paren (cxx_pp);
603 arg = TYPE_ARG_TYPES (t);
604 if (TREE_CODE (t) == METHOD_TYPE)
605 arg = TREE_CHAIN (arg);
607 /* Function pointers don't have default args. Not in standard C++,
608 anyway; they may in g++, but we'll just pretend otherwise. */
609 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
611 if (TREE_CODE (t) == METHOD_TYPE)
612 pp_cxx_cv_qualifier_seq
613 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
614 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
615 dump_type_suffix (TREE_TYPE (t), flags);
620 pp_maybe_space (cxx_pp);
621 pp_cxx_left_bracket (cxx_pp);
624 if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0))
626 (cxx_pp, tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1);
627 else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR)
628 dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0),
629 flags & ~TFF_EXPR_IN_PARENS);
631 dump_expr (fold (cp_build_binary_op
632 (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)),
634 flags & ~TFF_EXPR_IN_PARENS);
636 pp_cxx_right_bracket (cxx_pp);
637 dump_type_suffix (TREE_TYPE (t), flags);
641 case IDENTIFIER_NODE:
646 case TEMPLATE_TYPE_PARM:
647 case TEMPLATE_TEMPLATE_PARM:
648 case BOUND_TEMPLATE_TEMPLATE_PARM:
662 pp_unsupported_tree (cxx_pp, t);
664 /* Don't mark it here, we should have already done in
671 dump_global_iord (tree t)
673 const char *p = NULL;
675 if (DECL_GLOBAL_CTOR_P (t))
677 else if (DECL_GLOBAL_DTOR_P (t))
682 pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename);
686 dump_simple_decl (tree t, tree type, int flags)
688 if (flags & TFF_DECL_SPECIFIERS)
690 dump_type_prefix (type, flags);
691 pp_maybe_space (cxx_pp);
693 if (!DECL_INITIAL (t) || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX)
694 dump_scope (CP_DECL_CONTEXT (t), flags);
696 dump_decl (DECL_NAME (t), flags);
698 pp_identifier (cxx_pp, "<anonymous>");
699 if (flags & TFF_DECL_SPECIFIERS)
700 dump_type_suffix (type, flags);
703 /* Dump a human readable string for the decl T under control of FLAGS. */
706 dump_decl (tree t, int flags)
711 switch (TREE_CODE (t))
715 /* Don't say 'typedef class A' */
716 if (DECL_ARTIFICIAL (t))
718 if ((flags & TFF_DECL_SPECIFIERS)
719 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
720 /* Say `class T' not just `T'. */
721 pp_cxx_identifier (cxx_pp, "class");
723 dump_type (TREE_TYPE (t), flags);
727 if (flags & TFF_DECL_SPECIFIERS)
728 pp_cxx_identifier (cxx_pp, "typedef");
729 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
730 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
735 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
737 pp_string (cxx_pp, "vtable for ");
738 my_friendly_assert (TYPE_P (DECL_CONTEXT (t)), 20010720);
739 dump_type (DECL_CONTEXT (t), flags);
742 /* Else fall through. */
746 dump_simple_decl (t, TREE_TYPE (t), flags);
750 pp_string (cxx_pp, "<return value> ");
751 dump_simple_decl (t, TREE_TYPE (t), flags);
755 if (flags & TFF_DECL_SPECIFIERS)
756 pp_cxx_declaration (cxx_pp, t);
759 dump_scope (CP_DECL_CONTEXT (t), flags);
760 if (DECL_NAME (t) == NULL_TREE)
761 pp_identifier (cxx_pp, "<unnamed>");
763 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
768 pp_expression (cxx_pp, t);
772 dump_decl (TREE_OPERAND (t, 0), flags);
773 pp_cxx_left_bracket (cxx_pp);
774 dump_decl (TREE_OPERAND (t, 1), flags);
775 pp_cxx_right_bracket (cxx_pp);
778 /* So that we can do dump_decl on an aggr type. */
782 dump_type (t, flags);
786 /* This is a pseudo destructor call which has not been folded into
787 a PSEUDO_DTOR_EXPR yet. */
788 pp_cxx_complement (cxx_pp);
789 dump_type (TREE_OPERAND (t, 0), flags);
796 /* These special cases are duplicated here so that other functions
797 can feed identifiers to error and get them demangled properly. */
798 case IDENTIFIER_NODE:
799 if (IDENTIFIER_TYPENAME_P (t))
801 pp_cxx_identifier (cxx_pp, "operator");
802 /* Not exactly IDENTIFIER_TYPE_VALUE. */
803 dump_type (TREE_TYPE (t), flags);
807 pp_cxx_tree_identifier (cxx_pp, t);
814 if (DECL_CLASS_SCOPE_P (t))
816 dump_type (DECL_CONTEXT (t), flags);
817 pp_cxx_colon_colon (cxx_pp);
819 else if (DECL_CONTEXT (t))
821 dump_decl (DECL_CONTEXT (t), flags);
822 pp_cxx_colon_colon (cxx_pp);
824 dump_decl (DECL_NAME (t), flags);
828 /* If there's only one function, just treat it like an ordinary
834 if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
835 dump_global_iord (t);
836 else if (! DECL_LANG_SPECIFIC (t))
837 pp_identifier (cxx_pp, "<built-in>");
839 dump_function_decl (t, flags);
843 dump_template_decl (t, flags);
846 case TEMPLATE_ID_EXPR:
848 tree name = TREE_OPERAND (t, 0);
850 if (is_overloaded_fn (name))
851 name = DECL_NAME (get_first_fn (name));
852 dump_decl (name, flags);
853 pp_cxx_begin_template_argument_list (cxx_pp);
854 if (TREE_OPERAND (t, 1))
855 dump_template_argument_list (TREE_OPERAND (t, 1), flags);
856 pp_cxx_end_template_argument_list (cxx_pp);
861 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
865 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
866 || (DECL_INITIAL (t) &&
867 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
868 dump_simple_decl (t, TREE_TYPE (t), flags);
869 else if (DECL_NAME (t))
870 dump_decl (DECL_NAME (t), flags);
871 else if (DECL_INITIAL (t))
872 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
874 pp_identifier (cxx_pp, "<enumerator>");
878 pp_cxx_identifier (cxx_pp, "using");
879 dump_type (DECL_INITIAL (t), flags);
880 pp_cxx_colon_colon (cxx_pp);
881 dump_decl (DECL_NAME (t), flags);
885 dump_decl (BASELINK_FUNCTIONS (t), flags);
888 case NON_DEPENDENT_EXPR:
889 dump_expr (t, flags);
892 case TEMPLATE_TYPE_PARM:
893 if (flags & TFF_DECL_SPECIFIERS)
894 pp_cxx_declaration (cxx_pp, t);
896 pp_type_id (cxx_pp, t);
900 pp_unsupported_tree (cxx_pp, t);
901 /* Fall through to error. */
904 pp_identifier (cxx_pp, "<declaration error>");
909 /* Dump a template declaration T under control of FLAGS. This means the
910 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
913 dump_template_decl (tree t, int flags)
915 tree orig_parms = DECL_TEMPLATE_PARMS (t);
919 if (flags & TFF_TEMPLATE_HEADER)
921 for (parms = orig_parms = nreverse (orig_parms);
923 parms = TREE_CHAIN (parms))
925 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
926 int len = TREE_VEC_LENGTH (inner_parms);
928 pp_cxx_identifier (cxx_pp, "template");
929 pp_cxx_begin_template_argument_list (cxx_pp);
931 /* If we've shown the template prefix, we'd better show the
932 parameters' and decl's type too. */
933 flags |= TFF_DECL_SPECIFIERS;
935 for (i = 0; i < len; i++)
938 pp_separate_with_comma (cxx_pp);
939 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
941 pp_cxx_end_template_argument_list (cxx_pp);
942 pp_cxx_whitespace (cxx_pp);
944 nreverse(orig_parms);
946 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
947 /* Say `template<arg> class TT' not just `template<arg> TT'. */
948 pp_cxx_identifier (cxx_pp, "class");
951 if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
952 dump_type (TREE_TYPE (t),
953 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
954 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
955 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
956 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
957 else if (TREE_TYPE (t) == NULL_TREE)
960 switch (NEXT_CODE (t))
964 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
967 /* This case can occur with some invalid code. */
968 dump_type (TREE_TYPE (t),
969 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
970 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0));
974 /* Pretty print a function decl. There are several ways we want to print a
975 function declaration. The TFF_ bits in FLAGS tells us how to behave.
976 As error can only apply the '#' flag once to give 0 and 1 for V, there
977 is %D which doesn't print the throw specs, and %F which does. */
980 dump_function_decl (tree t, int flags)
984 tree cname = NULL_TREE;
985 tree template_args = NULL_TREE;
986 tree template_parms = NULL_TREE;
987 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
989 if (TREE_CODE (t) == TEMPLATE_DECL)
990 t = DECL_TEMPLATE_RESULT (t);
992 /* Pretty print template instantiations only. */
993 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t))
997 template_args = DECL_TI_ARGS (t);
998 tmpl = most_general_template (t);
999 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1001 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1006 fntype = TREE_TYPE (t);
1007 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1009 if (DECL_CLASS_SCOPE_P (t))
1010 cname = DECL_CONTEXT (t);
1011 /* This is for partially instantiated template methods. */
1012 else if (TREE_CODE (fntype) == METHOD_TYPE)
1013 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1015 if (!(flags & TFF_DECL_SPECIFIERS))
1017 else if (DECL_STATIC_FUNCTION_P (t))
1018 pp_cxx_identifier (cxx_pp, "static");
1019 else if (DECL_VIRTUAL_P (t))
1020 pp_cxx_identifier (cxx_pp, "virtual");
1022 /* Print the return type? */
1024 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1025 && !DECL_DESTRUCTOR_P (t);
1027 dump_type_prefix (TREE_TYPE (fntype), flags);
1029 /* Print the function name. */
1032 dump_type (cname, flags);
1033 pp_cxx_colon_colon (cxx_pp);
1036 dump_scope (CP_DECL_CONTEXT (t), flags);
1038 dump_function_name (t, flags);
1040 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1042 dump_parameters (parmtypes, flags);
1044 if (TREE_CODE (fntype) == METHOD_TYPE)
1046 pp_base (cxx_pp)->padding = pp_before;
1047 pp_cxx_cv_qualifier_seq
1048 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1051 if (flags & TFF_EXCEPTION_SPECIFICATION)
1053 pp_base (cxx_pp)->padding = pp_before;
1054 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
1058 dump_type_suffix (TREE_TYPE (fntype), flags);
1061 /* If T is a template instantiation, dump the parameter binding. */
1062 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1064 pp_cxx_whitespace (cxx_pp);
1065 pp_cxx_left_bracket (cxx_pp);
1066 pp_cxx_identifier (cxx_pp, "with");
1067 pp_cxx_whitespace (cxx_pp);
1068 dump_template_bindings (template_parms, template_args);
1069 pp_cxx_right_bracket (cxx_pp);
1073 /* Print a parameter list. If this is for a member function, the
1074 member object ptr (and any other hidden args) should have
1075 already been removed. */
1078 dump_parameters (tree parmtypes, int flags)
1082 pp_cxx_left_paren (cxx_pp);
1084 for (first = 1; parmtypes != void_list_node;
1085 parmtypes = TREE_CHAIN (parmtypes))
1088 pp_separate_with_comma (cxx_pp);
1092 pp_cxx_identifier (cxx_pp, "...");
1095 dump_type (TREE_VALUE (parmtypes), flags);
1097 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1099 pp_cxx_whitespace (cxx_pp);
1101 pp_cxx_whitespace (cxx_pp);
1102 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1106 pp_cxx_right_paren (cxx_pp);
1109 /* Print an exception specification. T is the exception specification. */
1112 dump_exception_spec (tree t, int flags)
1116 pp_cxx_identifier (cxx_pp, "throw");
1117 pp_cxx_whitespace (cxx_pp);
1118 pp_cxx_left_paren (cxx_pp);
1119 if (TREE_VALUE (t) != NULL_TREE)
1122 dump_type (TREE_VALUE (t), flags);
1126 pp_separate_with_comma (cxx_pp);
1128 pp_cxx_right_paren (cxx_pp);
1132 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1133 and destructors properly. */
1136 dump_function_name (tree t, int flags)
1138 tree name = DECL_NAME (t);
1140 /* We can get here with a decl that was synthesized by language-
1141 independent machinery (e.g. coverage.c) in which case it won't
1142 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1143 will crash. In this case it is safe just to print out the
1145 if (!DECL_LANG_SPECIFIC (t))
1147 pp_cxx_tree_identifier (cxx_pp, name);
1151 if (TREE_CODE (t) == TEMPLATE_DECL)
1152 t = DECL_TEMPLATE_RESULT (t);
1154 /* Don't let the user see __comp_ctor et al. */
1155 if (DECL_CONSTRUCTOR_P (t)
1156 || DECL_DESTRUCTOR_P (t))
1157 name = constructor_name (DECL_CONTEXT (t));
1159 if (DECL_DESTRUCTOR_P (t))
1161 pp_cxx_complement (cxx_pp);
1162 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1164 else if (DECL_CONV_FN_P (t))
1166 /* This cannot use the hack that the operator's return
1167 type is stashed off of its name because it may be
1168 used for error reporting. In the case of conflicting
1169 declarations, both will have the same name, yet
1170 the types will be different, hence the TREE_TYPE field
1171 of the first name will be clobbered by the second. */
1172 pp_cxx_identifier (cxx_pp, "operator");
1173 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1175 else if (IDENTIFIER_OPNAME_P (name))
1176 pp_cxx_tree_identifier (cxx_pp, name);
1178 dump_decl (name, flags);
1180 if (DECL_TEMPLATE_INFO (t)
1181 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1182 && (DECL_TEMPLATE_SPECIALIZATION (t)
1183 || TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1184 || DECL_TEMPLATE_SPECIALIZATION (DECL_TI_TEMPLATE (t))
1185 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1186 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1189 /* Dump the template parameters from the template info INFO under control of
1190 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1191 specialization (partial or complete). For partial specializations we show
1192 the specialized parameter values. For a primary template we show no
1196 dump_template_parms (tree info, int primary, int flags)
1198 tree args = info ? TI_ARGS (info) : NULL_TREE;
1200 if (primary && flags & TFF_TEMPLATE_NAME)
1202 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1203 pp_cxx_begin_template_argument_list (cxx_pp);
1205 /* Be careful only to print things when we have them, so as not
1206 to crash producing error messages. */
1207 if (args && !primary)
1211 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
1212 args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
1214 len = TREE_VEC_LENGTH (args);
1216 for (ix = 0; ix != len; ix++)
1218 tree arg = TREE_VEC_ELT (args, ix);
1221 pp_separate_with_comma (cxx_pp);
1224 pp_identifier (cxx_pp, "<template parameter error>");
1226 dump_template_argument (arg, flags);
1231 tree tpl = TI_TEMPLATE (info);
1232 tree parms = DECL_TEMPLATE_PARMS (tpl);
1235 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1236 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1238 for (ix = 0; ix != len; ix++)
1240 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1243 pp_separate_with_comma (cxx_pp);
1245 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1248 pp_cxx_end_template_argument_list (cxx_pp);
1251 /* Print out a list of initializers (subr of dump_expr). */
1254 dump_expr_list (tree l, int flags)
1258 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1261 pp_separate_with_comma (cxx_pp);
1265 /* Print out an expression E under control of FLAGS. */
1268 dump_expr (tree t, int flags)
1273 switch (TREE_CODE (t))
1281 case NAMESPACE_DECL:
1283 case IDENTIFIER_NODE:
1284 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1290 pp_c_constant (pp_c_base (cxx_pp), t);
1294 pp_cxx_identifier (cxx_pp, "throw");
1295 dump_expr (TREE_OPERAND (t, 0), flags);
1299 pp_ampersand (cxx_pp);
1300 dump_type (PTRMEM_CST_CLASS (t), flags);
1301 pp_cxx_colon_colon (cxx_pp);
1302 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1306 pp_cxx_left_paren (cxx_pp);
1307 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1308 pp_separate_with_comma (cxx_pp);
1309 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1310 pp_cxx_right_paren (cxx_pp);
1314 pp_cxx_left_paren (cxx_pp);
1315 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1316 pp_string (cxx_pp, " ? ");
1317 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1318 pp_string (cxx_pp, " : ");
1319 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1320 pp_cxx_right_paren (cxx_pp);
1324 if (TREE_HAS_CONSTRUCTOR (t))
1326 pp_cxx_identifier (cxx_pp, "new");
1327 pp_cxx_whitespace (cxx_pp);
1328 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1331 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1334 case AGGR_INIT_EXPR:
1336 tree fn = NULL_TREE;
1338 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
1339 fn = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
1341 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1343 if (DECL_CONSTRUCTOR_P (fn))
1344 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (TREE_TYPE (t)));
1349 dump_expr (TREE_OPERAND (t, 0), 0);
1351 pp_cxx_left_paren (cxx_pp);
1352 if (TREE_OPERAND (t, 1))
1353 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1354 pp_cxx_right_paren (cxx_pp);
1359 tree fn = TREE_OPERAND (t, 0);
1360 tree args = TREE_OPERAND (t, 1);
1362 if (TREE_CODE (fn) == ADDR_EXPR)
1363 fn = TREE_OPERAND (fn, 0);
1365 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1367 tree ob = TREE_VALUE (args);
1368 if (TREE_CODE (ob) == ADDR_EXPR)
1370 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1373 else if (TREE_CODE (ob) != PARM_DECL
1374 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1376 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1379 args = TREE_CHAIN (args);
1381 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1382 pp_cxx_left_paren (cxx_pp);
1383 dump_expr_list (args, flags);
1384 pp_cxx_right_paren (cxx_pp);
1390 tree type = TREE_OPERAND (t, 1);
1391 tree init = TREE_OPERAND (t, 2);
1392 if (NEW_EXPR_USE_GLOBAL (t))
1393 pp_cxx_colon_colon (cxx_pp);
1394 pp_cxx_identifier (cxx_pp, "new");
1395 if (TREE_OPERAND (t, 0))
1397 pp_cxx_left_paren (cxx_pp);
1398 dump_expr_list (TREE_OPERAND (t, 0), flags);
1399 pp_cxx_right_paren (cxx_pp);
1400 pp_cxx_whitespace (cxx_pp);
1402 if (TREE_CODE (type) == ARRAY_REF)
1403 type = build_cplus_array_type
1404 (TREE_OPERAND (type, 0),
1405 build_index_type (fold (build2 (MINUS_EXPR, integer_type_node,
1406 TREE_OPERAND (type, 1),
1407 integer_one_node))));
1408 dump_type (type, flags);
1411 pp_cxx_left_paren (cxx_pp);
1412 if (TREE_CODE (init) == TREE_LIST)
1413 dump_expr_list (init, flags);
1414 else if (init == void_zero_node)
1415 /* This representation indicates an empty initializer,
1416 e.g.: "new int()". */
1419 dump_expr (init, flags);
1420 pp_cxx_right_paren (cxx_pp);
1426 /* Note that this only works for G++ target exprs. If somebody
1427 builds a general TARGET_EXPR, there's no way to represent that
1428 it initializes anything other that the parameter slot for the
1429 default argument. Note we may have cleared out the first
1430 operand in expand_expr, so don't go killing ourselves. */
1431 if (TREE_OPERAND (t, 1))
1432 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1440 case TRUNC_DIV_EXPR:
1441 case TRUNC_MOD_EXPR:
1449 case TRUTH_ANDIF_EXPR:
1450 case TRUTH_ORIF_EXPR:
1457 case EXACT_DIV_EXPR:
1458 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1462 case FLOOR_DIV_EXPR:
1463 case ROUND_DIV_EXPR:
1464 dump_binary_op ("/", t, flags);
1468 case FLOOR_MOD_EXPR:
1469 case ROUND_MOD_EXPR:
1470 dump_binary_op ("%", t, flags);
1475 tree ob = TREE_OPERAND (t, 0);
1476 if (TREE_CODE (ob) == INDIRECT_REF)
1478 ob = TREE_OPERAND (ob, 0);
1479 if (TREE_CODE (ob) != PARM_DECL
1480 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1482 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1483 pp_cxx_arrow (cxx_pp);
1488 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1489 pp_cxx_dot (cxx_pp);
1491 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1496 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1497 pp_cxx_left_bracket (cxx_pp);
1498 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1499 pp_cxx_right_bracket (cxx_pp);
1503 if (TREE_TYPE (t) && VOID_TYPE_P (TREE_TYPE (t)))
1505 pp_cxx_left_paren (cxx_pp);
1506 dump_type (TREE_TYPE (t), flags);
1507 pp_cxx_right_paren (cxx_pp);
1508 dump_expr (TREE_OPERAND (t, 0), flags);
1511 dump_unary_op ("+", t, flags);
1515 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1516 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1517 /* An ADDR_EXPR can have reference type. In that case, we
1518 shouldn't print the `&' doing so indicates to the user
1519 that the expression has pointer type. */
1521 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1522 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1524 dump_unary_op ("&", t, flags);
1528 if (TREE_HAS_CONSTRUCTOR (t))
1530 t = TREE_OPERAND (t, 0);
1531 my_friendly_assert (TREE_CODE (t) == CALL_EXPR, 237);
1532 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1533 pp_cxx_left_paren (cxx_pp);
1534 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1535 pp_cxx_right_paren (cxx_pp);
1539 if (TREE_OPERAND (t,0) != NULL_TREE
1540 && TREE_TYPE (TREE_OPERAND (t, 0))
1541 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1542 dump_expr (TREE_OPERAND (t, 0), flags);
1544 dump_unary_op ("*", t, flags);
1550 case TRUTH_NOT_EXPR:
1551 case PREDECREMENT_EXPR:
1552 case PREINCREMENT_EXPR:
1553 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1556 case POSTDECREMENT_EXPR:
1557 case POSTINCREMENT_EXPR:
1558 pp_cxx_left_paren (cxx_pp);
1559 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1560 pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1561 pp_cxx_right_paren (cxx_pp);
1564 case NON_LVALUE_EXPR:
1565 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1566 should be another level of INDIRECT_REF so that I don't have to do
1568 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1570 tree next = TREE_TYPE (TREE_TYPE (t));
1572 while (TREE_CODE (next) == POINTER_TYPE)
1573 next = TREE_TYPE (next);
1575 if (TREE_CODE (next) == FUNCTION_TYPE)
1577 if (flags & TFF_EXPR_IN_PARENS)
1578 pp_cxx_left_paren (cxx_pp);
1579 pp_cxx_star (cxx_pp);
1580 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1581 if (flags & TFF_EXPR_IN_PARENS)
1582 pp_cxx_right_paren (cxx_pp);
1585 /* Else fall through. */
1587 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1592 tree op = TREE_OPERAND (t, 0);
1594 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1596 /* It is a cast, but we cannot tell whether it is a
1597 reinterpret or static cast. Use the C style notation. */
1598 if (flags & TFF_EXPR_IN_PARENS)
1599 pp_cxx_left_paren (cxx_pp);
1600 pp_cxx_left_paren (cxx_pp);
1601 dump_type (TREE_TYPE (t), flags);
1602 pp_cxx_right_paren (cxx_pp);
1603 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1604 if (flags & TFF_EXPR_IN_PARENS)
1605 pp_cxx_right_paren (cxx_pp);
1608 dump_expr (op, flags);
1613 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1615 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1617 if (integer_zerop (idx))
1619 /* A NULL pointer-to-member constant. */
1620 pp_cxx_left_paren (cxx_pp);
1621 pp_cxx_left_paren (cxx_pp);
1622 dump_type (TREE_TYPE (t), flags);
1623 pp_cxx_right_paren (cxx_pp);
1624 pp_character (cxx_pp, '0');
1625 pp_cxx_right_paren (cxx_pp);
1628 else if (host_integerp (idx, 0))
1631 unsigned HOST_WIDE_INT n;
1633 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1634 t = TYPE_METHOD_BASETYPE (t);
1635 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1637 n = tree_low_cst (idx, 0);
1639 /* Map vtable index back one, to allow for the null pointer to
1643 while (n > 0 && virtuals)
1646 virtuals = TREE_CHAIN (virtuals);
1650 dump_expr (BV_FN (virtuals),
1651 flags | TFF_EXPR_IN_PARENS);
1656 if (TREE_TYPE (t) && !CONSTRUCTOR_ELTS (t))
1658 dump_type (TREE_TYPE (t), 0);
1659 pp_cxx_left_paren (cxx_pp);
1660 pp_cxx_right_paren (cxx_pp);
1664 pp_cxx_left_brace (cxx_pp);
1665 dump_expr_list (CONSTRUCTOR_ELTS (t), flags);
1666 pp_cxx_right_brace (cxx_pp);
1673 tree ob = TREE_OPERAND (t, 0);
1674 if (is_dummy_object (ob))
1676 t = TREE_OPERAND (t, 1);
1677 if (TREE_CODE (t) == FUNCTION_DECL)
1679 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1680 else if (BASELINK_P (t))
1681 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1682 flags | TFF_EXPR_IN_PARENS);
1684 dump_decl (t, flags);
1688 if (TREE_CODE (ob) == INDIRECT_REF)
1690 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1691 pp_cxx_arrow (cxx_pp);
1692 pp_cxx_star (cxx_pp);
1696 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1697 pp_cxx_dot (cxx_pp);
1698 pp_cxx_star (cxx_pp);
1700 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1705 case TEMPLATE_PARM_INDEX:
1706 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1710 pp_expression (cxx_pp, t);
1714 if (TREE_OPERAND (t, 0) == NULL_TREE
1715 || TREE_CHAIN (TREE_OPERAND (t, 0)))
1717 dump_type (TREE_TYPE (t), flags);
1718 pp_cxx_left_paren (cxx_pp);
1719 dump_expr_list (TREE_OPERAND (t, 0), flags);
1720 pp_cxx_right_paren (cxx_pp);
1724 pp_cxx_left_paren (cxx_pp);
1725 dump_type (TREE_TYPE (t), flags);
1726 pp_cxx_right_paren (cxx_pp);
1727 pp_cxx_left_paren (cxx_pp);
1728 dump_expr_list (TREE_OPERAND (t, 0), flags);
1729 pp_cxx_right_paren (cxx_pp);
1733 case STATIC_CAST_EXPR:
1734 pp_cxx_identifier (cxx_pp, "static_cast");
1736 case REINTERPRET_CAST_EXPR:
1737 pp_cxx_identifier (cxx_pp, "reinterpret_cast");
1739 case CONST_CAST_EXPR:
1740 pp_cxx_identifier (cxx_pp, "const_cast");
1742 case DYNAMIC_CAST_EXPR:
1743 pp_cxx_identifier (cxx_pp, "dynamic_cast");
1745 pp_cxx_begin_template_argument_list (cxx_pp);
1746 dump_type (TREE_TYPE (t), flags);
1747 pp_cxx_end_template_argument_list (cxx_pp);
1748 pp_cxx_left_paren (cxx_pp);
1749 dump_expr (TREE_OPERAND (t, 0), flags);
1750 pp_cxx_right_paren (cxx_pp);
1754 dump_expr (TREE_OPERAND (t, 0), flags);
1755 pp_cxx_arrow (cxx_pp);
1760 if (TREE_CODE (t) == SIZEOF_EXPR)
1761 pp_cxx_identifier (cxx_pp, "sizeof");
1764 my_friendly_assert (TREE_CODE (t) == ALIGNOF_EXPR, 0);
1765 pp_cxx_identifier (cxx_pp, "__alignof__");
1767 pp_cxx_whitespace (cxx_pp);
1768 pp_cxx_left_paren (cxx_pp);
1769 if (TYPE_P (TREE_OPERAND (t, 0)))
1770 dump_type (TREE_OPERAND (t, 0), flags);
1772 dump_expr (TREE_OPERAND (t, 0), flags);
1773 pp_cxx_right_paren (cxx_pp);
1778 pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
1779 pp_cxx_whitespace (cxx_pp);
1780 dump_expr (TREE_OPERAND (t, 0), flags);
1784 pp_identifier (cxx_pp, "<unparsed>");
1787 case TRY_CATCH_EXPR:
1788 case WITH_CLEANUP_EXPR:
1789 case CLEANUP_POINT_EXPR:
1790 dump_expr (TREE_OPERAND (t, 0), flags);
1793 case PSEUDO_DTOR_EXPR:
1794 dump_expr (TREE_OPERAND (t, 2), flags);
1795 pp_cxx_dot (cxx_pp);
1796 dump_type (TREE_OPERAND (t, 0), flags);
1797 pp_cxx_colon_colon (cxx_pp);
1798 pp_cxx_complement (cxx_pp);
1799 dump_type (TREE_OPERAND (t, 1), flags);
1802 case TEMPLATE_ID_EXPR:
1803 dump_decl (t, flags);
1807 /* We don't yet have a way of dumping statements in a
1808 human-readable format. */
1809 pp_string (cxx_pp, "({...})");
1813 pp_cxx_left_brace (cxx_pp);
1814 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1815 pp_cxx_right_brace (cxx_pp);
1819 pp_string (cxx_pp, "while (1) { ");
1820 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1821 pp_cxx_right_brace (cxx_pp);
1825 pp_string (cxx_pp, "if (");
1826 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1827 pp_string (cxx_pp, ") break; ");
1831 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
1834 case EMPTY_CLASS_EXPR:
1835 dump_type (TREE_TYPE (t), flags);
1836 pp_cxx_left_paren (cxx_pp);
1837 pp_cxx_right_paren (cxx_pp);
1840 case NON_DEPENDENT_EXPR:
1841 dump_expr (TREE_OPERAND (t, 0), flags);
1844 /* This list is incomplete, but should suffice for now.
1845 It is very important that `sorry' does not call
1846 `report_error_function'. That could cause an infinite loop. */
1848 pp_unsupported_tree (cxx_pp, t);
1849 /* fall through to ERROR_MARK... */
1851 pp_identifier (cxx_pp, "<expression error>");
1857 dump_binary_op (const char *opstring, tree t, int flags)
1859 pp_cxx_left_paren (cxx_pp);
1860 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1861 pp_cxx_whitespace (cxx_pp);
1863 pp_cxx_identifier (cxx_pp, opstring);
1865 pp_identifier (cxx_pp, "<unknown operator>");
1866 pp_cxx_whitespace (cxx_pp);
1867 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1868 pp_cxx_right_paren (cxx_pp);
1872 dump_unary_op (const char *opstring, tree t, int flags)
1874 if (flags & TFF_EXPR_IN_PARENS)
1875 pp_cxx_left_paren (cxx_pp);
1876 pp_cxx_identifier (cxx_pp, opstring);
1877 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1878 if (flags & TFF_EXPR_IN_PARENS)
1879 pp_cxx_right_paren (cxx_pp);
1883 reinit_cxx_pp (void)
1885 pp_clear_output_area (cxx_pp);
1886 pp_base (cxx_pp)->padding = pp_none;
1887 pp_indentation (cxx_pp) = 0;
1888 pp_needs_newline (cxx_pp) = false;
1889 cxx_pp->enclosing_scope = 0;
1893 /* Exported interface to stringifying types, exprs and decls under TFF_*
1897 type_as_string (tree typ, int flags)
1900 dump_type (typ, flags);
1901 return pp_formatted_text (cxx_pp);
1905 expr_as_string (tree decl, int flags)
1908 dump_expr (decl, flags);
1909 return pp_formatted_text (cxx_pp);
1913 decl_as_string (tree decl, int flags)
1916 dump_decl (decl, flags);
1917 return pp_formatted_text (cxx_pp);
1921 context_as_string (tree context, int flags)
1924 dump_scope (context, flags);
1925 return pp_formatted_text (cxx_pp);
1928 /* Generate the three forms of printable names for cxx_printable_name. */
1931 lang_decl_name (tree decl, int v)
1934 return decl_as_string (decl, TFF_DECL_SPECIFIERS);
1937 if (v == 1 && DECL_CLASS_SCOPE_P (decl))
1939 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
1940 pp_cxx_colon_colon (cxx_pp);
1943 if (TREE_CODE (decl) == FUNCTION_DECL)
1944 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
1946 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
1948 return pp_formatted_text (cxx_pp);
1952 location_of (tree t)
1954 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
1955 t = DECL_CONTEXT (t);
1956 else if (TYPE_P (t))
1957 t = TYPE_MAIN_DECL (t);
1958 else if (TREE_CODE (t) == OVERLOAD)
1959 t = OVL_FUNCTION (t);
1961 return DECL_SOURCE_LOCATION (t);
1964 /* Now the interfaces from error et al to dump_type et al. Each takes an
1965 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
1969 decl_to_string (tree decl, int verbose)
1973 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
1974 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
1975 flags = TFF_CLASS_KEY_OR_ENUM;
1977 flags |= TFF_DECL_SPECIFIERS;
1978 else if (TREE_CODE (decl) == FUNCTION_DECL)
1979 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
1980 flags |= TFF_TEMPLATE_HEADER;
1983 dump_decl (decl, flags);
1984 return pp_formatted_text (cxx_pp);
1988 expr_to_string (tree decl)
1991 dump_expr (decl, 0);
1992 return pp_formatted_text (cxx_pp);
1996 fndecl_to_string (tree fndecl, int verbose)
2000 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS;
2002 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2004 dump_decl (fndecl, flags);
2005 return pp_formatted_text (cxx_pp);
2010 code_to_string (enum tree_code c)
2012 return tree_code_name [c];
2016 language_to_string (enum languages c)
2023 case lang_cplusplus:
2035 /* Return the proper printed version of a parameter to a C++ function. */
2038 parm_to_string (int p)
2042 pp_string (cxx_pp, "'this'");
2044 pp_decimal_int (cxx_pp, p + 1);
2045 return pp_formatted_text (cxx_pp);
2049 op_to_string (enum tree_code p)
2051 tree id = operator_name_info[(int) p].identifier;
2052 return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2056 type_to_string (tree typ, int verbose)
2060 flags |= TFF_CLASS_KEY_OR_ENUM;
2061 flags |= TFF_TEMPLATE_HEADER;
2064 dump_type (typ, flags);
2065 return pp_formatted_text (cxx_pp);
2069 assop_to_string (enum tree_code p)
2071 tree id = assignment_operator_name_info[(int) p].identifier;
2072 return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2076 args_to_string (tree p, int verbose)
2080 flags |= TFF_CLASS_KEY_OR_ENUM;
2085 if (TYPE_P (TREE_VALUE (p)))
2086 return type_as_string (p, flags);
2089 for (; p; p = TREE_CHAIN (p))
2091 if (TREE_VALUE (p) == null_node)
2092 pp_cxx_identifier (cxx_pp, "NULL");
2094 dump_type (error_type (TREE_VALUE (p)), flags);
2096 pp_separate_with_comma (cxx_pp);
2098 return pp_formatted_text (cxx_pp);
2102 cv_to_string (tree p, int v)
2105 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2106 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2107 return pp_formatted_text (cxx_pp);
2110 /* Langhook for print_error_function. */
2112 cxx_print_error_function (diagnostic_context *context, const char *file)
2114 lhd_print_error_function (context, file);
2115 pp_base_set_prefix (context->printer, file);
2116 maybe_print_instantiation_context (context);
2120 cp_diagnostic_starter (diagnostic_context *context,
2121 diagnostic_info *diagnostic)
2123 diagnostic_report_current_module (context);
2124 cp_print_error_function (context, diagnostic);
2125 maybe_print_instantiation_context (context);
2126 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2130 cp_diagnostic_finalizer (diagnostic_context *context,
2131 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2133 pp_base_destroy_prefix (context->printer);
2136 /* Print current function onto BUFFER, in the process of reporting
2137 a diagnostic message. Called from cp_diagnostic_starter. */
2139 cp_print_error_function (diagnostic_context *context,
2140 diagnostic_info *diagnostic)
2142 if (diagnostic_last_function_changed (context))
2144 const char *old_prefix = context->printer->prefix;
2145 const char *file = LOCATION_FILE (diagnostic->location);
2146 char *new_prefix = file ? file_name_as_prefix (file) : NULL;
2148 pp_base_set_prefix (context->printer, new_prefix);
2150 if (current_function_decl == NULL)
2151 pp_base_string (context->printer, "At global scope:");
2153 pp_printf (context->printer, "In %s `%s':",
2154 function_category (current_function_decl),
2155 cxx_printable_name (current_function_decl, 2));
2156 pp_base_newline (context->printer);
2158 diagnostic_set_last_function (context);
2159 pp_base_destroy_prefix (context->printer);
2160 context->printer->prefix = old_prefix;
2164 /* Returns a description of FUNCTION using standard terminology. */
2166 function_category (tree fn)
2168 if (DECL_FUNCTION_MEMBER_P (fn))
2170 if (DECL_STATIC_FUNCTION_P (fn))
2171 return "static member function";
2172 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2173 return "copy constructor";
2174 else if (DECL_CONSTRUCTOR_P (fn))
2175 return "constructor";
2176 else if (DECL_DESTRUCTOR_P (fn))
2177 return "destructor";
2179 return "member function";
2185 /* Report the full context of a current template instantiation,
2188 print_instantiation_full_context (diagnostic_context *context)
2190 tree p = current_instantiation ();
2191 location_t location = input_location;
2195 if (current_function_decl != TINST_DECL (p)
2196 && current_function_decl != NULL_TREE)
2197 /* We can get here during the processing of some synthesized
2198 method. Then, TINST_DECL (p) will be the function that's causing
2203 if (current_function_decl == TINST_DECL (p))
2204 /* Avoid redundancy with the the "In function" line. */;
2206 pp_verbatim (context->printer,
2207 "%s: In instantiation of `%s':\n",
2208 LOCATION_FILE (location),
2209 decl_as_string (TINST_DECL (p),
2210 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2212 location = TINST_LOCATION (p);
2217 print_instantiation_partial_context (context, p, location);
2220 /* Same as above but less verbose. */
2222 print_instantiation_partial_context (diagnostic_context *context,
2223 tree t, location_t loc)
2225 expanded_location xloc;
2226 for (; ; t = TREE_CHAIN (t))
2228 xloc = expand_location (loc);
2231 pp_verbatim (context->printer, "%s:%d: instantiated from `%s'\n",
2232 xloc.file, xloc.line,
2233 decl_as_string (TINST_DECL (t),
2234 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2235 loc = TINST_LOCATION (t);
2237 pp_verbatim (context->printer, "%s:%d: instantiated from here\n",
2238 xloc.file, xloc.line);
2241 /* Called from cp_thing to print the template context for an error. */
2243 maybe_print_instantiation_context (diagnostic_context *context)
2245 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2248 record_last_problematic_instantiation ();
2249 print_instantiation_full_context (context);
2252 /* Report the bare minimum context of a template instantiation. */
2254 print_instantiation_context (void)
2256 print_instantiation_partial_context
2257 (global_dc, current_instantiation (), input_location);
2258 diagnostic_flush_buffer (global_dc);
2261 /* Called from output_format -- during diagnostic message processing --
2262 to handle C++ specific format specifier with the following meanings:
2263 %A function argument-list.
2267 %F function declaration.
2268 %L language as used in extern "lang".
2270 %P function parameter whose position is indicated by an integer.
2271 %Q assignment operator.
2275 cp_printer (pretty_printer *pp, text_info *text)
2279 #define next_tree va_arg (*text->args_ptr, tree)
2280 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2281 #define next_lang va_arg (*text->args_ptr, enum languages)
2282 #define next_int va_arg (*text->args_ptr, int)
2284 if (*text->format_spec == '+')
2285 ++text->format_spec;
2286 if (*text->format_spec == '#')
2289 ++text->format_spec;
2292 switch (*text->format_spec)
2294 case 'A': result = args_to_string (next_tree, verbose); break;
2295 case 'C': result = code_to_string (next_tcode); break;
2296 case 'D': result = decl_to_string (next_tree, verbose); break;
2297 case 'E': result = expr_to_string (next_tree); break;
2298 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2299 case 'L': result = language_to_string (next_lang); break;
2300 case 'O': result = op_to_string (next_tcode); break;
2301 case 'P': result = parm_to_string (next_int); break;
2302 case 'Q': result = assop_to_string (next_tcode); break;
2303 case 'T': result = type_to_string (next_tree, verbose); break;
2304 case 'V': result = cv_to_string (next_tree, verbose); break;
2310 pp_base_string (pp, result);
2318 /* These are temporary wrapper functions which handle the historic
2319 behavior of cp_*_at. */
2322 locate_error (const char *msgid, va_list ap)
2328 for (f = msgid; *f; f++)
2341 /* Just ignore these possibilities. */
2344 case 'd': (void) va_arg (ap, int); break;
2345 case 's': (void) va_arg (ap, char *); break;
2346 case 'L': (void) va_arg (ap, enum languages); break;
2349 case 'Q': (void) va_arg (ap, enum tree_code); break;
2351 /* These take a tree, which may be where the error is
2359 t = va_arg (ap, tree);
2365 errorcount = 0; /* damn ICE suppression */
2366 internal_error ("unexpected letter `%c' in locate_error\n", *f);
2372 here = va_arg (ap, tree);
2379 cp_error_at (const char *msgid, ...)
2382 diagnostic_info diagnostic;
2385 va_start (ap, msgid);
2386 here = locate_error (msgid, ap);
2389 va_start (ap, msgid);
2390 diagnostic_set_info (&diagnostic, msgid, &ap,
2391 location_of (here), DK_ERROR);
2392 report_diagnostic (&diagnostic);
2397 cp_warning_at (const char *msgid, ...)
2400 diagnostic_info diagnostic;
2403 va_start (ap, msgid);
2404 here = locate_error (msgid, ap);
2407 va_start (ap, msgid);
2408 diagnostic_set_info (&diagnostic, msgid, &ap,
2409 location_of (here), DK_WARNING);
2410 report_diagnostic (&diagnostic);
2415 cp_pedwarn_at (const char *msgid, ...)
2418 diagnostic_info diagnostic;
2421 va_start (ap, msgid);
2422 here = locate_error (msgid, ap);
2425 va_start (ap, msgid);
2426 diagnostic_set_info (&diagnostic, msgid, &ap,
2427 location_of (here), pedantic_error_kind());
2428 report_diagnostic (&diagnostic);