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);
966 pp_unsupported_tree (cxx_pp, t);
967 /* Fall through to error. */
970 pp_identifier (cxx_pp, "<declaration error>");
975 /* Dump a template declaration T under control of FLAGS. This means the
976 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
979 dump_template_decl (tree t, int flags)
981 tree orig_parms = DECL_TEMPLATE_PARMS (t);
985 if (flags & TFF_TEMPLATE_HEADER)
987 for (parms = orig_parms = nreverse (orig_parms);
989 parms = TREE_CHAIN (parms))
991 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
992 int len = TREE_VEC_LENGTH (inner_parms);
994 pp_cxx_identifier (cxx_pp, "template");
995 pp_cxx_begin_template_argument_list (cxx_pp);
997 /* If we've shown the template prefix, we'd better show the
998 parameters' and decl's type too. */
999 flags |= TFF_DECL_SPECIFIERS;
1001 for (i = 0; i < len; i++)
1004 pp_separate_with_comma (cxx_pp);
1005 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
1007 pp_cxx_end_template_argument_list (cxx_pp);
1008 pp_cxx_whitespace (cxx_pp);
1010 nreverse(orig_parms);
1012 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1013 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1014 pp_cxx_identifier (cxx_pp, "class");
1017 if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
1018 dump_type (TREE_TYPE (t),
1019 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1020 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1021 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
1022 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1025 gcc_assert (TREE_TYPE (t));
1026 switch (NEXT_CODE (t))
1030 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1033 /* This case can occur with some invalid code. */
1034 dump_type (TREE_TYPE (t),
1035 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1036 | (flags & TFF_DECL_SPECIFIERS
1037 ? TFF_CLASS_KEY_OR_ENUM : 0));
1042 /* Pretty print a function decl. There are several ways we want to print a
1043 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1044 As error can only apply the '#' flag once to give 0 and 1 for V, there
1045 is %D which doesn't print the throw specs, and %F which does. */
1048 dump_function_decl (tree t, int flags)
1052 tree cname = NULL_TREE;
1053 tree template_args = NULL_TREE;
1054 tree template_parms = NULL_TREE;
1055 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1056 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1058 flags &= ~TFF_UNQUALIFIED_NAME;
1059 if (TREE_CODE (t) == TEMPLATE_DECL)
1060 t = DECL_TEMPLATE_RESULT (t);
1062 /* Pretty print template instantiations only. */
1063 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t))
1067 template_args = DECL_TI_ARGS (t);
1068 tmpl = most_general_template (t);
1069 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1071 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1076 fntype = TREE_TYPE (t);
1077 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1079 if (DECL_CLASS_SCOPE_P (t))
1080 cname = DECL_CONTEXT (t);
1081 /* This is for partially instantiated template methods. */
1082 else if (TREE_CODE (fntype) == METHOD_TYPE)
1083 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1085 if (!(flags & TFF_DECL_SPECIFIERS))
1087 else if (DECL_STATIC_FUNCTION_P (t))
1088 pp_cxx_identifier (cxx_pp, "static");
1089 else if (DECL_VIRTUAL_P (t))
1090 pp_cxx_identifier (cxx_pp, "virtual");
1092 /* Print the return type? */
1094 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1095 && !DECL_DESTRUCTOR_P (t);
1097 dump_type_prefix (TREE_TYPE (fntype), flags);
1099 /* Print the function name. */
1100 if (!do_outer_scope)
1104 dump_type (cname, flags);
1105 pp_cxx_colon_colon (cxx_pp);
1108 dump_scope (CP_DECL_CONTEXT (t), flags);
1110 dump_function_name (t, flags);
1112 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1114 dump_parameters (parmtypes, flags);
1116 if (TREE_CODE (fntype) == METHOD_TYPE)
1118 pp_base (cxx_pp)->padding = pp_before;
1119 pp_cxx_cv_qualifier_seq
1120 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1123 if (flags & TFF_EXCEPTION_SPECIFICATION)
1125 pp_base (cxx_pp)->padding = pp_before;
1126 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
1130 dump_type_suffix (TREE_TYPE (fntype), flags);
1133 /* If T is a template instantiation, dump the parameter binding. */
1134 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1136 pp_cxx_whitespace (cxx_pp);
1137 pp_cxx_left_bracket (cxx_pp);
1138 pp_cxx_identifier (cxx_pp, "with");
1139 pp_cxx_whitespace (cxx_pp);
1140 dump_template_bindings (template_parms, template_args);
1141 pp_cxx_right_bracket (cxx_pp);
1145 /* Print a parameter list. If this is for a member function, the
1146 member object ptr (and any other hidden args) should have
1147 already been removed. */
1150 dump_parameters (tree parmtypes, int flags)
1153 pp_cxx_left_paren (cxx_pp);
1155 for (first = 1; parmtypes != void_list_node;
1156 parmtypes = TREE_CHAIN (parmtypes))
1159 pp_separate_with_comma (cxx_pp);
1163 pp_cxx_identifier (cxx_pp, "...");
1166 if (ARGUMENT_PACK_P (TREE_VALUE (parmtypes)))
1168 tree types = ARGUMENT_PACK_ARGS (TREE_VALUE (parmtypes));
1169 int i, len = TREE_VEC_LENGTH (types);
1171 for (i = 0; i < len; ++i)
1174 pp_separate_with_comma (cxx_pp);
1177 dump_type (TREE_VEC_ELT (types, i), flags);
1181 dump_type (TREE_VALUE (parmtypes), flags);
1183 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1185 pp_cxx_whitespace (cxx_pp);
1187 pp_cxx_whitespace (cxx_pp);
1188 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1192 pp_cxx_right_paren (cxx_pp);
1195 /* Print an exception specification. T is the exception specification. */
1198 dump_exception_spec (tree t, int flags)
1202 pp_cxx_identifier (cxx_pp, "throw");
1203 pp_cxx_whitespace (cxx_pp);
1204 pp_cxx_left_paren (cxx_pp);
1205 if (TREE_VALUE (t) != NULL_TREE)
1208 dump_type (TREE_VALUE (t), flags);
1212 pp_separate_with_comma (cxx_pp);
1214 pp_cxx_right_paren (cxx_pp);
1218 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1219 and destructors properly. */
1222 dump_function_name (tree t, int flags)
1224 tree name = DECL_NAME (t);
1226 /* We can get here with a decl that was synthesized by language-
1227 independent machinery (e.g. coverage.c) in which case it won't
1228 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1229 will crash. In this case it is safe just to print out the
1231 if (!DECL_LANG_SPECIFIC (t))
1233 pp_cxx_tree_identifier (cxx_pp, name);
1237 if (TREE_CODE (t) == TEMPLATE_DECL)
1238 t = DECL_TEMPLATE_RESULT (t);
1240 /* Don't let the user see __comp_ctor et al. */
1241 if (DECL_CONSTRUCTOR_P (t)
1242 || DECL_DESTRUCTOR_P (t))
1243 name = constructor_name (DECL_CONTEXT (t));
1245 if (DECL_DESTRUCTOR_P (t))
1247 pp_cxx_complement (cxx_pp);
1248 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1250 else if (DECL_CONV_FN_P (t))
1252 /* This cannot use the hack that the operator's return
1253 type is stashed off of its name because it may be
1254 used for error reporting. In the case of conflicting
1255 declarations, both will have the same name, yet
1256 the types will be different, hence the TREE_TYPE field
1257 of the first name will be clobbered by the second. */
1258 pp_cxx_identifier (cxx_pp, "operator");
1259 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1261 else if (IDENTIFIER_OPNAME_P (name))
1262 pp_cxx_tree_identifier (cxx_pp, name);
1264 dump_decl (name, flags);
1266 if (DECL_TEMPLATE_INFO (t)
1267 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1268 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1269 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1270 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1273 /* Dump the template parameters from the template info INFO under control of
1274 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1275 specialization (partial or complete). For partial specializations we show
1276 the specialized parameter values. For a primary template we show no
1280 dump_template_parms (tree info, int primary, int flags)
1282 tree args = info ? TI_ARGS (info) : NULL_TREE;
1284 if (primary && flags & TFF_TEMPLATE_NAME)
1286 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1287 pp_cxx_begin_template_argument_list (cxx_pp);
1289 /* Be careful only to print things when we have them, so as not
1290 to crash producing error messages. */
1291 if (args && !primary)
1295 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
1296 args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
1298 len = TREE_VEC_LENGTH (args);
1300 for (ix = 0; ix != len; ix++)
1302 tree arg = TREE_VEC_ELT (args, ix);
1304 /* Only print a comma if we know there is an argument coming. In
1305 the case of an empty template argument pack, no actual
1306 argument will be printed. */
1308 && (!ARGUMENT_PACK_P (arg)
1309 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1310 pp_separate_with_comma (cxx_pp);
1313 pp_identifier (cxx_pp, "<template parameter error>");
1315 dump_template_argument (arg, flags);
1320 tree tpl = TI_TEMPLATE (info);
1321 tree parms = DECL_TEMPLATE_PARMS (tpl);
1324 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1325 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1327 for (ix = 0; ix != len; ix++)
1331 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1333 pp_identifier (cxx_pp, "<template parameter error>");
1337 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1340 pp_separate_with_comma (cxx_pp);
1342 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1345 pp_cxx_end_template_argument_list (cxx_pp);
1348 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1349 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1352 dump_call_expr_args (tree t, int flags, bool skipfirst)
1355 call_expr_arg_iterator iter;
1357 pp_cxx_left_paren (cxx_pp);
1358 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1364 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1365 if (more_call_expr_args_p (&iter))
1366 pp_separate_with_comma (cxx_pp);
1369 pp_cxx_right_paren (cxx_pp);
1372 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1373 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1377 dump_aggr_init_expr_args (tree t, int flags, bool skipfirst)
1380 aggr_init_expr_arg_iterator iter;
1382 pp_cxx_left_paren (cxx_pp);
1383 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1389 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1390 if (more_aggr_init_expr_args_p (&iter))
1391 pp_separate_with_comma (cxx_pp);
1394 pp_cxx_right_paren (cxx_pp);
1397 /* Print out a list of initializers (subr of dump_expr). */
1400 dump_expr_list (tree l, int flags)
1404 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1407 pp_separate_with_comma (cxx_pp);
1411 /* Print out a vector of initializers (subr of dump_expr). */
1414 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1416 unsigned HOST_WIDE_INT idx;
1419 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1421 dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1422 if (idx != VEC_length (constructor_elt, v) - 1)
1423 pp_separate_with_comma (cxx_pp);
1428 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1429 function. Resolve it to a close relative -- in the sense of static
1430 type -- variant being overridden. That is close to what was written in
1431 the source code. Subroutine of dump_expr. */
1434 resolve_virtual_fun_from_obj_type_ref (tree ref)
1436 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1437 int index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1438 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1440 fun = TREE_CHAIN (fun);
1445 /* Print out an expression E under control of FLAGS. */
1448 dump_expr (tree t, int flags)
1453 switch (TREE_CODE (t))
1461 case NAMESPACE_DECL:
1464 case IDENTIFIER_NODE:
1465 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1471 pp_constant (cxx_pp, t);
1475 pp_cxx_identifier (cxx_pp, "throw");
1476 dump_expr (TREE_OPERAND (t, 0), flags);
1480 pp_ampersand (cxx_pp);
1481 dump_type (PTRMEM_CST_CLASS (t), flags);
1482 pp_cxx_colon_colon (cxx_pp);
1483 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1487 pp_cxx_left_paren (cxx_pp);
1488 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1489 pp_separate_with_comma (cxx_pp);
1490 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1491 pp_cxx_right_paren (cxx_pp);
1495 pp_cxx_left_paren (cxx_pp);
1496 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1497 pp_string (cxx_pp, " ? ");
1498 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1499 pp_string (cxx_pp, " : ");
1500 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1501 pp_cxx_right_paren (cxx_pp);
1505 if (TREE_HAS_CONSTRUCTOR (t))
1507 pp_cxx_identifier (cxx_pp, "new");
1508 pp_cxx_whitespace (cxx_pp);
1509 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1512 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1515 case AGGR_INIT_EXPR:
1517 tree fn = NULL_TREE;
1519 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
1520 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
1522 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1524 if (DECL_CONSTRUCTOR_P (fn))
1525 dump_type (DECL_CONTEXT (fn), flags);
1530 dump_expr (AGGR_INIT_EXPR_FN (t), 0);
1532 dump_aggr_init_expr_args (t, flags, true);
1537 tree fn = CALL_EXPR_FN (t);
1538 bool skipfirst = false;
1540 if (TREE_CODE (fn) == ADDR_EXPR)
1541 fn = TREE_OPERAND (fn, 0);
1543 /* Nobody is interested in seeing the guts of vcalls. */
1544 if (TREE_CODE (fn) == OBJ_TYPE_REF)
1545 fn = resolve_virtual_fun_from_obj_type_ref (fn);
1547 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1549 tree ob = CALL_EXPR_ARG (t, 0);
1550 if (TREE_CODE (ob) == ADDR_EXPR)
1552 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1555 else if (TREE_CODE (ob) != PARM_DECL
1556 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1558 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1563 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1564 dump_call_expr_args (t, flags, skipfirst);
1570 tree type = TREE_OPERAND (t, 1);
1571 tree init = TREE_OPERAND (t, 2);
1572 if (NEW_EXPR_USE_GLOBAL (t))
1573 pp_cxx_colon_colon (cxx_pp);
1574 pp_cxx_identifier (cxx_pp, "new");
1575 if (TREE_OPERAND (t, 0))
1577 pp_cxx_left_paren (cxx_pp);
1578 dump_expr_list (TREE_OPERAND (t, 0), flags);
1579 pp_cxx_right_paren (cxx_pp);
1580 pp_cxx_whitespace (cxx_pp);
1582 if (TREE_CODE (type) == ARRAY_REF)
1583 type = build_cplus_array_type
1584 (TREE_OPERAND (type, 0),
1585 build_index_type (fold_build2 (MINUS_EXPR, integer_type_node,
1586 TREE_OPERAND (type, 1),
1587 integer_one_node)));
1588 dump_type (type, flags);
1591 pp_cxx_left_paren (cxx_pp);
1592 if (TREE_CODE (init) == TREE_LIST)
1593 dump_expr_list (init, flags);
1594 else if (init == void_zero_node)
1595 /* This representation indicates an empty initializer,
1596 e.g.: "new int()". */
1599 dump_expr (init, flags);
1600 pp_cxx_right_paren (cxx_pp);
1606 /* Note that this only works for G++ target exprs. If somebody
1607 builds a general TARGET_EXPR, there's no way to represent that
1608 it initializes anything other that the parameter slot for the
1609 default argument. Note we may have cleared out the first
1610 operand in expand_expr, so don't go killing ourselves. */
1611 if (TREE_OPERAND (t, 1))
1612 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1620 case TRUNC_DIV_EXPR:
1621 case TRUNC_MOD_EXPR:
1629 case TRUTH_ANDIF_EXPR:
1630 case TRUTH_ORIF_EXPR:
1637 case EXACT_DIV_EXPR:
1638 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1642 case FLOOR_DIV_EXPR:
1643 case ROUND_DIV_EXPR:
1645 dump_binary_op ("/", t, flags);
1649 case FLOOR_MOD_EXPR:
1650 case ROUND_MOD_EXPR:
1651 dump_binary_op ("%", t, flags);
1656 tree ob = TREE_OPERAND (t, 0);
1657 if (TREE_CODE (ob) == INDIRECT_REF)
1659 ob = TREE_OPERAND (ob, 0);
1660 if (TREE_CODE (ob) != PARM_DECL
1662 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1664 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1665 pp_cxx_arrow (cxx_pp);
1670 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1671 pp_cxx_dot (cxx_pp);
1673 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1678 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1679 pp_cxx_left_bracket (cxx_pp);
1680 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1681 pp_cxx_right_bracket (cxx_pp);
1684 case UNARY_PLUS_EXPR:
1685 dump_unary_op ("+", t, flags);
1689 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1690 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1691 /* An ADDR_EXPR can have reference type. In that case, we
1692 shouldn't print the `&' doing so indicates to the user
1693 that the expression has pointer type. */
1695 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1696 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1697 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1698 dump_unary_op ("&&", t, flags);
1700 dump_unary_op ("&", t, flags);
1704 if (TREE_HAS_CONSTRUCTOR (t))
1706 t = TREE_OPERAND (t, 0);
1707 gcc_assert (TREE_CODE (t) == CALL_EXPR);
1708 dump_expr (CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
1709 dump_call_expr_args (t, flags, true);
1713 if (TREE_OPERAND (t,0) != NULL_TREE
1714 && TREE_TYPE (TREE_OPERAND (t, 0))
1715 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1716 dump_expr (TREE_OPERAND (t, 0), flags);
1718 dump_unary_op ("*", t, flags);
1724 case TRUTH_NOT_EXPR:
1725 case PREDECREMENT_EXPR:
1726 case PREINCREMENT_EXPR:
1727 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1730 case POSTDECREMENT_EXPR:
1731 case POSTINCREMENT_EXPR:
1732 pp_cxx_left_paren (cxx_pp);
1733 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1734 pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1735 pp_cxx_right_paren (cxx_pp);
1738 case NON_LVALUE_EXPR:
1739 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1740 should be another level of INDIRECT_REF so that I don't have to do
1742 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1744 tree next = TREE_TYPE (TREE_TYPE (t));
1746 while (TREE_CODE (next) == POINTER_TYPE)
1747 next = TREE_TYPE (next);
1749 if (TREE_CODE (next) == FUNCTION_TYPE)
1751 if (flags & TFF_EXPR_IN_PARENS)
1752 pp_cxx_left_paren (cxx_pp);
1753 pp_cxx_star (cxx_pp);
1754 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1755 if (flags & TFF_EXPR_IN_PARENS)
1756 pp_cxx_right_paren (cxx_pp);
1759 /* Else fall through. */
1761 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1767 tree op = TREE_OPERAND (t, 0);
1769 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1771 /* It is a cast, but we cannot tell whether it is a
1772 reinterpret or static cast. Use the C style notation. */
1773 if (flags & TFF_EXPR_IN_PARENS)
1774 pp_cxx_left_paren (cxx_pp);
1775 pp_cxx_left_paren (cxx_pp);
1776 dump_type (TREE_TYPE (t), flags);
1777 pp_cxx_right_paren (cxx_pp);
1778 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1779 if (flags & TFF_EXPR_IN_PARENS)
1780 pp_cxx_right_paren (cxx_pp);
1783 dump_expr (op, flags);
1788 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1790 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1792 if (integer_zerop (idx))
1794 /* A NULL pointer-to-member constant. */
1795 pp_cxx_left_paren (cxx_pp);
1796 pp_cxx_left_paren (cxx_pp);
1797 dump_type (TREE_TYPE (t), flags);
1798 pp_cxx_right_paren (cxx_pp);
1799 pp_character (cxx_pp, '0');
1800 pp_cxx_right_paren (cxx_pp);
1803 else if (host_integerp (idx, 0))
1806 unsigned HOST_WIDE_INT n;
1808 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1809 t = TYPE_METHOD_BASETYPE (t);
1810 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1812 n = tree_low_cst (idx, 0);
1814 /* Map vtable index back one, to allow for the null pointer to
1818 while (n > 0 && virtuals)
1821 virtuals = TREE_CHAIN (virtuals);
1825 dump_expr (BV_FN (virtuals),
1826 flags | TFF_EXPR_IN_PARENS);
1831 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
1833 dump_type (TREE_TYPE (t), 0);
1834 pp_cxx_left_paren (cxx_pp);
1835 pp_cxx_right_paren (cxx_pp);
1839 pp_cxx_left_brace (cxx_pp);
1840 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
1841 pp_cxx_right_brace (cxx_pp);
1848 tree ob = TREE_OPERAND (t, 0);
1849 if (is_dummy_object (ob))
1851 t = TREE_OPERAND (t, 1);
1852 if (TREE_CODE (t) == FUNCTION_DECL)
1854 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1855 else if (BASELINK_P (t))
1856 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1857 flags | TFF_EXPR_IN_PARENS);
1859 dump_decl (t, flags);
1863 if (TREE_CODE (ob) == INDIRECT_REF)
1865 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1866 pp_cxx_arrow (cxx_pp);
1867 pp_cxx_star (cxx_pp);
1871 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1872 pp_cxx_dot (cxx_pp);
1873 pp_cxx_star (cxx_pp);
1875 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1880 case TEMPLATE_PARM_INDEX:
1881 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1885 pp_expression (cxx_pp, t);
1889 if (TREE_OPERAND (t, 0) == NULL_TREE
1890 || TREE_CHAIN (TREE_OPERAND (t, 0)))
1892 dump_type (TREE_TYPE (t), flags);
1893 pp_cxx_left_paren (cxx_pp);
1894 dump_expr_list (TREE_OPERAND (t, 0), flags);
1895 pp_cxx_right_paren (cxx_pp);
1899 pp_cxx_left_paren (cxx_pp);
1900 dump_type (TREE_TYPE (t), flags);
1901 pp_cxx_right_paren (cxx_pp);
1902 pp_cxx_left_paren (cxx_pp);
1903 dump_expr_list (TREE_OPERAND (t, 0), flags);
1904 pp_cxx_right_paren (cxx_pp);
1908 case STATIC_CAST_EXPR:
1909 pp_cxx_identifier (cxx_pp, "static_cast");
1911 case REINTERPRET_CAST_EXPR:
1912 pp_cxx_identifier (cxx_pp, "reinterpret_cast");
1914 case CONST_CAST_EXPR:
1915 pp_cxx_identifier (cxx_pp, "const_cast");
1917 case DYNAMIC_CAST_EXPR:
1918 pp_cxx_identifier (cxx_pp, "dynamic_cast");
1920 pp_cxx_begin_template_argument_list (cxx_pp);
1921 dump_type (TREE_TYPE (t), flags);
1922 pp_cxx_end_template_argument_list (cxx_pp);
1923 pp_cxx_left_paren (cxx_pp);
1924 dump_expr (TREE_OPERAND (t, 0), flags);
1925 pp_cxx_right_paren (cxx_pp);
1929 dump_expr (TREE_OPERAND (t, 0), flags);
1930 pp_cxx_arrow (cxx_pp);
1935 if (TREE_CODE (t) == SIZEOF_EXPR)
1936 pp_cxx_identifier (cxx_pp, "sizeof");
1939 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
1940 pp_cxx_identifier (cxx_pp, "__alignof__");
1942 pp_cxx_whitespace (cxx_pp);
1943 pp_cxx_left_paren (cxx_pp);
1944 if (TYPE_P (TREE_OPERAND (t, 0)))
1945 dump_type (TREE_OPERAND (t, 0), flags);
1947 dump_expr (TREE_OPERAND (t, 0), flags);
1948 pp_cxx_right_paren (cxx_pp);
1953 pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
1954 pp_cxx_whitespace (cxx_pp);
1955 dump_expr (TREE_OPERAND (t, 0), flags);
1959 pp_identifier (cxx_pp, "<unparsed>");
1962 case TRY_CATCH_EXPR:
1963 case WITH_CLEANUP_EXPR:
1964 case CLEANUP_POINT_EXPR:
1965 dump_expr (TREE_OPERAND (t, 0), flags);
1968 case PSEUDO_DTOR_EXPR:
1969 dump_expr (TREE_OPERAND (t, 2), flags);
1970 pp_cxx_dot (cxx_pp);
1971 dump_type (TREE_OPERAND (t, 0), flags);
1972 pp_cxx_colon_colon (cxx_pp);
1973 pp_cxx_complement (cxx_pp);
1974 dump_type (TREE_OPERAND (t, 1), flags);
1977 case TEMPLATE_ID_EXPR:
1978 dump_decl (t, flags);
1983 case STATEMENT_LIST:
1984 /* We don't yet have a way of dumping statements in a
1985 human-readable format. */
1986 pp_string (cxx_pp, "({...})");
1990 pp_string (cxx_pp, "while (1) { ");
1991 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1992 pp_cxx_right_brace (cxx_pp);
1996 pp_string (cxx_pp, "if (");
1997 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1998 pp_string (cxx_pp, ") break; ");
2002 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
2005 case EMPTY_CLASS_EXPR:
2006 dump_type (TREE_TYPE (t), flags);
2007 pp_cxx_left_paren (cxx_pp);
2008 pp_cxx_right_paren (cxx_pp);
2011 case NON_DEPENDENT_EXPR:
2012 dump_expr (TREE_OPERAND (t, 0), flags);
2015 case EXPR_PACK_EXPANSION:
2016 dump_expr (PACK_EXPANSION_PATTERN (t), flags);
2017 pp_cxx_identifier (cxx_pp, "...");
2029 pp_type_specifier_seq (cxx_pp, t);
2033 /* We get here when we want to print a dependent type as an
2034 id-expression, without any disambiguator decoration. */
2035 pp_id_expression (cxx_pp, t);
2038 /* This list is incomplete, but should suffice for now.
2039 It is very important that `sorry' does not call
2040 `report_error_function'. That could cause an infinite loop. */
2042 pp_unsupported_tree (cxx_pp, t);
2043 /* fall through to ERROR_MARK... */
2045 pp_identifier (cxx_pp, "<expression error>");
2051 dump_binary_op (const char *opstring, tree t, int flags)
2053 pp_cxx_left_paren (cxx_pp);
2054 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2055 pp_cxx_whitespace (cxx_pp);
2057 pp_cxx_identifier (cxx_pp, opstring);
2059 pp_identifier (cxx_pp, "<unknown operator>");
2060 pp_cxx_whitespace (cxx_pp);
2061 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2062 pp_cxx_right_paren (cxx_pp);
2066 dump_unary_op (const char *opstring, tree t, int flags)
2068 if (flags & TFF_EXPR_IN_PARENS)
2069 pp_cxx_left_paren (cxx_pp);
2070 pp_cxx_identifier (cxx_pp, opstring);
2071 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2072 if (flags & TFF_EXPR_IN_PARENS)
2073 pp_cxx_right_paren (cxx_pp);
2077 reinit_cxx_pp (void)
2079 pp_clear_output_area (cxx_pp);
2080 pp_base (cxx_pp)->padding = pp_none;
2081 pp_indentation (cxx_pp) = 0;
2082 pp_needs_newline (cxx_pp) = false;
2083 cxx_pp->enclosing_scope = 0;
2087 /* Exported interface to stringifying types, exprs and decls under TFF_*
2091 type_as_string (tree typ, int flags)
2094 dump_type (typ, flags);
2095 return pp_formatted_text (cxx_pp);
2099 expr_as_string (tree decl, int flags)
2102 dump_expr (decl, flags);
2103 return pp_formatted_text (cxx_pp);
2107 decl_as_string (tree decl, int flags)
2110 dump_decl (decl, flags);
2111 return pp_formatted_text (cxx_pp);
2114 /* Generate the three forms of printable names for cxx_printable_name. */
2117 lang_decl_name (tree decl, int v)
2120 return decl_as_string (decl, TFF_DECL_SPECIFIERS);
2123 if (v == 1 && DECL_CLASS_SCOPE_P (decl))
2125 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2126 pp_cxx_colon_colon (cxx_pp);
2129 if (TREE_CODE (decl) == FUNCTION_DECL)
2130 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2132 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2134 return pp_formatted_text (cxx_pp);
2137 /* Return the location of a tree passed to %+ formats. */
2140 location_of (tree t)
2142 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2143 t = DECL_CONTEXT (t);
2144 else if (TYPE_P (t))
2145 t = TYPE_MAIN_DECL (t);
2146 else if (TREE_CODE (t) == OVERLOAD)
2147 t = OVL_FUNCTION (t);
2149 return DECL_SOURCE_LOCATION (t);
2152 /* Now the interfaces from error et al to dump_type et al. Each takes an
2153 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2157 decl_to_string (tree decl, int verbose)
2161 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2162 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2163 flags = TFF_CLASS_KEY_OR_ENUM;
2165 flags |= TFF_DECL_SPECIFIERS;
2166 else if (TREE_CODE (decl) == FUNCTION_DECL)
2167 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2168 flags |= TFF_TEMPLATE_HEADER;
2171 dump_decl (decl, flags);
2172 return pp_formatted_text (cxx_pp);
2176 expr_to_string (tree decl)
2179 dump_expr (decl, 0);
2180 return pp_formatted_text (cxx_pp);
2184 fndecl_to_string (tree fndecl, int verbose)
2188 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2189 | TFF_TEMPLATE_HEADER;
2191 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2193 dump_decl (fndecl, flags);
2194 return pp_formatted_text (cxx_pp);
2199 code_to_string (enum tree_code c)
2201 return tree_code_name [c];
2205 language_to_string (enum languages c)
2212 case lang_cplusplus:
2224 /* Return the proper printed version of a parameter to a C++ function. */
2227 parm_to_string (int p)
2231 pp_string (cxx_pp, "'this'");
2233 pp_decimal_int (cxx_pp, p + 1);
2234 return pp_formatted_text (cxx_pp);
2238 op_to_string (enum tree_code p)
2240 tree id = operator_name_info[(int) p].identifier;
2241 return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2245 type_to_string (tree typ, int verbose)
2249 flags |= TFF_CLASS_KEY_OR_ENUM;
2250 flags |= TFF_TEMPLATE_HEADER;
2253 dump_type (typ, flags);
2254 return pp_formatted_text (cxx_pp);
2258 assop_to_string (enum tree_code p)
2260 tree id = assignment_operator_name_info[(int) p].identifier;
2261 return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2265 args_to_string (tree p, int verbose)
2269 flags |= TFF_CLASS_KEY_OR_ENUM;
2274 if (TYPE_P (TREE_VALUE (p)))
2275 return type_as_string (p, flags);
2278 for (; p; p = TREE_CHAIN (p))
2280 if (TREE_VALUE (p) == null_node)
2281 pp_cxx_identifier (cxx_pp, "NULL");
2283 dump_type (error_type (TREE_VALUE (p)), flags);
2285 pp_separate_with_comma (cxx_pp);
2287 return pp_formatted_text (cxx_pp);
2291 cv_to_string (tree p, int v)
2294 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2295 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2296 return pp_formatted_text (cxx_pp);
2299 /* Langhook for print_error_function. */
2301 cxx_print_error_function (diagnostic_context *context, const char *file)
2303 lhd_print_error_function (context, file);
2304 pp_base_set_prefix (context->printer, file);
2305 maybe_print_instantiation_context (context);
2309 cp_diagnostic_starter (diagnostic_context *context,
2310 diagnostic_info *diagnostic)
2312 diagnostic_report_current_module (context);
2313 cp_print_error_function (context, diagnostic);
2314 maybe_print_instantiation_context (context);
2315 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2319 cp_diagnostic_finalizer (diagnostic_context *context,
2320 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2322 pp_base_destroy_prefix (context->printer);
2325 /* Print current function onto BUFFER, in the process of reporting
2326 a diagnostic message. Called from cp_diagnostic_starter. */
2328 cp_print_error_function (diagnostic_context *context,
2329 diagnostic_info *diagnostic)
2331 if (diagnostic_last_function_changed (context))
2333 const char *old_prefix = context->printer->prefix;
2334 const char *file = LOCATION_FILE (diagnostic->location);
2335 char *new_prefix = file ? file_name_as_prefix (file) : NULL;
2337 pp_base_set_prefix (context->printer, new_prefix);
2339 if (current_function_decl == NULL)
2340 pp_base_string (context->printer, "At global scope:");
2342 pp_printf (context->printer, "In %s %qs:",
2343 function_category (current_function_decl),
2344 cxx_printable_name (current_function_decl, 2));
2345 pp_base_newline (context->printer);
2347 diagnostic_set_last_function (context);
2348 pp_base_destroy_prefix (context->printer);
2349 context->printer->prefix = old_prefix;
2353 /* Returns a description of FUNCTION using standard terminology. */
2355 function_category (tree fn)
2357 if (DECL_FUNCTION_MEMBER_P (fn))
2359 if (DECL_STATIC_FUNCTION_P (fn))
2360 return "static member function";
2361 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2362 return "copy constructor";
2363 else if (DECL_CONSTRUCTOR_P (fn))
2364 return "constructor";
2365 else if (DECL_DESTRUCTOR_P (fn))
2366 return "destructor";
2368 return "member function";
2374 /* Report the full context of a current template instantiation,
2377 print_instantiation_full_context (diagnostic_context *context)
2379 tree p = current_instantiation ();
2380 location_t location = input_location;
2384 if (current_function_decl != TINST_DECL (p)
2385 && current_function_decl != NULL_TREE)
2386 /* We can get here during the processing of some synthesized
2387 method. Then, TINST_DECL (p) will be the function that's causing
2392 if (current_function_decl == TINST_DECL (p))
2393 /* Avoid redundancy with the "In function" line. */;
2395 pp_verbatim (context->printer,
2396 "%s: In instantiation of %qs:\n",
2397 LOCATION_FILE (location),
2398 decl_as_string (TINST_DECL (p),
2399 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2401 location = TINST_LOCATION (p);
2406 print_instantiation_partial_context (context, p, location);
2409 /* Same as above but less verbose. */
2411 print_instantiation_partial_context (diagnostic_context *context,
2412 tree t, location_t loc)
2414 expanded_location xloc;
2415 for (; ; t = TREE_CHAIN (t))
2417 xloc = expand_location (loc);
2420 pp_verbatim (context->printer, "%s:%d: instantiated from %qs\n",
2421 xloc.file, xloc.line,
2422 decl_as_string (TINST_DECL (t),
2423 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2424 loc = TINST_LOCATION (t);
2426 pp_verbatim (context->printer, "%s:%d: instantiated from here",
2427 xloc.file, xloc.line);
2428 pp_base_newline (context->printer);
2431 /* Called from cp_thing to print the template context for an error. */
2433 maybe_print_instantiation_context (diagnostic_context *context)
2435 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2438 record_last_problematic_instantiation ();
2439 print_instantiation_full_context (context);
2442 /* Report the bare minimum context of a template instantiation. */
2444 print_instantiation_context (void)
2446 print_instantiation_partial_context
2447 (global_dc, current_instantiation (), input_location);
2448 diagnostic_flush_buffer (global_dc);
2451 /* Called from output_format -- during diagnostic message processing --
2452 to handle C++ specific format specifier with the following meanings:
2453 %A function argument-list.
2457 %F function declaration.
2458 %L language as used in extern "lang".
2460 %P function parameter whose position is indicated by an integer.
2461 %Q assignment operator.
2465 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2466 int precision, bool wide, bool set_locus, bool verbose)
2470 #define next_tree (t = va_arg (*text->args_ptr, tree))
2471 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2472 #define next_lang va_arg (*text->args_ptr, enum languages)
2473 #define next_int va_arg (*text->args_ptr, int)
2475 if (precision != 0 || wide)
2478 if (text->locus == NULL)
2483 case 'A': result = args_to_string (next_tree, verbose); break;
2484 case 'C': result = code_to_string (next_tcode); break;
2487 tree temp = next_tree;
2489 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
2491 temp = DECL_DEBUG_EXPR (temp);
2494 result = expr_to_string (temp);
2498 result = decl_to_string (temp, verbose);
2501 case 'E': result = expr_to_string (next_tree); break;
2502 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2503 case 'L': result = language_to_string (next_lang); break;
2504 case 'O': result = op_to_string (next_tcode); break;
2505 case 'P': result = parm_to_string (next_int); break;
2506 case 'Q': result = assop_to_string (next_tcode); break;
2507 case 'T': result = type_to_string (next_tree, verbose); break;
2508 case 'V': result = cv_to_string (next_tree, verbose); break;
2514 pp_base_string (pp, result);
2515 if (set_locus && t != NULL)
2516 *text->locus = location_of (t);
2524 /* Callback from cpp_error for PFILE to print diagnostics arising from
2525 interpreting strings. The diagnostic is of type LEVEL; MSG is the
2526 translated message and AP the arguments. */
2529 cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
2530 const char *msg, va_list *ap)
2532 diagnostic_info diagnostic;
2533 diagnostic_t dlevel;
2536 case CPP_DL_WARNING:
2537 case CPP_DL_WARNING_SYSHDR:
2538 dlevel = DK_WARNING;
2540 case CPP_DL_PEDWARN:
2541 dlevel = pedantic_error_kind ();
2552 diagnostic_set_info_translated (&diagnostic, msg, ap,
2553 input_location, dlevel);
2554 report_diagnostic (&diagnostic);
2557 /* Warn about the use of variadic templates when appropriate. */
2559 maybe_warn_variadic_templates (void)
2561 if ((cxx_dialect == cxx98) && !in_system_header)
2562 /* We really want to suppress this warning in system headers,
2563 because libstdc++ uses variadic templates even when we aren't
2565 pedwarn ("ISO C++ does not include variadic templates");