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, 2006, 2007 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 3, 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 COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
30 #include "diagnostic.h"
31 #include "langhooks-def.h"
32 #include "cxx-pretty-print.h"
34 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
36 /* The global buffer where we dump everything. It is there only for
37 transitional purpose. It is expected, in the near future, to be
38 completely removed. */
39 static cxx_pretty_printer scratch_pretty_printer;
40 #define cxx_pp (&scratch_pretty_printer)
42 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
44 static const char *args_to_string (tree, int);
45 static const char *assop_to_string (enum tree_code);
46 static const char *code_to_string (enum tree_code);
47 static const char *cv_to_string (tree, int);
48 static const char *decl_to_string (tree, int);
49 static const char *expr_to_string (tree);
50 static const char *fndecl_to_string (tree, int);
51 static const char *op_to_string (enum tree_code);
52 static const char *parm_to_string (int);
53 static const char *type_to_string (tree, int);
55 static void dump_type (tree, int);
56 static void dump_typename (tree, int);
57 static void dump_simple_decl (tree, tree, int);
58 static void dump_decl (tree, int);
59 static void dump_template_decl (tree, int);
60 static void dump_function_decl (tree, int);
61 static void dump_expr (tree, int);
62 static void dump_unary_op (const char *, tree, int);
63 static void dump_binary_op (const char *, tree, int);
64 static void dump_aggr_type (tree, int);
65 static void dump_type_prefix (tree, int);
66 static void dump_type_suffix (tree, int);
67 static void dump_function_name (tree, int);
68 static void dump_call_expr_args (tree, int, bool);
69 static void dump_aggr_init_expr_args (tree, int, bool);
70 static void dump_expr_list (tree, int);
71 static void dump_global_iord (tree);
72 static void dump_parameters (tree, int);
73 static void dump_exception_spec (tree, int);
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 *, const char *,
91 int, bool, bool, bool);
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 (ARGUMENT_PACK_P (arg))
141 dump_template_argument_list (ARGUMENT_PACK_ARGS (arg), flags);
142 else if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
143 dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
145 dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
148 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
152 dump_template_argument_list (tree args, int flags)
154 int n = TREE_VEC_LENGTH (args);
158 for (i = 0; i< n; ++i)
160 tree arg = TREE_VEC_ELT (args, i);
162 /* Only print a comma if we know there is an argument coming. In
163 the case of an empty template argument pack, no actual
164 argument will be printed. */
166 && (!ARGUMENT_PACK_P (arg)
167 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
168 pp_separate_with_comma (cxx_pp);
170 dump_template_argument (arg, flags);
175 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
178 dump_template_parameter (tree parm, int flags)
183 if (parm == error_mark_node)
186 p = TREE_VALUE (parm);
187 a = TREE_PURPOSE (parm);
189 if (TREE_CODE (p) == TYPE_DECL)
191 if (flags & TFF_DECL_SPECIFIERS)
193 pp_cxx_identifier (cxx_pp, "class");
194 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p)))
195 pp_cxx_identifier (cxx_pp, "...");
197 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
199 else if (DECL_NAME (p))
200 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
202 pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
205 dump_decl (p, flags | TFF_DECL_SPECIFIERS);
207 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
209 pp_cxx_whitespace (cxx_pp);
211 pp_cxx_whitespace (cxx_pp);
212 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
213 dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
215 dump_expr (a, flags | TFF_EXPR_IN_PARENS);
219 /* Dump, under control of FLAGS, a template-parameter-list binding.
220 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
224 dump_template_bindings (tree parms, tree args)
230 tree p = TREE_VALUE (parms);
231 int lvl = TMPL_PARMS_DEPTH (parms);
235 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
237 tree arg = NULL_TREE;
239 /* Don't crash if we had an invalid argument list. */
240 if (TMPL_ARGS_DEPTH (args) >= lvl)
242 tree lvl_args = TMPL_ARGS_LEVEL (args, lvl);
243 if (NUM_TMPL_ARGS (lvl_args) > arg_idx)
244 arg = TREE_VEC_ELT (lvl_args, arg_idx);
248 pp_separate_with_comma (cxx_pp);
249 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
250 pp_cxx_whitespace (cxx_pp);
252 pp_cxx_whitespace (cxx_pp);
254 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
256 pp_identifier (cxx_pp, "<missing>");
262 parms = TREE_CHAIN (parms);
266 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
270 dump_type (tree t, int flags)
275 if (TYPE_PTRMEMFUNC_P (t))
278 switch (TREE_CODE (t))
281 pp_identifier (cxx_pp, "<unresolved overloaded function type>");
285 /* A list of function parms. */
286 dump_parameters (t, flags);
289 case IDENTIFIER_NODE:
290 pp_cxx_tree_identifier (cxx_pp, t);
294 dump_type (BINFO_TYPE (t), flags);
300 dump_aggr_type (t, flags);
304 if (flags & TFF_CHASE_TYPEDEF)
306 dump_type (DECL_ORIGINAL_TYPE (t)
307 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
310 /* Else fall through. */
314 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
323 pp_type_specifier_seq (cxx_pp, t);
326 case TEMPLATE_TEMPLATE_PARM:
327 /* For parameters inside template signature. */
328 if (TYPE_IDENTIFIER (t))
329 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
331 pp_cxx_canonical_template_parameter (cxx_pp, t);
334 case BOUND_TEMPLATE_TEMPLATE_PARM:
336 tree args = TYPE_TI_ARGS (t);
337 pp_cxx_cv_qualifier_seq (cxx_pp, t);
338 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
339 pp_cxx_begin_template_argument_list (cxx_pp);
340 dump_template_argument_list (args, flags);
341 pp_cxx_end_template_argument_list (cxx_pp);
345 case TEMPLATE_TYPE_PARM:
346 pp_cxx_cv_qualifier_seq (cxx_pp, t);
347 if (TYPE_IDENTIFIER (t))
348 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
350 pp_cxx_canonical_template_parameter
351 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
354 /* This is not always necessary for pointers and such, but doing this
355 reduces code size. */
364 dump_type_prefix (t, flags);
365 dump_type_suffix (t, flags);
369 pp_cxx_cv_qualifier_seq (cxx_pp, t);
370 pp_cxx_identifier (cxx_pp,
371 TYPENAME_IS_ENUM_P (t) ? "enum"
372 : TYPENAME_IS_CLASS_P (t) ? "class"
374 dump_typename (t, flags);
377 case UNBOUND_CLASS_TEMPLATE:
378 dump_type (TYPE_CONTEXT (t), flags);
379 pp_cxx_colon_colon (cxx_pp);
380 pp_cxx_identifier (cxx_pp, "template");
381 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
385 pp_cxx_identifier (cxx_pp, "__typeof__");
386 pp_cxx_whitespace (cxx_pp);
387 pp_cxx_left_paren (cxx_pp);
388 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
389 pp_cxx_right_paren (cxx_pp);
392 case TYPE_PACK_EXPANSION:
393 dump_type (PACK_EXPANSION_PATTERN (t), flags);
394 pp_cxx_identifier (cxx_pp, "...");
397 case TYPE_ARGUMENT_PACK:
399 tree args = ARGUMENT_PACK_ARGS (t);
401 for (i = 0; i < TREE_VEC_LENGTH (args); ++i)
404 pp_separate_with_comma (cxx_pp);
405 dump_type (TREE_VEC_ELT (args, i), flags);
411 pp_cxx_identifier (cxx_pp, "decltype");
412 pp_cxx_whitespace (cxx_pp);
413 pp_cxx_left_paren (cxx_pp);
414 dump_expr (DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
415 pp_cxx_right_paren (cxx_pp);
419 pp_unsupported_tree (cxx_pp, t);
420 /* Fall through to error. */
423 pp_identifier (cxx_pp, "<type error>");
428 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
432 dump_typename (tree t, int flags)
434 tree ctx = TYPE_CONTEXT (t);
436 if (TREE_CODE (ctx) == TYPENAME_TYPE)
437 dump_typename (ctx, flags);
439 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
440 pp_cxx_colon_colon (cxx_pp);
441 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
444 /* Return the name of the supplied aggregate, or enumeral type. */
447 class_key_or_enum_as_string (tree t)
449 if (TREE_CODE (t) == ENUMERAL_TYPE)
451 else if (TREE_CODE (t) == UNION_TYPE)
453 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
459 /* Print out a class declaration T under the control of FLAGS,
460 in the form `class foo'. */
463 dump_aggr_type (tree t, int flags)
466 const char *variety = class_key_or_enum_as_string (t);
470 pp_cxx_cv_qualifier_seq (cxx_pp, t);
472 if (flags & TFF_CLASS_KEY_OR_ENUM)
473 pp_cxx_identifier (cxx_pp, variety);
475 if (flags & TFF_CHASE_TYPEDEF)
476 t = TYPE_MAIN_VARIANT (t);
478 name = TYPE_NAME (t);
482 typdef = !DECL_ARTIFICIAL (name);
483 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
484 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
485 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
486 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
488 if (! (flags & TFF_UNQUALIFIED_NAME))
489 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
490 flags &= ~TFF_UNQUALIFIED_NAME;
493 /* Because the template names are mangled, we have to locate
494 the most general template, and use that name. */
495 tree tpl = CLASSTYPE_TI_TEMPLATE (t);
497 while (DECL_TEMPLATE_INFO (tpl))
498 tpl = DECL_TI_TEMPLATE (tpl);
501 name = DECL_NAME (name);
504 if (name == 0 || ANON_AGGRNAME_P (name))
506 if (flags & TFF_CLASS_KEY_OR_ENUM)
507 pp_identifier (cxx_pp, "<anonymous>");
509 pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety);
512 pp_cxx_tree_identifier (cxx_pp, name);
514 dump_template_parms (TYPE_TEMPLATE_INFO (t),
515 !CLASSTYPE_USE_TEMPLATE (t),
516 flags & ~TFF_TEMPLATE_HEADER);
519 /* Dump into the obstack the initial part of the output for a given type.
520 This is necessary when dealing with things like functions returning
523 return type of `int (* fee ())()': pointer -> function -> int. Both
524 pointer (and reference and offset) and function (and member) types must
525 deal with prefix and suffix.
527 Arrays must also do this for DECL nodes, like int a[], and for things like
531 dump_type_prefix (tree t, int flags)
533 if (TYPE_PTRMEMFUNC_P (t))
535 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
539 switch (TREE_CODE (t))
544 tree sub = TREE_TYPE (t);
546 dump_type_prefix (sub, flags);
547 if (TREE_CODE (sub) == ARRAY_TYPE)
549 pp_cxx_whitespace (cxx_pp);
550 pp_cxx_left_paren (cxx_pp);
552 if (TREE_CODE (t) == POINTER_TYPE)
553 pp_character(cxx_pp, '*');
554 else if (TREE_CODE (t) == REFERENCE_TYPE)
556 if (TYPE_REF_IS_RVALUE (t))
557 pp_string (cxx_pp, "&&");
559 pp_character (cxx_pp, '&');
561 pp_base (cxx_pp)->padding = pp_before;
562 pp_cxx_cv_qualifier_seq (cxx_pp, t);
568 dump_type_prefix (TREE_TYPE (t), flags);
569 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
571 pp_maybe_space (cxx_pp);
572 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
573 pp_cxx_left_paren (cxx_pp);
574 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
575 pp_cxx_colon_colon (cxx_pp);
577 pp_cxx_star (cxx_pp);
578 pp_cxx_cv_qualifier_seq (cxx_pp, t);
579 pp_base (cxx_pp)->padding = pp_before;
582 /* Can only be reached through function pointer -- this would not be
583 correct if FUNCTION_DECLs used it. */
585 dump_type_prefix (TREE_TYPE (t), flags);
586 pp_maybe_space (cxx_pp);
587 pp_cxx_left_paren (cxx_pp);
591 dump_type_prefix (TREE_TYPE (t), flags);
592 pp_maybe_space (cxx_pp);
593 pp_cxx_left_paren (cxx_pp);
594 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
595 pp_cxx_colon_colon (cxx_pp);
599 dump_type_prefix (TREE_TYPE (t), flags);
603 case IDENTIFIER_NODE:
608 case TEMPLATE_TYPE_PARM:
609 case TEMPLATE_TEMPLATE_PARM:
610 case BOUND_TEMPLATE_TEMPLATE_PARM:
622 dump_type (t, flags);
623 pp_base (cxx_pp)->padding = pp_before;
627 pp_unsupported_tree (cxx_pp, t);
630 pp_identifier (cxx_pp, "<typeprefixerror>");
635 /* Dump the suffix of type T, under control of FLAGS. This is the part
636 which appears after the identifier (or function parms). */
639 dump_type_suffix (tree t, int flags)
641 if (TYPE_PTRMEMFUNC_P (t))
642 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
644 switch (TREE_CODE (t))
649 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
650 pp_cxx_right_paren (cxx_pp);
651 dump_type_suffix (TREE_TYPE (t), flags);
654 /* Can only be reached through function pointer. */
659 pp_cxx_right_paren (cxx_pp);
660 arg = TYPE_ARG_TYPES (t);
661 if (TREE_CODE (t) == METHOD_TYPE)
662 arg = TREE_CHAIN (arg);
664 /* Function pointers don't have default args. Not in standard C++,
665 anyway; they may in g++, but we'll just pretend otherwise. */
666 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
668 if (TREE_CODE (t) == METHOD_TYPE)
669 pp_cxx_cv_qualifier_seq
670 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
672 pp_cxx_cv_qualifier_seq(cxx_pp, t);
673 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
674 dump_type_suffix (TREE_TYPE (t), flags);
679 pp_maybe_space (cxx_pp);
680 pp_cxx_left_bracket (cxx_pp);
683 tree dtype = TYPE_DOMAIN (t);
684 tree max = TYPE_MAX_VALUE (dtype);
685 if (host_integerp (max, 0))
686 pp_wide_integer (cxx_pp, tree_low_cst (max, 0) + 1);
687 else if (TREE_CODE (max) == MINUS_EXPR)
688 dump_expr (TREE_OPERAND (max, 0),
689 flags & ~TFF_EXPR_IN_PARENS);
691 dump_expr (fold_build2 (PLUS_EXPR, dtype, max,
692 build_int_cst (dtype, 1)),
693 flags & ~TFF_EXPR_IN_PARENS);
695 pp_cxx_right_bracket (cxx_pp);
696 dump_type_suffix (TREE_TYPE (t), flags);
700 case IDENTIFIER_NODE:
705 case TEMPLATE_TYPE_PARM:
706 case TEMPLATE_TEMPLATE_PARM:
707 case BOUND_TEMPLATE_TEMPLATE_PARM:
722 pp_unsupported_tree (cxx_pp, t);
724 /* Don't mark it here, we should have already done in
731 dump_global_iord (tree t)
733 const char *p = NULL;
735 if (DECL_GLOBAL_CTOR_P (t))
737 else if (DECL_GLOBAL_DTOR_P (t))
742 pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename);
746 dump_simple_decl (tree t, tree type, int flags)
748 if (flags & TFF_DECL_SPECIFIERS)
750 dump_type_prefix (type, flags & ~TFF_UNQUALIFIED_NAME);
751 pp_maybe_space (cxx_pp);
753 if (! (flags & TFF_UNQUALIFIED_NAME)
754 && (!DECL_INITIAL (t)
755 || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
756 dump_scope (CP_DECL_CONTEXT (t), flags);
757 flags &= ~TFF_UNQUALIFIED_NAME;
759 dump_decl (DECL_NAME (t), flags);
761 pp_identifier (cxx_pp, "<anonymous>");
762 if (flags & TFF_DECL_SPECIFIERS)
763 dump_type_suffix (type, flags);
766 /* Dump a human readable string for the decl T under control of FLAGS. */
769 dump_decl (tree t, int flags)
774 switch (TREE_CODE (t))
777 /* Don't say 'typedef class A' */
778 if (DECL_ARTIFICIAL (t))
780 if ((flags & TFF_DECL_SPECIFIERS)
781 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
782 /* Say `class T' not just `T'. */
783 pp_cxx_identifier (cxx_pp, "class");
785 dump_type (TREE_TYPE (t), flags);
788 if (flags & TFF_DECL_SPECIFIERS)
789 pp_cxx_identifier (cxx_pp, "typedef");
790 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
791 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
796 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
798 pp_string (cxx_pp, "vtable for ");
799 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
800 dump_type (DECL_CONTEXT (t), flags);
803 /* Else fall through. */
806 dump_simple_decl (t, TREE_TYPE (t), flags);
810 pp_string (cxx_pp, "<return value> ");
811 dump_simple_decl (t, TREE_TYPE (t), flags);
815 if (flags & TFF_DECL_SPECIFIERS)
816 pp_cxx_declaration (cxx_pp, t);
819 if (! (flags & TFF_UNQUALIFIED_NAME))
820 dump_scope (CP_DECL_CONTEXT (t), flags);
821 flags &= ~TFF_UNQUALIFIED_NAME;
822 if (DECL_NAME (t) == NULL_TREE)
823 pp_identifier (cxx_pp, "<unnamed>");
825 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
830 pp_expression (cxx_pp, t);
834 dump_decl (TREE_OPERAND (t, 0), flags);
835 pp_cxx_left_bracket (cxx_pp);
836 dump_decl (TREE_OPERAND (t, 1), flags);
837 pp_cxx_right_bracket (cxx_pp);
840 /* So that we can do dump_decl on an aggr type. */
844 dump_type (t, flags);
848 /* This is a pseudo destructor call which has not been folded into
849 a PSEUDO_DTOR_EXPR yet. */
850 pp_cxx_complement (cxx_pp);
851 dump_type (TREE_OPERAND (t, 0), flags);
858 /* These special cases are duplicated here so that other functions
859 can feed identifiers to error and get them demangled properly. */
860 case IDENTIFIER_NODE:
861 if (IDENTIFIER_TYPENAME_P (t))
863 pp_cxx_identifier (cxx_pp, "operator");
864 /* Not exactly IDENTIFIER_TYPE_VALUE. */
865 dump_type (TREE_TYPE (t), flags);
869 pp_cxx_tree_identifier (cxx_pp, t);
876 if (DECL_CLASS_SCOPE_P (t))
878 dump_type (DECL_CONTEXT (t), flags);
879 pp_cxx_colon_colon (cxx_pp);
881 else if (DECL_CONTEXT (t))
883 dump_decl (DECL_CONTEXT (t), flags);
884 pp_cxx_colon_colon (cxx_pp);
886 dump_decl (DECL_NAME (t), flags);
890 /* If there's only one function, just treat it like an ordinary
896 if (! DECL_LANG_SPECIFIC (t))
897 pp_identifier (cxx_pp, "<built-in>");
898 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
899 dump_global_iord (t);
901 dump_function_decl (t, flags);
905 dump_template_decl (t, flags);
908 case TEMPLATE_ID_EXPR:
910 tree name = TREE_OPERAND (t, 0);
912 if (is_overloaded_fn (name))
913 name = DECL_NAME (get_first_fn (name));
914 dump_decl (name, flags);
915 pp_cxx_begin_template_argument_list (cxx_pp);
916 if (TREE_OPERAND (t, 1))
917 dump_template_argument_list (TREE_OPERAND (t, 1), flags);
918 pp_cxx_end_template_argument_list (cxx_pp);
923 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
927 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
928 || (DECL_INITIAL (t) &&
929 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
930 dump_simple_decl (t, TREE_TYPE (t), flags);
931 else if (DECL_NAME (t))
932 dump_decl (DECL_NAME (t), flags);
933 else if (DECL_INITIAL (t))
934 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
936 pp_identifier (cxx_pp, "<enumerator>");
940 pp_cxx_identifier (cxx_pp, "using");
941 dump_type (USING_DECL_SCOPE (t), flags);
942 pp_cxx_colon_colon (cxx_pp);
943 dump_decl (DECL_NAME (t), flags);
947 pp_cxx_declaration (cxx_pp, t);
951 dump_decl (BASELINK_FUNCTIONS (t), flags);
954 case NON_DEPENDENT_EXPR:
955 dump_expr (t, flags);
958 case TEMPLATE_TYPE_PARM:
959 if (flags & TFF_DECL_SPECIFIERS)
960 pp_cxx_declaration (cxx_pp, t);
962 pp_type_id (cxx_pp, t);
965 case UNBOUND_CLASS_TEMPLATE:
966 dump_type (t, flags);
970 pp_unsupported_tree (cxx_pp, t);
971 /* Fall through to error. */
974 pp_identifier (cxx_pp, "<declaration error>");
979 /* Dump a template declaration T under control of FLAGS. This means the
980 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
983 dump_template_decl (tree t, int flags)
985 tree orig_parms = DECL_TEMPLATE_PARMS (t);
989 if (flags & TFF_TEMPLATE_HEADER)
991 for (parms = orig_parms = nreverse (orig_parms);
993 parms = TREE_CHAIN (parms))
995 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
996 int len = TREE_VEC_LENGTH (inner_parms);
998 pp_cxx_identifier (cxx_pp, "template");
999 pp_cxx_begin_template_argument_list (cxx_pp);
1001 /* If we've shown the template prefix, we'd better show the
1002 parameters' and decl's type too. */
1003 flags |= TFF_DECL_SPECIFIERS;
1005 for (i = 0; i < len; i++)
1008 pp_separate_with_comma (cxx_pp);
1009 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
1011 pp_cxx_end_template_argument_list (cxx_pp);
1012 pp_cxx_whitespace (cxx_pp);
1014 nreverse(orig_parms);
1016 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1017 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1018 pp_cxx_identifier (cxx_pp, "class");
1021 if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
1022 dump_type (TREE_TYPE (t),
1023 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1024 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1025 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
1026 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1029 gcc_assert (TREE_TYPE (t));
1030 switch (NEXT_CODE (t))
1034 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1037 /* This case can occur with some invalid code. */
1038 dump_type (TREE_TYPE (t),
1039 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1040 | (flags & TFF_DECL_SPECIFIERS
1041 ? TFF_CLASS_KEY_OR_ENUM : 0));
1046 /* Pretty print a function decl. There are several ways we want to print a
1047 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1048 As error can only apply the '#' flag once to give 0 and 1 for V, there
1049 is %D which doesn't print the throw specs, and %F which does. */
1052 dump_function_decl (tree t, int flags)
1056 tree cname = NULL_TREE;
1057 tree template_args = NULL_TREE;
1058 tree template_parms = NULL_TREE;
1059 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1060 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1062 flags &= ~TFF_UNQUALIFIED_NAME;
1063 if (TREE_CODE (t) == TEMPLATE_DECL)
1064 t = DECL_TEMPLATE_RESULT (t);
1066 /* Pretty print template instantiations only. */
1067 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t))
1071 template_args = DECL_TI_ARGS (t);
1072 tmpl = most_general_template (t);
1073 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1075 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1080 fntype = TREE_TYPE (t);
1081 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1083 if (DECL_CLASS_SCOPE_P (t))
1084 cname = DECL_CONTEXT (t);
1085 /* This is for partially instantiated template methods. */
1086 else if (TREE_CODE (fntype) == METHOD_TYPE)
1087 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1089 if (!(flags & TFF_DECL_SPECIFIERS))
1091 else if (DECL_STATIC_FUNCTION_P (t))
1092 pp_cxx_identifier (cxx_pp, "static");
1093 else if (DECL_VIRTUAL_P (t))
1094 pp_cxx_identifier (cxx_pp, "virtual");
1096 /* Print the return type? */
1098 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1099 && !DECL_DESTRUCTOR_P (t);
1101 dump_type_prefix (TREE_TYPE (fntype), flags);
1103 /* Print the function name. */
1104 if (!do_outer_scope)
1108 dump_type (cname, flags);
1109 pp_cxx_colon_colon (cxx_pp);
1112 dump_scope (CP_DECL_CONTEXT (t), flags);
1114 dump_function_name (t, flags);
1116 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1118 dump_parameters (parmtypes, flags);
1120 if (TREE_CODE (fntype) == METHOD_TYPE)
1122 pp_base (cxx_pp)->padding = pp_before;
1123 pp_cxx_cv_qualifier_seq
1124 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1127 if (flags & TFF_EXCEPTION_SPECIFICATION)
1129 pp_base (cxx_pp)->padding = pp_before;
1130 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
1134 dump_type_suffix (TREE_TYPE (fntype), flags);
1137 /* If T is a template instantiation, dump the parameter binding. */
1138 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1140 pp_cxx_whitespace (cxx_pp);
1141 pp_cxx_left_bracket (cxx_pp);
1142 pp_cxx_identifier (cxx_pp, "with");
1143 pp_cxx_whitespace (cxx_pp);
1144 dump_template_bindings (template_parms, template_args);
1145 pp_cxx_right_bracket (cxx_pp);
1149 /* Print a parameter list. If this is for a member function, the
1150 member object ptr (and any other hidden args) should have
1151 already been removed. */
1154 dump_parameters (tree parmtypes, int flags)
1157 pp_cxx_left_paren (cxx_pp);
1159 for (first = 1; parmtypes != void_list_node;
1160 parmtypes = TREE_CHAIN (parmtypes))
1163 pp_separate_with_comma (cxx_pp);
1167 pp_cxx_identifier (cxx_pp, "...");
1170 if (ARGUMENT_PACK_P (TREE_VALUE (parmtypes)))
1172 tree types = ARGUMENT_PACK_ARGS (TREE_VALUE (parmtypes));
1173 int i, len = TREE_VEC_LENGTH (types);
1175 for (i = 0; i < len; ++i)
1178 pp_separate_with_comma (cxx_pp);
1181 dump_type (TREE_VEC_ELT (types, i), flags);
1185 dump_type (TREE_VALUE (parmtypes), flags);
1187 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1189 pp_cxx_whitespace (cxx_pp);
1191 pp_cxx_whitespace (cxx_pp);
1192 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1196 pp_cxx_right_paren (cxx_pp);
1199 /* Print an exception specification. T is the exception specification. */
1202 dump_exception_spec (tree t, int flags)
1206 pp_cxx_identifier (cxx_pp, "throw");
1207 pp_cxx_whitespace (cxx_pp);
1208 pp_cxx_left_paren (cxx_pp);
1209 if (TREE_VALUE (t) != NULL_TREE)
1212 dump_type (TREE_VALUE (t), flags);
1216 pp_separate_with_comma (cxx_pp);
1218 pp_cxx_right_paren (cxx_pp);
1222 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1223 and destructors properly. */
1226 dump_function_name (tree t, int flags)
1228 tree name = DECL_NAME (t);
1230 /* We can get here with a decl that was synthesized by language-
1231 independent machinery (e.g. coverage.c) in which case it won't
1232 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1233 will crash. In this case it is safe just to print out the
1235 if (!DECL_LANG_SPECIFIC (t))
1237 pp_cxx_tree_identifier (cxx_pp, name);
1241 if (TREE_CODE (t) == TEMPLATE_DECL)
1242 t = DECL_TEMPLATE_RESULT (t);
1244 /* Don't let the user see __comp_ctor et al. */
1245 if (DECL_CONSTRUCTOR_P (t)
1246 || DECL_DESTRUCTOR_P (t))
1247 name = constructor_name (DECL_CONTEXT (t));
1249 if (DECL_DESTRUCTOR_P (t))
1251 pp_cxx_complement (cxx_pp);
1252 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1254 else if (DECL_CONV_FN_P (t))
1256 /* This cannot use the hack that the operator's return
1257 type is stashed off of its name because it may be
1258 used for error reporting. In the case of conflicting
1259 declarations, both will have the same name, yet
1260 the types will be different, hence the TREE_TYPE field
1261 of the first name will be clobbered by the second. */
1262 pp_cxx_identifier (cxx_pp, "operator");
1263 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1265 else if (IDENTIFIER_OPNAME_P (name))
1266 pp_cxx_tree_identifier (cxx_pp, name);
1268 dump_decl (name, flags);
1270 if (DECL_TEMPLATE_INFO (t)
1271 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1272 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1273 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1274 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1277 /* Dump the template parameters from the template info INFO under control of
1278 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1279 specialization (partial or complete). For partial specializations we show
1280 the specialized parameter values. For a primary template we show no
1284 dump_template_parms (tree info, int primary, int flags)
1286 tree args = info ? TI_ARGS (info) : NULL_TREE;
1288 if (primary && flags & TFF_TEMPLATE_NAME)
1290 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1291 pp_cxx_begin_template_argument_list (cxx_pp);
1293 /* Be careful only to print things when we have them, so as not
1294 to crash producing error messages. */
1295 if (args && !primary)
1299 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
1300 args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
1302 len = TREE_VEC_LENGTH (args);
1304 for (ix = 0; ix != len; ix++)
1306 tree arg = TREE_VEC_ELT (args, ix);
1308 /* Only print a comma if we know there is an argument coming. In
1309 the case of an empty template argument pack, no actual
1310 argument will be printed. */
1312 && (!ARGUMENT_PACK_P (arg)
1313 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1314 pp_separate_with_comma (cxx_pp);
1317 pp_identifier (cxx_pp, "<template parameter error>");
1319 dump_template_argument (arg, flags);
1324 tree tpl = TI_TEMPLATE (info);
1325 tree parms = DECL_TEMPLATE_PARMS (tpl);
1328 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1329 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1331 for (ix = 0; ix != len; ix++)
1335 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1337 pp_identifier (cxx_pp, "<template parameter error>");
1341 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1344 pp_separate_with_comma (cxx_pp);
1346 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1349 pp_cxx_end_template_argument_list (cxx_pp);
1352 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1353 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1356 dump_call_expr_args (tree t, int flags, bool skipfirst)
1359 call_expr_arg_iterator iter;
1361 pp_cxx_left_paren (cxx_pp);
1362 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1368 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1369 if (more_call_expr_args_p (&iter))
1370 pp_separate_with_comma (cxx_pp);
1373 pp_cxx_right_paren (cxx_pp);
1376 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1377 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1381 dump_aggr_init_expr_args (tree t, int flags, bool skipfirst)
1384 aggr_init_expr_arg_iterator iter;
1386 pp_cxx_left_paren (cxx_pp);
1387 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1393 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1394 if (more_aggr_init_expr_args_p (&iter))
1395 pp_separate_with_comma (cxx_pp);
1398 pp_cxx_right_paren (cxx_pp);
1401 /* Print out a list of initializers (subr of dump_expr). */
1404 dump_expr_list (tree l, int flags)
1408 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1411 pp_separate_with_comma (cxx_pp);
1415 /* Print out a vector of initializers (subr of dump_expr). */
1418 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1420 unsigned HOST_WIDE_INT idx;
1423 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1425 dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1426 if (idx != VEC_length (constructor_elt, v) - 1)
1427 pp_separate_with_comma (cxx_pp);
1432 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1433 function. Resolve it to a close relative -- in the sense of static
1434 type -- variant being overridden. That is close to what was written in
1435 the source code. Subroutine of dump_expr. */
1438 resolve_virtual_fun_from_obj_type_ref (tree ref)
1440 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1441 HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1442 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1445 fun = TREE_CHAIN (fun);
1446 index -= (TARGET_VTABLE_USES_DESCRIPTORS
1447 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
1453 /* Print out an expression E under control of FLAGS. */
1456 dump_expr (tree t, int flags)
1461 switch (TREE_CODE (t))
1469 case NAMESPACE_DECL:
1472 case IDENTIFIER_NODE:
1473 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1479 pp_constant (cxx_pp, t);
1483 pp_cxx_identifier (cxx_pp, "throw");
1484 dump_expr (TREE_OPERAND (t, 0), flags);
1488 pp_ampersand (cxx_pp);
1489 dump_type (PTRMEM_CST_CLASS (t), flags);
1490 pp_cxx_colon_colon (cxx_pp);
1491 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1495 pp_cxx_left_paren (cxx_pp);
1496 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1497 pp_separate_with_comma (cxx_pp);
1498 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1499 pp_cxx_right_paren (cxx_pp);
1503 pp_cxx_left_paren (cxx_pp);
1504 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1505 pp_string (cxx_pp, " ? ");
1506 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1507 pp_string (cxx_pp, " : ");
1508 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1509 pp_cxx_right_paren (cxx_pp);
1513 if (TREE_HAS_CONSTRUCTOR (t))
1515 pp_cxx_identifier (cxx_pp, "new");
1516 pp_cxx_whitespace (cxx_pp);
1517 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1520 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1523 case AGGR_INIT_EXPR:
1525 tree fn = NULL_TREE;
1527 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
1528 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
1530 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1532 if (DECL_CONSTRUCTOR_P (fn))
1533 dump_type (DECL_CONTEXT (fn), flags);
1538 dump_expr (AGGR_INIT_EXPR_FN (t), 0);
1540 dump_aggr_init_expr_args (t, flags, true);
1545 tree fn = CALL_EXPR_FN (t);
1546 bool skipfirst = false;
1548 if (TREE_CODE (fn) == ADDR_EXPR)
1549 fn = TREE_OPERAND (fn, 0);
1551 /* Nobody is interested in seeing the guts of vcalls. */
1552 if (TREE_CODE (fn) == OBJ_TYPE_REF)
1553 fn = resolve_virtual_fun_from_obj_type_ref (fn);
1555 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1557 tree ob = CALL_EXPR_ARG (t, 0);
1558 if (TREE_CODE (ob) == ADDR_EXPR)
1560 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1561 pp_cxx_dot (cxx_pp);
1563 else if (TREE_CODE (ob) != PARM_DECL
1564 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1566 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1567 pp_cxx_arrow (cxx_pp);
1571 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1572 dump_call_expr_args (t, flags, skipfirst);
1578 tree type = TREE_OPERAND (t, 1);
1579 tree init = TREE_OPERAND (t, 2);
1580 if (NEW_EXPR_USE_GLOBAL (t))
1581 pp_cxx_colon_colon (cxx_pp);
1582 pp_cxx_identifier (cxx_pp, "new");
1583 if (TREE_OPERAND (t, 0))
1585 pp_cxx_left_paren (cxx_pp);
1586 dump_expr_list (TREE_OPERAND (t, 0), flags);
1587 pp_cxx_right_paren (cxx_pp);
1588 pp_cxx_whitespace (cxx_pp);
1590 if (TREE_CODE (type) == ARRAY_REF)
1591 type = build_cplus_array_type
1592 (TREE_OPERAND (type, 0),
1593 build_index_type (fold_build2 (MINUS_EXPR, integer_type_node,
1594 TREE_OPERAND (type, 1),
1595 integer_one_node)));
1596 dump_type (type, flags);
1599 pp_cxx_left_paren (cxx_pp);
1600 if (TREE_CODE (init) == TREE_LIST)
1601 dump_expr_list (init, flags);
1602 else if (init == void_zero_node)
1603 /* This representation indicates an empty initializer,
1604 e.g.: "new int()". */
1607 dump_expr (init, flags);
1608 pp_cxx_right_paren (cxx_pp);
1614 /* Note that this only works for G++ target exprs. If somebody
1615 builds a general TARGET_EXPR, there's no way to represent that
1616 it initializes anything other that the parameter slot for the
1617 default argument. Note we may have cleared out the first
1618 operand in expand_expr, so don't go killing ourselves. */
1619 if (TREE_OPERAND (t, 1))
1620 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1623 case POINTER_PLUS_EXPR:
1624 dump_binary_op ("+", t, flags);
1632 case TRUNC_DIV_EXPR:
1633 case TRUNC_MOD_EXPR:
1641 case TRUTH_ANDIF_EXPR:
1642 case TRUTH_ORIF_EXPR:
1649 case EXACT_DIV_EXPR:
1650 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1654 case FLOOR_DIV_EXPR:
1655 case ROUND_DIV_EXPR:
1657 dump_binary_op ("/", t, flags);
1661 case FLOOR_MOD_EXPR:
1662 case ROUND_MOD_EXPR:
1663 dump_binary_op ("%", t, flags);
1668 tree ob = TREE_OPERAND (t, 0);
1669 if (TREE_CODE (ob) == INDIRECT_REF)
1671 ob = TREE_OPERAND (ob, 0);
1672 if (TREE_CODE (ob) != PARM_DECL
1674 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1676 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1677 pp_cxx_arrow (cxx_pp);
1682 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1683 pp_cxx_dot (cxx_pp);
1685 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1690 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1691 pp_cxx_left_bracket (cxx_pp);
1692 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1693 pp_cxx_right_bracket (cxx_pp);
1696 case UNARY_PLUS_EXPR:
1697 dump_unary_op ("+", t, flags);
1701 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1702 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1703 /* An ADDR_EXPR can have reference type. In that case, we
1704 shouldn't print the `&' doing so indicates to the user
1705 that the expression has pointer type. */
1707 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1708 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1709 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1710 dump_unary_op ("&&", t, flags);
1712 dump_unary_op ("&", t, flags);
1716 if (TREE_HAS_CONSTRUCTOR (t))
1718 t = TREE_OPERAND (t, 0);
1719 gcc_assert (TREE_CODE (t) == CALL_EXPR);
1720 dump_expr (CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
1721 dump_call_expr_args (t, flags, true);
1725 if (TREE_OPERAND (t,0) != NULL_TREE
1726 && TREE_TYPE (TREE_OPERAND (t, 0))
1727 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1728 dump_expr (TREE_OPERAND (t, 0), flags);
1730 dump_unary_op ("*", t, flags);
1736 case TRUTH_NOT_EXPR:
1737 case PREDECREMENT_EXPR:
1738 case PREINCREMENT_EXPR:
1739 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1742 case POSTDECREMENT_EXPR:
1743 case POSTINCREMENT_EXPR:
1744 pp_cxx_left_paren (cxx_pp);
1745 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1746 pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1747 pp_cxx_right_paren (cxx_pp);
1750 case NON_LVALUE_EXPR:
1751 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1752 should be another level of INDIRECT_REF so that I don't have to do
1754 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1756 tree next = TREE_TYPE (TREE_TYPE (t));
1758 while (TREE_CODE (next) == POINTER_TYPE)
1759 next = TREE_TYPE (next);
1761 if (TREE_CODE (next) == FUNCTION_TYPE)
1763 if (flags & TFF_EXPR_IN_PARENS)
1764 pp_cxx_left_paren (cxx_pp);
1765 pp_cxx_star (cxx_pp);
1766 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1767 if (flags & TFF_EXPR_IN_PARENS)
1768 pp_cxx_right_paren (cxx_pp);
1771 /* Else fall through. */
1773 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1779 tree op = TREE_OPERAND (t, 0);
1781 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1783 /* It is a cast, but we cannot tell whether it is a
1784 reinterpret or static cast. Use the C style notation. */
1785 if (flags & TFF_EXPR_IN_PARENS)
1786 pp_cxx_left_paren (cxx_pp);
1787 pp_cxx_left_paren (cxx_pp);
1788 dump_type (TREE_TYPE (t), flags);
1789 pp_cxx_right_paren (cxx_pp);
1790 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1791 if (flags & TFF_EXPR_IN_PARENS)
1792 pp_cxx_right_paren (cxx_pp);
1795 dump_expr (op, flags);
1800 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1802 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1804 if (integer_zerop (idx))
1806 /* A NULL pointer-to-member constant. */
1807 pp_cxx_left_paren (cxx_pp);
1808 pp_cxx_left_paren (cxx_pp);
1809 dump_type (TREE_TYPE (t), flags);
1810 pp_cxx_right_paren (cxx_pp);
1811 pp_character (cxx_pp, '0');
1812 pp_cxx_right_paren (cxx_pp);
1815 else if (host_integerp (idx, 0))
1818 unsigned HOST_WIDE_INT n;
1820 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1821 t = TYPE_METHOD_BASETYPE (t);
1822 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1824 n = tree_low_cst (idx, 0);
1826 /* Map vtable index back one, to allow for the null pointer to
1830 while (n > 0 && virtuals)
1833 virtuals = TREE_CHAIN (virtuals);
1837 dump_expr (BV_FN (virtuals),
1838 flags | TFF_EXPR_IN_PARENS);
1843 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
1845 dump_type (TREE_TYPE (t), 0);
1846 pp_cxx_left_paren (cxx_pp);
1847 pp_cxx_right_paren (cxx_pp);
1851 pp_cxx_left_brace (cxx_pp);
1852 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
1853 pp_cxx_right_brace (cxx_pp);
1860 tree ob = TREE_OPERAND (t, 0);
1861 if (is_dummy_object (ob))
1863 t = TREE_OPERAND (t, 1);
1864 if (TREE_CODE (t) == FUNCTION_DECL)
1866 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1867 else if (BASELINK_P (t))
1868 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1869 flags | TFF_EXPR_IN_PARENS);
1871 dump_decl (t, flags);
1875 if (TREE_CODE (ob) == INDIRECT_REF)
1877 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1878 pp_cxx_arrow (cxx_pp);
1879 pp_cxx_star (cxx_pp);
1883 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1884 pp_cxx_dot (cxx_pp);
1885 pp_cxx_star (cxx_pp);
1887 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1892 case TEMPLATE_PARM_INDEX:
1893 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1897 pp_expression (cxx_pp, t);
1901 if (TREE_OPERAND (t, 0) == NULL_TREE
1902 || TREE_CHAIN (TREE_OPERAND (t, 0)))
1904 dump_type (TREE_TYPE (t), flags);
1905 pp_cxx_left_paren (cxx_pp);
1906 dump_expr_list (TREE_OPERAND (t, 0), flags);
1907 pp_cxx_right_paren (cxx_pp);
1911 pp_cxx_left_paren (cxx_pp);
1912 dump_type (TREE_TYPE (t), flags);
1913 pp_cxx_right_paren (cxx_pp);
1914 pp_cxx_left_paren (cxx_pp);
1915 dump_expr_list (TREE_OPERAND (t, 0), flags);
1916 pp_cxx_right_paren (cxx_pp);
1920 case STATIC_CAST_EXPR:
1921 pp_cxx_identifier (cxx_pp, "static_cast");
1923 case REINTERPRET_CAST_EXPR:
1924 pp_cxx_identifier (cxx_pp, "reinterpret_cast");
1926 case CONST_CAST_EXPR:
1927 pp_cxx_identifier (cxx_pp, "const_cast");
1929 case DYNAMIC_CAST_EXPR:
1930 pp_cxx_identifier (cxx_pp, "dynamic_cast");
1932 pp_cxx_begin_template_argument_list (cxx_pp);
1933 dump_type (TREE_TYPE (t), flags);
1934 pp_cxx_end_template_argument_list (cxx_pp);
1935 pp_cxx_left_paren (cxx_pp);
1936 dump_expr (TREE_OPERAND (t, 0), flags);
1937 pp_cxx_right_paren (cxx_pp);
1941 dump_expr (TREE_OPERAND (t, 0), flags);
1942 pp_cxx_arrow (cxx_pp);
1947 if (TREE_CODE (t) == SIZEOF_EXPR)
1948 pp_cxx_identifier (cxx_pp, "sizeof");
1951 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
1952 pp_cxx_identifier (cxx_pp, "__alignof__");
1954 pp_cxx_whitespace (cxx_pp);
1955 pp_cxx_left_paren (cxx_pp);
1956 if (TYPE_P (TREE_OPERAND (t, 0)))
1957 dump_type (TREE_OPERAND (t, 0), flags);
1959 dump_expr (TREE_OPERAND (t, 0), flags);
1960 pp_cxx_right_paren (cxx_pp);
1965 pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
1966 pp_cxx_whitespace (cxx_pp);
1967 dump_expr (TREE_OPERAND (t, 0), flags);
1971 pp_identifier (cxx_pp, "<unparsed>");
1974 case TRY_CATCH_EXPR:
1975 case WITH_CLEANUP_EXPR:
1976 case CLEANUP_POINT_EXPR:
1977 dump_expr (TREE_OPERAND (t, 0), flags);
1980 case PSEUDO_DTOR_EXPR:
1981 dump_expr (TREE_OPERAND (t, 2), flags);
1982 pp_cxx_dot (cxx_pp);
1983 dump_type (TREE_OPERAND (t, 0), flags);
1984 pp_cxx_colon_colon (cxx_pp);
1985 pp_cxx_complement (cxx_pp);
1986 dump_type (TREE_OPERAND (t, 1), flags);
1989 case TEMPLATE_ID_EXPR:
1990 dump_decl (t, flags);
1995 case STATEMENT_LIST:
1996 /* We don't yet have a way of dumping statements in a
1997 human-readable format. */
1998 pp_string (cxx_pp, "({...})");
2002 pp_string (cxx_pp, "while (1) { ");
2003 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2004 pp_cxx_right_brace (cxx_pp);
2008 pp_string (cxx_pp, "if (");
2009 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2010 pp_string (cxx_pp, ") break; ");
2014 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
2017 case EMPTY_CLASS_EXPR:
2018 dump_type (TREE_TYPE (t), flags);
2019 pp_cxx_left_paren (cxx_pp);
2020 pp_cxx_right_paren (cxx_pp);
2023 case NON_DEPENDENT_EXPR:
2024 dump_expr (TREE_OPERAND (t, 0), flags);
2027 case EXPR_PACK_EXPANSION:
2028 dump_expr (PACK_EXPANSION_PATTERN (t), flags);
2029 pp_cxx_identifier (cxx_pp, "...");
2041 pp_type_specifier_seq (cxx_pp, t);
2045 /* We get here when we want to print a dependent type as an
2046 id-expression, without any disambiguator decoration. */
2047 pp_id_expression (cxx_pp, t);
2050 /* This list is incomplete, but should suffice for now.
2051 It is very important that `sorry' does not call
2052 `report_error_function'. That could cause an infinite loop. */
2054 pp_unsupported_tree (cxx_pp, t);
2055 /* fall through to ERROR_MARK... */
2057 pp_identifier (cxx_pp, "<expression error>");
2063 dump_binary_op (const char *opstring, tree t, int flags)
2065 pp_cxx_left_paren (cxx_pp);
2066 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2067 pp_cxx_whitespace (cxx_pp);
2069 pp_cxx_identifier (cxx_pp, opstring);
2071 pp_identifier (cxx_pp, "<unknown operator>");
2072 pp_cxx_whitespace (cxx_pp);
2073 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2074 pp_cxx_right_paren (cxx_pp);
2078 dump_unary_op (const char *opstring, tree t, int flags)
2080 if (flags & TFF_EXPR_IN_PARENS)
2081 pp_cxx_left_paren (cxx_pp);
2082 pp_cxx_identifier (cxx_pp, opstring);
2083 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2084 if (flags & TFF_EXPR_IN_PARENS)
2085 pp_cxx_right_paren (cxx_pp);
2089 reinit_cxx_pp (void)
2091 pp_clear_output_area (cxx_pp);
2092 pp_base (cxx_pp)->padding = pp_none;
2093 pp_indentation (cxx_pp) = 0;
2094 pp_needs_newline (cxx_pp) = false;
2095 cxx_pp->enclosing_scope = 0;
2099 /* Exported interface to stringifying types, exprs and decls under TFF_*
2103 type_as_string (tree typ, int flags)
2106 dump_type (typ, flags);
2107 return pp_formatted_text (cxx_pp);
2111 expr_as_string (tree decl, int flags)
2114 dump_expr (decl, flags);
2115 return pp_formatted_text (cxx_pp);
2119 decl_as_string (tree decl, int flags)
2122 dump_decl (decl, flags);
2123 return pp_formatted_text (cxx_pp);
2126 /* Generate the three forms of printable names for cxx_printable_name. */
2129 lang_decl_name (tree decl, int v)
2132 return decl_as_string (decl, TFF_DECL_SPECIFIERS);
2135 if (v == 1 && DECL_CLASS_SCOPE_P (decl))
2137 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2138 pp_cxx_colon_colon (cxx_pp);
2141 if (TREE_CODE (decl) == FUNCTION_DECL)
2142 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2144 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2146 return pp_formatted_text (cxx_pp);
2149 /* Return the location of a tree passed to %+ formats. */
2152 location_of (tree t)
2154 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2155 t = DECL_CONTEXT (t);
2156 else if (TYPE_P (t))
2157 t = TYPE_MAIN_DECL (t);
2158 else if (TREE_CODE (t) == OVERLOAD)
2159 t = OVL_FUNCTION (t);
2161 return DECL_SOURCE_LOCATION (t);
2164 /* Now the interfaces from error et al to dump_type et al. Each takes an
2165 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2169 decl_to_string (tree decl, int verbose)
2173 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2174 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2175 flags = TFF_CLASS_KEY_OR_ENUM;
2177 flags |= TFF_DECL_SPECIFIERS;
2178 else if (TREE_CODE (decl) == FUNCTION_DECL)
2179 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2180 flags |= TFF_TEMPLATE_HEADER;
2183 dump_decl (decl, flags);
2184 return pp_formatted_text (cxx_pp);
2188 expr_to_string (tree decl)
2191 dump_expr (decl, 0);
2192 return pp_formatted_text (cxx_pp);
2196 fndecl_to_string (tree fndecl, int verbose)
2200 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2201 | TFF_TEMPLATE_HEADER;
2203 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2205 dump_decl (fndecl, flags);
2206 return pp_formatted_text (cxx_pp);
2211 code_to_string (enum tree_code c)
2213 return tree_code_name [c];
2217 language_to_string (enum languages c)
2224 case lang_cplusplus:
2236 /* Return the proper printed version of a parameter to a C++ function. */
2239 parm_to_string (int p)
2243 pp_string (cxx_pp, "'this'");
2245 pp_decimal_int (cxx_pp, p + 1);
2246 return pp_formatted_text (cxx_pp);
2250 op_to_string (enum tree_code p)
2252 tree id = operator_name_info[(int) p].identifier;
2253 return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2257 type_to_string (tree typ, int verbose)
2261 flags |= TFF_CLASS_KEY_OR_ENUM;
2262 flags |= TFF_TEMPLATE_HEADER;
2265 dump_type (typ, flags);
2266 return pp_formatted_text (cxx_pp);
2270 assop_to_string (enum tree_code p)
2272 tree id = assignment_operator_name_info[(int) p].identifier;
2273 return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2277 args_to_string (tree p, int verbose)
2281 flags |= TFF_CLASS_KEY_OR_ENUM;
2286 if (TYPE_P (TREE_VALUE (p)))
2287 return type_as_string (p, flags);
2290 for (; p; p = TREE_CHAIN (p))
2292 if (TREE_VALUE (p) == null_node)
2293 pp_cxx_identifier (cxx_pp, "NULL");
2295 dump_type (error_type (TREE_VALUE (p)), flags);
2297 pp_separate_with_comma (cxx_pp);
2299 return pp_formatted_text (cxx_pp);
2303 cv_to_string (tree p, int v)
2306 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2307 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2308 return pp_formatted_text (cxx_pp);
2311 /* Langhook for print_error_function. */
2313 cxx_print_error_function (diagnostic_context *context, const char *file)
2315 lhd_print_error_function (context, file);
2316 pp_base_set_prefix (context->printer, file);
2317 maybe_print_instantiation_context (context);
2321 cp_diagnostic_starter (diagnostic_context *context,
2322 diagnostic_info *diagnostic)
2324 diagnostic_report_current_module (context);
2325 cp_print_error_function (context, diagnostic);
2326 maybe_print_instantiation_context (context);
2327 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2331 cp_diagnostic_finalizer (diagnostic_context *context,
2332 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2334 pp_base_destroy_prefix (context->printer);
2337 /* Print current function onto BUFFER, in the process of reporting
2338 a diagnostic message. Called from cp_diagnostic_starter. */
2340 cp_print_error_function (diagnostic_context *context,
2341 diagnostic_info *diagnostic)
2343 if (diagnostic_last_function_changed (context))
2345 const char *old_prefix = context->printer->prefix;
2346 const char *file = LOCATION_FILE (diagnostic->location);
2347 char *new_prefix = file ? file_name_as_prefix (file) : NULL;
2349 pp_base_set_prefix (context->printer, new_prefix);
2351 if (current_function_decl == NULL)
2352 pp_base_string (context->printer, "At global scope:");
2354 pp_printf (context->printer, "In %s %qs:",
2355 function_category (current_function_decl),
2356 cxx_printable_name (current_function_decl, 2));
2357 pp_base_newline (context->printer);
2359 diagnostic_set_last_function (context);
2360 pp_base_destroy_prefix (context->printer);
2361 context->printer->prefix = old_prefix;
2365 /* Returns a description of FUNCTION using standard terminology. */
2367 function_category (tree fn)
2369 if (DECL_FUNCTION_MEMBER_P (fn))
2371 if (DECL_STATIC_FUNCTION_P (fn))
2372 return "static member function";
2373 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2374 return "copy constructor";
2375 else if (DECL_CONSTRUCTOR_P (fn))
2376 return "constructor";
2377 else if (DECL_DESTRUCTOR_P (fn))
2378 return "destructor";
2380 return "member function";
2386 /* Report the full context of a current template instantiation,
2389 print_instantiation_full_context (diagnostic_context *context)
2391 tree p = current_instantiation ();
2392 location_t location = input_location;
2396 if (current_function_decl != TINST_DECL (p)
2397 && current_function_decl != NULL_TREE)
2398 /* We can get here during the processing of some synthesized
2399 method. Then, TINST_DECL (p) will be the function that's causing
2404 if (current_function_decl == TINST_DECL (p))
2405 /* Avoid redundancy with the "In function" line. */;
2407 pp_verbatim (context->printer,
2408 "%s: In instantiation of %qs:\n",
2409 LOCATION_FILE (location),
2410 decl_as_string (TINST_DECL (p),
2411 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2413 location = TINST_LOCATION (p);
2418 print_instantiation_partial_context (context, p, location);
2421 /* Same as above but less verbose. */
2423 print_instantiation_partial_context (diagnostic_context *context,
2424 tree t, location_t loc)
2426 expanded_location xloc;
2427 for (; ; t = TREE_CHAIN (t))
2429 xloc = expand_location (loc);
2432 pp_verbatim (context->printer, "%s:%d: instantiated from %qs\n",
2433 xloc.file, xloc.line,
2434 decl_as_string (TINST_DECL (t),
2435 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2436 loc = TINST_LOCATION (t);
2438 pp_verbatim (context->printer, "%s:%d: instantiated from here",
2439 xloc.file, xloc.line);
2440 pp_base_newline (context->printer);
2443 /* Called from cp_thing to print the template context for an error. */
2445 maybe_print_instantiation_context (diagnostic_context *context)
2447 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2450 record_last_problematic_instantiation ();
2451 print_instantiation_full_context (context);
2454 /* Report the bare minimum context of a template instantiation. */
2456 print_instantiation_context (void)
2458 print_instantiation_partial_context
2459 (global_dc, current_instantiation (), input_location);
2460 diagnostic_flush_buffer (global_dc);
2463 /* Called from output_format -- during diagnostic message processing --
2464 to handle C++ specific format specifier with the following meanings:
2465 %A function argument-list.
2469 %F function declaration.
2470 %L language as used in extern "lang".
2472 %P function parameter whose position is indicated by an integer.
2473 %Q assignment operator.
2477 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2478 int precision, bool wide, bool set_locus, bool verbose)
2482 #define next_tree (t = va_arg (*text->args_ptr, tree))
2483 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2484 #define next_lang va_arg (*text->args_ptr, enum languages)
2485 #define next_int va_arg (*text->args_ptr, int)
2487 if (precision != 0 || wide)
2490 if (text->locus == NULL)
2495 case 'A': result = args_to_string (next_tree, verbose); break;
2496 case 'C': result = code_to_string (next_tcode); break;
2499 tree temp = next_tree;
2501 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
2503 temp = DECL_DEBUG_EXPR (temp);
2506 result = expr_to_string (temp);
2510 result = decl_to_string (temp, verbose);
2513 case 'E': result = expr_to_string (next_tree); break;
2514 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2515 case 'L': result = language_to_string (next_lang); break;
2516 case 'O': result = op_to_string (next_tcode); break;
2517 case 'P': result = parm_to_string (next_int); break;
2518 case 'Q': result = assop_to_string (next_tcode); break;
2519 case 'T': result = type_to_string (next_tree, verbose); break;
2520 case 'V': result = cv_to_string (next_tree, verbose); break;
2526 pp_base_string (pp, result);
2527 if (set_locus && t != NULL)
2528 *text->locus = location_of (t);
2536 /* Callback from cpp_error for PFILE to print diagnostics arising from
2537 interpreting strings. The diagnostic is of type LEVEL; MSG is the
2538 translated message and AP the arguments. */
2541 cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
2542 const char *msg, va_list *ap)
2544 diagnostic_info diagnostic;
2545 diagnostic_t dlevel;
2548 case CPP_DL_WARNING:
2549 case CPP_DL_WARNING_SYSHDR:
2550 dlevel = DK_WARNING;
2552 case CPP_DL_PEDWARN:
2553 dlevel = pedantic_error_kind ();
2564 diagnostic_set_info_translated (&diagnostic, msg, ap,
2565 input_location, dlevel);
2566 report_diagnostic (&diagnostic);
2569 /* Warn about the use of variadic templates when appropriate. */
2571 maybe_warn_variadic_templates (void)
2573 if ((cxx_dialect == cxx98) && !in_system_header)
2574 /* We really want to suppress this warning in system headers,
2575 because libstdc++ uses variadic templates even when we aren't
2577 pedwarn ("ISO C++ does not include variadic templates");