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 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
24 #include "coretypes.h"
31 #include "diagnostic.h"
32 #include "langhooks-def.h"
33 #include "cxx-pretty-print.h"
35 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
37 /* The global buffer where we dump everything. It is there only for
38 transitional purpose. It is expected, in the near future, to be
39 completely removed. */
40 static cxx_pretty_printer scratch_pretty_printer;
41 #define cxx_pp (&scratch_pretty_printer)
43 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
45 static const char *args_to_string (tree, int);
46 static const char *assop_to_string (enum tree_code);
47 static const char *code_to_string (enum tree_code);
48 static const char *cv_to_string (tree, int);
49 static const char *decl_to_string (tree, int);
50 static const char *expr_to_string (tree);
51 static const char *fndecl_to_string (tree, int);
52 static const char *op_to_string (enum tree_code);
53 static const char *parm_to_string (int);
54 static const char *type_to_string (tree, int);
56 static void dump_type (tree, int);
57 static void dump_typename (tree, int);
58 static void dump_simple_decl (tree, tree, int);
59 static void dump_decl (tree, int);
60 static void dump_template_decl (tree, int);
61 static void dump_function_decl (tree, int);
62 static void dump_expr (tree, int);
63 static void dump_unary_op (const char *, tree, int);
64 static void dump_binary_op (const char *, tree, int);
65 static void dump_aggr_type (tree, int);
66 static void dump_type_prefix (tree, int);
67 static void dump_type_suffix (tree, int);
68 static void dump_function_name (tree, int);
69 static void dump_call_expr_args (tree, int, bool);
70 static void dump_aggr_init_expr_args (tree, int, bool);
71 static void dump_expr_list (tree, int);
72 static void dump_global_iord (tree);
73 static void dump_parameters (tree, int);
74 static void dump_exception_spec (tree, int);
75 static void dump_template_argument (tree, int);
76 static void dump_template_argument_list (tree, int);
77 static void dump_template_parameter (tree, int);
78 static void dump_template_bindings (tree, tree);
79 static void dump_scope (tree, int);
80 static void dump_template_parms (tree, int, int);
82 static const char *function_category (tree);
83 static void maybe_print_instantiation_context (diagnostic_context *);
84 static void print_instantiation_full_context (diagnostic_context *);
85 static void print_instantiation_partial_context (diagnostic_context *,
87 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
88 static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
89 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
91 static bool cp_printer (pretty_printer *, text_info *, const char *,
92 int, bool, bool, bool);
93 static location_t location_of (tree);
98 diagnostic_starter (global_dc) = cp_diagnostic_starter;
99 diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer;
100 diagnostic_format_decoder (global_dc) = cp_printer;
102 pp_construct (pp_base (cxx_pp), NULL, 0);
103 pp_cxx_pretty_printer_init (cxx_pp);
106 /* Dump a scope, if deemed necessary. */
109 dump_scope (tree scope, int flags)
111 int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF));
113 if (scope == NULL_TREE)
116 if (TREE_CODE (scope) == NAMESPACE_DECL)
118 if (scope != global_namespace)
120 dump_decl (scope, f);
121 pp_cxx_colon_colon (cxx_pp);
124 else if (AGGREGATE_TYPE_P (scope))
126 dump_type (scope, f);
127 pp_cxx_colon_colon (cxx_pp);
129 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
131 dump_function_decl (scope, f);
132 pp_cxx_colon_colon (cxx_pp);
136 /* Dump the template ARGument under control of FLAGS. */
139 dump_template_argument (tree arg, int flags)
141 if (ARGUMENT_PACK_P (arg))
142 dump_template_argument_list (ARGUMENT_PACK_ARGS (arg), flags);
143 else if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
144 dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
146 dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
149 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
153 dump_template_argument_list (tree args, int flags)
155 int n = TREE_VEC_LENGTH (args);
159 for (i = 0; i< n; ++i)
161 tree arg = TREE_VEC_ELT (args, i);
163 /* Only print a comma if we know there is an argument coming. In
164 the case of an empty template argument pack, no actual
165 argument will be printed. */
167 && (!ARGUMENT_PACK_P (arg)
168 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
169 pp_separate_with_comma (cxx_pp);
171 dump_template_argument (arg, flags);
176 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
179 dump_template_parameter (tree parm, int flags)
184 if (parm == error_mark_node)
187 p = TREE_VALUE (parm);
188 a = TREE_PURPOSE (parm);
190 if (TREE_CODE (p) == TYPE_DECL)
192 if (flags & TFF_DECL_SPECIFIERS)
194 pp_cxx_identifier (cxx_pp, "class");
195 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p)))
196 pp_cxx_identifier (cxx_pp, "...");
198 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
200 else if (DECL_NAME (p))
201 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
203 pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
206 dump_decl (p, flags | TFF_DECL_SPECIFIERS);
208 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
210 pp_cxx_whitespace (cxx_pp);
212 pp_cxx_whitespace (cxx_pp);
213 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
214 dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
216 dump_expr (a, flags | TFF_EXPR_IN_PARENS);
220 /* Dump, under control of FLAGS, a template-parameter-list binding.
221 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
225 dump_template_bindings (tree parms, tree args)
231 tree p = TREE_VALUE (parms);
232 int lvl = TMPL_PARMS_DEPTH (parms);
236 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
238 tree arg = NULL_TREE;
240 /* Don't crash if we had an invalid argument list. */
241 if (TMPL_ARGS_DEPTH (args) >= lvl)
243 tree lvl_args = TMPL_ARGS_LEVEL (args, lvl);
244 if (NUM_TMPL_ARGS (lvl_args) > arg_idx)
245 arg = TREE_VEC_ELT (lvl_args, arg_idx);
249 pp_separate_with_comma (cxx_pp);
250 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
251 pp_cxx_whitespace (cxx_pp);
253 pp_cxx_whitespace (cxx_pp);
255 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
257 pp_identifier (cxx_pp, "<missing>");
263 parms = TREE_CHAIN (parms);
267 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
271 dump_type (tree t, int flags)
276 if (TYPE_PTRMEMFUNC_P (t))
279 switch (TREE_CODE (t))
282 pp_identifier (cxx_pp, "<unresolved overloaded function type>");
286 /* A list of function parms. */
287 dump_parameters (t, flags);
290 case IDENTIFIER_NODE:
291 pp_cxx_tree_identifier (cxx_pp, t);
295 dump_type (BINFO_TYPE (t), flags);
301 dump_aggr_type (t, flags);
305 if (flags & TFF_CHASE_TYPEDEF)
307 dump_type (DECL_ORIGINAL_TYPE (t)
308 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
311 /* Else fall through. */
315 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
324 pp_type_specifier_seq (cxx_pp, t);
327 case TEMPLATE_TEMPLATE_PARM:
328 /* For parameters inside template signature. */
329 if (TYPE_IDENTIFIER (t))
330 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
332 pp_cxx_canonical_template_parameter (cxx_pp, t);
335 case BOUND_TEMPLATE_TEMPLATE_PARM:
337 tree args = TYPE_TI_ARGS (t);
338 pp_cxx_cv_qualifier_seq (cxx_pp, t);
339 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
340 pp_cxx_begin_template_argument_list (cxx_pp);
341 dump_template_argument_list (args, flags);
342 pp_cxx_end_template_argument_list (cxx_pp);
346 case TEMPLATE_TYPE_PARM:
347 pp_cxx_cv_qualifier_seq (cxx_pp, t);
348 if (TYPE_IDENTIFIER (t))
349 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
351 pp_cxx_canonical_template_parameter
352 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
355 /* This is not always necessary for pointers and such, but doing this
356 reduces code size. */
365 dump_type_prefix (t, flags);
366 dump_type_suffix (t, flags);
370 pp_cxx_cv_qualifier_seq (cxx_pp, t);
371 pp_cxx_identifier (cxx_pp,
372 TYPENAME_IS_ENUM_P (t) ? "enum"
373 : TYPENAME_IS_CLASS_P (t) ? "class"
375 dump_typename (t, flags);
378 case UNBOUND_CLASS_TEMPLATE:
379 dump_type (TYPE_CONTEXT (t), flags);
380 pp_cxx_colon_colon (cxx_pp);
381 pp_cxx_identifier (cxx_pp, "template");
382 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
386 pp_cxx_identifier (cxx_pp, "__typeof__");
387 pp_cxx_whitespace (cxx_pp);
388 pp_cxx_left_paren (cxx_pp);
389 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
390 pp_cxx_right_paren (cxx_pp);
393 case TYPE_PACK_EXPANSION:
394 dump_type (PACK_EXPANSION_PATTERN (t), flags);
395 pp_cxx_identifier (cxx_pp, "...");
398 case TYPE_ARGUMENT_PACK:
400 tree args = ARGUMENT_PACK_ARGS (t);
402 for (i = 0; i < TREE_VEC_LENGTH (args); ++i)
405 pp_separate_with_comma (cxx_pp);
406 dump_type (TREE_VEC_ELT (args, i), flags);
412 pp_unsupported_tree (cxx_pp, t);
413 /* Fall through to error. */
416 pp_identifier (cxx_pp, "<type error>");
421 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
425 dump_typename (tree t, int flags)
427 tree ctx = TYPE_CONTEXT (t);
429 if (TREE_CODE (ctx) == TYPENAME_TYPE)
430 dump_typename (ctx, flags);
432 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
433 pp_cxx_colon_colon (cxx_pp);
434 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
437 /* Return the name of the supplied aggregate, or enumeral type. */
440 class_key_or_enum_as_string (tree t)
442 if (TREE_CODE (t) == ENUMERAL_TYPE)
444 else if (TREE_CODE (t) == UNION_TYPE)
446 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
452 /* Print out a class declaration T under the control of FLAGS,
453 in the form `class foo'. */
456 dump_aggr_type (tree t, int flags)
459 const char *variety = class_key_or_enum_as_string (t);
463 pp_cxx_cv_qualifier_seq (cxx_pp, t);
465 if (flags & TFF_CLASS_KEY_OR_ENUM)
466 pp_cxx_identifier (cxx_pp, variety);
468 if (flags & TFF_CHASE_TYPEDEF)
469 t = TYPE_MAIN_VARIANT (t);
471 name = TYPE_NAME (t);
475 typdef = !DECL_ARTIFICIAL (name);
476 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
477 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
478 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
479 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
481 if (! (flags & TFF_UNQUALIFIED_NAME))
482 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
483 flags &= ~TFF_UNQUALIFIED_NAME;
486 /* Because the template names are mangled, we have to locate
487 the most general template, and use that name. */
488 tree tpl = CLASSTYPE_TI_TEMPLATE (t);
490 while (DECL_TEMPLATE_INFO (tpl))
491 tpl = DECL_TI_TEMPLATE (tpl);
494 name = DECL_NAME (name);
497 if (name == 0 || ANON_AGGRNAME_P (name))
499 if (flags & TFF_CLASS_KEY_OR_ENUM)
500 pp_identifier (cxx_pp, "<anonymous>");
502 pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety);
505 pp_cxx_tree_identifier (cxx_pp, name);
507 dump_template_parms (TYPE_TEMPLATE_INFO (t),
508 !CLASSTYPE_USE_TEMPLATE (t),
509 flags & ~TFF_TEMPLATE_HEADER);
512 /* Dump into the obstack the initial part of the output for a given type.
513 This is necessary when dealing with things like functions returning
516 return type of `int (* fee ())()': pointer -> function -> int. Both
517 pointer (and reference and offset) and function (and member) types must
518 deal with prefix and suffix.
520 Arrays must also do this for DECL nodes, like int a[], and for things like
524 dump_type_prefix (tree t, int flags)
526 if (TYPE_PTRMEMFUNC_P (t))
528 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
532 switch (TREE_CODE (t))
537 tree sub = TREE_TYPE (t);
539 dump_type_prefix (sub, flags);
540 if (TREE_CODE (sub) == ARRAY_TYPE)
542 pp_cxx_whitespace (cxx_pp);
543 pp_cxx_left_paren (cxx_pp);
545 if (TREE_CODE (t) == POINTER_TYPE)
546 pp_character(cxx_pp, '*');
547 else if (TREE_CODE (t) == REFERENCE_TYPE)
549 if (TYPE_REF_IS_RVALUE (t))
550 pp_string (cxx_pp, "&&");
552 pp_character (cxx_pp, '&');
554 pp_base (cxx_pp)->padding = pp_before;
555 pp_cxx_cv_qualifier_seq (cxx_pp, t);
561 dump_type_prefix (TREE_TYPE (t), flags);
562 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
564 pp_maybe_space (cxx_pp);
565 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
566 pp_cxx_left_paren (cxx_pp);
567 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
568 pp_cxx_colon_colon (cxx_pp);
570 pp_cxx_star (cxx_pp);
571 pp_cxx_cv_qualifier_seq (cxx_pp, t);
572 pp_base (cxx_pp)->padding = pp_before;
575 /* Can only be reached through function pointer -- this would not be
576 correct if FUNCTION_DECLs used it. */
578 dump_type_prefix (TREE_TYPE (t), flags);
579 pp_maybe_space (cxx_pp);
580 pp_cxx_left_paren (cxx_pp);
584 dump_type_prefix (TREE_TYPE (t), flags);
585 pp_maybe_space (cxx_pp);
586 pp_cxx_left_paren (cxx_pp);
587 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
588 pp_cxx_colon_colon (cxx_pp);
592 dump_type_prefix (TREE_TYPE (t), flags);
596 case IDENTIFIER_NODE:
601 case TEMPLATE_TYPE_PARM:
602 case TEMPLATE_TEMPLATE_PARM:
603 case BOUND_TEMPLATE_TEMPLATE_PARM:
614 dump_type (t, flags);
615 pp_base (cxx_pp)->padding = pp_before;
619 pp_unsupported_tree (cxx_pp, t);
622 pp_identifier (cxx_pp, "<typeprefixerror>");
627 /* Dump the suffix of type T, under control of FLAGS. This is the part
628 which appears after the identifier (or function parms). */
631 dump_type_suffix (tree t, int flags)
633 if (TYPE_PTRMEMFUNC_P (t))
634 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
636 switch (TREE_CODE (t))
641 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
642 pp_cxx_right_paren (cxx_pp);
643 dump_type_suffix (TREE_TYPE (t), flags);
646 /* Can only be reached through function pointer. */
651 pp_cxx_right_paren (cxx_pp);
652 arg = TYPE_ARG_TYPES (t);
653 if (TREE_CODE (t) == METHOD_TYPE)
654 arg = TREE_CHAIN (arg);
656 /* Function pointers don't have default args. Not in standard C++,
657 anyway; they may in g++, but we'll just pretend otherwise. */
658 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
660 if (TREE_CODE (t) == METHOD_TYPE)
661 pp_cxx_cv_qualifier_seq
662 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
664 pp_cxx_cv_qualifier_seq(cxx_pp, t);
665 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
666 dump_type_suffix (TREE_TYPE (t), flags);
671 pp_maybe_space (cxx_pp);
672 pp_cxx_left_bracket (cxx_pp);
675 tree dtype = TYPE_DOMAIN (t);
676 tree max = TYPE_MAX_VALUE (dtype);
677 if (host_integerp (max, 0))
678 pp_wide_integer (cxx_pp, tree_low_cst (max, 0) + 1);
679 else if (TREE_CODE (max) == MINUS_EXPR)
680 dump_expr (TREE_OPERAND (max, 0),
681 flags & ~TFF_EXPR_IN_PARENS);
683 dump_expr (fold_build2 (PLUS_EXPR, dtype, max,
684 build_int_cst (dtype, 1)),
685 flags & ~TFF_EXPR_IN_PARENS);
687 pp_cxx_right_bracket (cxx_pp);
688 dump_type_suffix (TREE_TYPE (t), flags);
692 case IDENTIFIER_NODE:
697 case TEMPLATE_TYPE_PARM:
698 case TEMPLATE_TEMPLATE_PARM:
699 case BOUND_TEMPLATE_TEMPLATE_PARM:
713 pp_unsupported_tree (cxx_pp, t);
715 /* Don't mark it here, we should have already done in
722 dump_global_iord (tree t)
724 const char *p = NULL;
726 if (DECL_GLOBAL_CTOR_P (t))
728 else if (DECL_GLOBAL_DTOR_P (t))
733 pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename);
737 dump_simple_decl (tree t, tree type, int flags)
739 if (flags & TFF_DECL_SPECIFIERS)
741 dump_type_prefix (type, flags & ~TFF_UNQUALIFIED_NAME);
742 pp_maybe_space (cxx_pp);
744 if (! (flags & TFF_UNQUALIFIED_NAME)
745 && (!DECL_INITIAL (t)
746 || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
747 dump_scope (CP_DECL_CONTEXT (t), flags);
748 flags &= ~TFF_UNQUALIFIED_NAME;
750 dump_decl (DECL_NAME (t), flags);
752 pp_identifier (cxx_pp, "<anonymous>");
753 if (flags & TFF_DECL_SPECIFIERS)
754 dump_type_suffix (type, flags);
757 /* Dump a human readable string for the decl T under control of FLAGS. */
760 dump_decl (tree t, int flags)
765 switch (TREE_CODE (t))
768 /* Don't say 'typedef class A' */
769 if (DECL_ARTIFICIAL (t))
771 if ((flags & TFF_DECL_SPECIFIERS)
772 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
773 /* Say `class T' not just `T'. */
774 pp_cxx_identifier (cxx_pp, "class");
776 dump_type (TREE_TYPE (t), flags);
779 if (flags & TFF_DECL_SPECIFIERS)
780 pp_cxx_identifier (cxx_pp, "typedef");
781 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
782 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
787 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
789 pp_string (cxx_pp, "vtable for ");
790 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
791 dump_type (DECL_CONTEXT (t), flags);
794 /* Else fall through. */
797 dump_simple_decl (t, TREE_TYPE (t), flags);
801 pp_string (cxx_pp, "<return value> ");
802 dump_simple_decl (t, TREE_TYPE (t), flags);
806 if (flags & TFF_DECL_SPECIFIERS)
807 pp_cxx_declaration (cxx_pp, t);
810 if (! (flags & TFF_UNQUALIFIED_NAME))
811 dump_scope (CP_DECL_CONTEXT (t), flags);
812 flags &= ~TFF_UNQUALIFIED_NAME;
813 if (DECL_NAME (t) == NULL_TREE)
814 pp_identifier (cxx_pp, "<unnamed>");
816 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
821 pp_expression (cxx_pp, t);
825 dump_decl (TREE_OPERAND (t, 0), flags);
826 pp_cxx_left_bracket (cxx_pp);
827 dump_decl (TREE_OPERAND (t, 1), flags);
828 pp_cxx_right_bracket (cxx_pp);
831 /* So that we can do dump_decl on an aggr type. */
835 dump_type (t, flags);
839 /* This is a pseudo destructor call which has not been folded into
840 a PSEUDO_DTOR_EXPR yet. */
841 pp_cxx_complement (cxx_pp);
842 dump_type (TREE_OPERAND (t, 0), flags);
849 /* These special cases are duplicated here so that other functions
850 can feed identifiers to error and get them demangled properly. */
851 case IDENTIFIER_NODE:
852 if (IDENTIFIER_TYPENAME_P (t))
854 pp_cxx_identifier (cxx_pp, "operator");
855 /* Not exactly IDENTIFIER_TYPE_VALUE. */
856 dump_type (TREE_TYPE (t), flags);
860 pp_cxx_tree_identifier (cxx_pp, t);
867 if (DECL_CLASS_SCOPE_P (t))
869 dump_type (DECL_CONTEXT (t), flags);
870 pp_cxx_colon_colon (cxx_pp);
872 else if (DECL_CONTEXT (t))
874 dump_decl (DECL_CONTEXT (t), flags);
875 pp_cxx_colon_colon (cxx_pp);
877 dump_decl (DECL_NAME (t), flags);
881 /* If there's only one function, just treat it like an ordinary
887 if (! DECL_LANG_SPECIFIC (t))
888 pp_identifier (cxx_pp, "<built-in>");
889 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
890 dump_global_iord (t);
892 dump_function_decl (t, flags);
896 dump_template_decl (t, flags);
899 case TEMPLATE_ID_EXPR:
901 tree name = TREE_OPERAND (t, 0);
903 if (is_overloaded_fn (name))
904 name = DECL_NAME (get_first_fn (name));
905 dump_decl (name, flags);
906 pp_cxx_begin_template_argument_list (cxx_pp);
907 if (TREE_OPERAND (t, 1))
908 dump_template_argument_list (TREE_OPERAND (t, 1), flags);
909 pp_cxx_end_template_argument_list (cxx_pp);
914 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
918 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
919 || (DECL_INITIAL (t) &&
920 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
921 dump_simple_decl (t, TREE_TYPE (t), flags);
922 else if (DECL_NAME (t))
923 dump_decl (DECL_NAME (t), flags);
924 else if (DECL_INITIAL (t))
925 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
927 pp_identifier (cxx_pp, "<enumerator>");
931 pp_cxx_identifier (cxx_pp, "using");
932 dump_type (USING_DECL_SCOPE (t), flags);
933 pp_cxx_colon_colon (cxx_pp);
934 dump_decl (DECL_NAME (t), flags);
938 pp_cxx_declaration (cxx_pp, t);
942 dump_decl (BASELINK_FUNCTIONS (t), flags);
945 case NON_DEPENDENT_EXPR:
946 dump_expr (t, flags);
949 case TEMPLATE_TYPE_PARM:
950 if (flags & TFF_DECL_SPECIFIERS)
951 pp_cxx_declaration (cxx_pp, t);
953 pp_type_id (cxx_pp, t);
957 pp_unsupported_tree (cxx_pp, t);
958 /* Fall through to error. */
961 pp_identifier (cxx_pp, "<declaration error>");
966 /* Dump a template declaration T under control of FLAGS. This means the
967 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
970 dump_template_decl (tree t, int flags)
972 tree orig_parms = DECL_TEMPLATE_PARMS (t);
976 if (flags & TFF_TEMPLATE_HEADER)
978 for (parms = orig_parms = nreverse (orig_parms);
980 parms = TREE_CHAIN (parms))
982 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
983 int len = TREE_VEC_LENGTH (inner_parms);
985 pp_cxx_identifier (cxx_pp, "template");
986 pp_cxx_begin_template_argument_list (cxx_pp);
988 /* If we've shown the template prefix, we'd better show the
989 parameters' and decl's type too. */
990 flags |= TFF_DECL_SPECIFIERS;
992 for (i = 0; i < len; i++)
995 pp_separate_with_comma (cxx_pp);
996 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
998 pp_cxx_end_template_argument_list (cxx_pp);
999 pp_cxx_whitespace (cxx_pp);
1001 nreverse(orig_parms);
1003 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1004 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1005 pp_cxx_identifier (cxx_pp, "class");
1008 if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
1009 dump_type (TREE_TYPE (t),
1010 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1011 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1012 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
1013 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1016 gcc_assert (TREE_TYPE (t));
1017 switch (NEXT_CODE (t))
1021 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1024 /* This case can occur with some invalid code. */
1025 dump_type (TREE_TYPE (t),
1026 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1027 | (flags & TFF_DECL_SPECIFIERS
1028 ? TFF_CLASS_KEY_OR_ENUM : 0));
1033 /* Pretty print a function decl. There are several ways we want to print a
1034 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1035 As error can only apply the '#' flag once to give 0 and 1 for V, there
1036 is %D which doesn't print the throw specs, and %F which does. */
1039 dump_function_decl (tree t, int flags)
1043 tree cname = NULL_TREE;
1044 tree template_args = NULL_TREE;
1045 tree template_parms = NULL_TREE;
1046 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1047 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1049 flags &= ~TFF_UNQUALIFIED_NAME;
1050 if (TREE_CODE (t) == TEMPLATE_DECL)
1051 t = DECL_TEMPLATE_RESULT (t);
1053 /* Pretty print template instantiations only. */
1054 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t))
1058 template_args = DECL_TI_ARGS (t);
1059 tmpl = most_general_template (t);
1060 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1062 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1067 fntype = TREE_TYPE (t);
1068 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1070 if (DECL_CLASS_SCOPE_P (t))
1071 cname = DECL_CONTEXT (t);
1072 /* This is for partially instantiated template methods. */
1073 else if (TREE_CODE (fntype) == METHOD_TYPE)
1074 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1076 if (!(flags & TFF_DECL_SPECIFIERS))
1078 else if (DECL_STATIC_FUNCTION_P (t))
1079 pp_cxx_identifier (cxx_pp, "static");
1080 else if (DECL_VIRTUAL_P (t))
1081 pp_cxx_identifier (cxx_pp, "virtual");
1083 /* Print the return type? */
1085 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1086 && !DECL_DESTRUCTOR_P (t);
1088 dump_type_prefix (TREE_TYPE (fntype), flags);
1090 /* Print the function name. */
1091 if (!do_outer_scope)
1095 dump_type (cname, flags);
1096 pp_cxx_colon_colon (cxx_pp);
1099 dump_scope (CP_DECL_CONTEXT (t), flags);
1101 dump_function_name (t, flags);
1103 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1105 dump_parameters (parmtypes, flags);
1107 if (TREE_CODE (fntype) == METHOD_TYPE)
1109 pp_base (cxx_pp)->padding = pp_before;
1110 pp_cxx_cv_qualifier_seq
1111 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1114 if (flags & TFF_EXCEPTION_SPECIFICATION)
1116 pp_base (cxx_pp)->padding = pp_before;
1117 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
1121 dump_type_suffix (TREE_TYPE (fntype), flags);
1124 /* If T is a template instantiation, dump the parameter binding. */
1125 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1127 pp_cxx_whitespace (cxx_pp);
1128 pp_cxx_left_bracket (cxx_pp);
1129 pp_cxx_identifier (cxx_pp, "with");
1130 pp_cxx_whitespace (cxx_pp);
1131 dump_template_bindings (template_parms, template_args);
1132 pp_cxx_right_bracket (cxx_pp);
1136 /* Print a parameter list. If this is for a member function, the
1137 member object ptr (and any other hidden args) should have
1138 already been removed. */
1141 dump_parameters (tree parmtypes, int flags)
1144 pp_cxx_left_paren (cxx_pp);
1146 for (first = 1; parmtypes != void_list_node;
1147 parmtypes = TREE_CHAIN (parmtypes))
1150 pp_separate_with_comma (cxx_pp);
1154 pp_cxx_identifier (cxx_pp, "...");
1157 if (ARGUMENT_PACK_P (TREE_VALUE (parmtypes)))
1159 tree types = ARGUMENT_PACK_ARGS (TREE_VALUE (parmtypes));
1160 int i, len = TREE_VEC_LENGTH (types);
1162 for (i = 0; i < len; ++i)
1165 pp_separate_with_comma (cxx_pp);
1168 dump_type (TREE_VEC_ELT (types, i), flags);
1172 dump_type (TREE_VALUE (parmtypes), flags);
1174 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1176 pp_cxx_whitespace (cxx_pp);
1178 pp_cxx_whitespace (cxx_pp);
1179 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1183 pp_cxx_right_paren (cxx_pp);
1186 /* Print an exception specification. T is the exception specification. */
1189 dump_exception_spec (tree t, int flags)
1193 pp_cxx_identifier (cxx_pp, "throw");
1194 pp_cxx_whitespace (cxx_pp);
1195 pp_cxx_left_paren (cxx_pp);
1196 if (TREE_VALUE (t) != NULL_TREE)
1199 dump_type (TREE_VALUE (t), flags);
1203 pp_separate_with_comma (cxx_pp);
1205 pp_cxx_right_paren (cxx_pp);
1209 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1210 and destructors properly. */
1213 dump_function_name (tree t, int flags)
1215 tree name = DECL_NAME (t);
1217 /* We can get here with a decl that was synthesized by language-
1218 independent machinery (e.g. coverage.c) in which case it won't
1219 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1220 will crash. In this case it is safe just to print out the
1222 if (!DECL_LANG_SPECIFIC (t))
1224 pp_cxx_tree_identifier (cxx_pp, name);
1228 if (TREE_CODE (t) == TEMPLATE_DECL)
1229 t = DECL_TEMPLATE_RESULT (t);
1231 /* Don't let the user see __comp_ctor et al. */
1232 if (DECL_CONSTRUCTOR_P (t)
1233 || DECL_DESTRUCTOR_P (t))
1234 name = constructor_name (DECL_CONTEXT (t));
1236 if (DECL_DESTRUCTOR_P (t))
1238 pp_cxx_complement (cxx_pp);
1239 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1241 else if (DECL_CONV_FN_P (t))
1243 /* This cannot use the hack that the operator's return
1244 type is stashed off of its name because it may be
1245 used for error reporting. In the case of conflicting
1246 declarations, both will have the same name, yet
1247 the types will be different, hence the TREE_TYPE field
1248 of the first name will be clobbered by the second. */
1249 pp_cxx_identifier (cxx_pp, "operator");
1250 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1252 else if (IDENTIFIER_OPNAME_P (name))
1253 pp_cxx_tree_identifier (cxx_pp, name);
1255 dump_decl (name, flags);
1257 if (DECL_TEMPLATE_INFO (t)
1258 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1259 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1260 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1261 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1264 /* Dump the template parameters from the template info INFO under control of
1265 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1266 specialization (partial or complete). For partial specializations we show
1267 the specialized parameter values. For a primary template we show no
1271 dump_template_parms (tree info, int primary, int flags)
1273 tree args = info ? TI_ARGS (info) : NULL_TREE;
1275 if (primary && flags & TFF_TEMPLATE_NAME)
1277 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1278 pp_cxx_begin_template_argument_list (cxx_pp);
1280 /* Be careful only to print things when we have them, so as not
1281 to crash producing error messages. */
1282 if (args && !primary)
1286 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
1287 args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
1289 len = TREE_VEC_LENGTH (args);
1291 for (ix = 0; ix != len; ix++)
1293 tree arg = TREE_VEC_ELT (args, ix);
1295 /* Only print a comma if we know there is an argument coming. In
1296 the case of an empty template argument pack, no actual
1297 argument will be printed. */
1299 && (!ARGUMENT_PACK_P (arg)
1300 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1301 pp_separate_with_comma (cxx_pp);
1304 pp_identifier (cxx_pp, "<template parameter error>");
1306 dump_template_argument (arg, flags);
1311 tree tpl = TI_TEMPLATE (info);
1312 tree parms = DECL_TEMPLATE_PARMS (tpl);
1315 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1316 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1318 for (ix = 0; ix != len; ix++)
1322 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1324 pp_identifier (cxx_pp, "<template parameter error>");
1328 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1331 pp_separate_with_comma (cxx_pp);
1333 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1336 pp_cxx_end_template_argument_list (cxx_pp);
1339 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1340 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1343 dump_call_expr_args (tree t, int flags, bool skipfirst)
1346 call_expr_arg_iterator iter;
1348 pp_cxx_left_paren (cxx_pp);
1349 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1355 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1356 if (more_call_expr_args_p (&iter))
1357 pp_separate_with_comma (cxx_pp);
1360 pp_cxx_right_paren (cxx_pp);
1363 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1364 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1368 dump_aggr_init_expr_args (tree t, int flags, bool skipfirst)
1371 aggr_init_expr_arg_iterator iter;
1373 pp_cxx_left_paren (cxx_pp);
1374 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1380 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1381 if (more_aggr_init_expr_args_p (&iter))
1382 pp_separate_with_comma (cxx_pp);
1385 pp_cxx_right_paren (cxx_pp);
1388 /* Print out a list of initializers (subr of dump_expr). */
1391 dump_expr_list (tree l, int flags)
1395 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1398 pp_separate_with_comma (cxx_pp);
1402 /* Print out a vector of initializers (subr of dump_expr). */
1405 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1407 unsigned HOST_WIDE_INT idx;
1410 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1412 dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1413 if (idx != VEC_length (constructor_elt, v) - 1)
1414 pp_separate_with_comma (cxx_pp);
1419 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1420 function. Resolve it to a close relative -- in the sense of static
1421 type -- variant being overridden. That is close to what was written in
1422 the source code. Subroutine of dump_expr. */
1425 resolve_virtual_fun_from_obj_type_ref (tree ref)
1427 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1428 int index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1429 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1431 fun = TREE_CHAIN (fun);
1436 /* Print out an expression E under control of FLAGS. */
1439 dump_expr (tree t, int flags)
1444 switch (TREE_CODE (t))
1452 case NAMESPACE_DECL:
1455 case IDENTIFIER_NODE:
1456 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1462 pp_constant (cxx_pp, t);
1466 pp_cxx_identifier (cxx_pp, "throw");
1467 dump_expr (TREE_OPERAND (t, 0), flags);
1471 pp_ampersand (cxx_pp);
1472 dump_type (PTRMEM_CST_CLASS (t), flags);
1473 pp_cxx_colon_colon (cxx_pp);
1474 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1478 pp_cxx_left_paren (cxx_pp);
1479 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1480 pp_separate_with_comma (cxx_pp);
1481 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1482 pp_cxx_right_paren (cxx_pp);
1486 pp_cxx_left_paren (cxx_pp);
1487 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1488 pp_string (cxx_pp, " ? ");
1489 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1490 pp_string (cxx_pp, " : ");
1491 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1492 pp_cxx_right_paren (cxx_pp);
1496 if (TREE_HAS_CONSTRUCTOR (t))
1498 pp_cxx_identifier (cxx_pp, "new");
1499 pp_cxx_whitespace (cxx_pp);
1500 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1503 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1506 case AGGR_INIT_EXPR:
1508 tree fn = NULL_TREE;
1510 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
1511 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
1513 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1515 if (DECL_CONSTRUCTOR_P (fn))
1516 dump_type (DECL_CONTEXT (fn), flags);
1521 dump_expr (AGGR_INIT_EXPR_FN (t), 0);
1523 dump_aggr_init_expr_args (t, flags, false);
1528 tree fn = CALL_EXPR_FN (t);
1529 bool skipfirst = false;
1531 if (TREE_CODE (fn) == ADDR_EXPR)
1532 fn = TREE_OPERAND (fn, 0);
1534 /* Nobody is interested in seeing the guts of vcalls. */
1535 if (TREE_CODE (fn) == OBJ_TYPE_REF)
1536 fn = resolve_virtual_fun_from_obj_type_ref (fn);
1538 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1540 tree ob = CALL_EXPR_ARG (t, 0);
1541 if (TREE_CODE (ob) == ADDR_EXPR)
1543 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1546 else if (TREE_CODE (ob) != PARM_DECL
1547 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1549 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1554 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1555 dump_call_expr_args (t, flags, skipfirst);
1561 tree type = TREE_OPERAND (t, 1);
1562 tree init = TREE_OPERAND (t, 2);
1563 if (NEW_EXPR_USE_GLOBAL (t))
1564 pp_cxx_colon_colon (cxx_pp);
1565 pp_cxx_identifier (cxx_pp, "new");
1566 if (TREE_OPERAND (t, 0))
1568 pp_cxx_left_paren (cxx_pp);
1569 dump_expr_list (TREE_OPERAND (t, 0), flags);
1570 pp_cxx_right_paren (cxx_pp);
1571 pp_cxx_whitespace (cxx_pp);
1573 if (TREE_CODE (type) == ARRAY_REF)
1574 type = build_cplus_array_type
1575 (TREE_OPERAND (type, 0),
1576 build_index_type (fold_build2 (MINUS_EXPR, integer_type_node,
1577 TREE_OPERAND (type, 1),
1578 integer_one_node)));
1579 dump_type (type, flags);
1582 pp_cxx_left_paren (cxx_pp);
1583 if (TREE_CODE (init) == TREE_LIST)
1584 dump_expr_list (init, flags);
1585 else if (init == void_zero_node)
1586 /* This representation indicates an empty initializer,
1587 e.g.: "new int()". */
1590 dump_expr (init, flags);
1591 pp_cxx_right_paren (cxx_pp);
1597 /* Note that this only works for G++ target exprs. If somebody
1598 builds a general TARGET_EXPR, there's no way to represent that
1599 it initializes anything other that the parameter slot for the
1600 default argument. Note we may have cleared out the first
1601 operand in expand_expr, so don't go killing ourselves. */
1602 if (TREE_OPERAND (t, 1))
1603 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1611 case TRUNC_DIV_EXPR:
1612 case TRUNC_MOD_EXPR:
1620 case TRUTH_ANDIF_EXPR:
1621 case TRUTH_ORIF_EXPR:
1628 case EXACT_DIV_EXPR:
1629 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1633 case FLOOR_DIV_EXPR:
1634 case ROUND_DIV_EXPR:
1636 dump_binary_op ("/", t, flags);
1640 case FLOOR_MOD_EXPR:
1641 case ROUND_MOD_EXPR:
1642 dump_binary_op ("%", t, flags);
1647 tree ob = TREE_OPERAND (t, 0);
1648 if (TREE_CODE (ob) == INDIRECT_REF)
1650 ob = TREE_OPERAND (ob, 0);
1651 if (TREE_CODE (ob) != PARM_DECL
1653 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1655 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1656 pp_cxx_arrow (cxx_pp);
1661 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1662 pp_cxx_dot (cxx_pp);
1664 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1669 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1670 pp_cxx_left_bracket (cxx_pp);
1671 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1672 pp_cxx_right_bracket (cxx_pp);
1675 case UNARY_PLUS_EXPR:
1676 dump_unary_op ("+", t, flags);
1680 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1681 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1682 /* An ADDR_EXPR can have reference type. In that case, we
1683 shouldn't print the `&' doing so indicates to the user
1684 that the expression has pointer type. */
1686 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1687 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1688 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1689 dump_unary_op ("&&", t, flags);
1691 dump_unary_op ("&", t, flags);
1695 if (TREE_HAS_CONSTRUCTOR (t))
1697 t = TREE_OPERAND (t, 0);
1698 gcc_assert (TREE_CODE (t) == CALL_EXPR);
1699 dump_expr (CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
1700 dump_call_expr_args (t, flags, true);
1704 if (TREE_OPERAND (t,0) != NULL_TREE
1705 && TREE_TYPE (TREE_OPERAND (t, 0))
1706 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1707 dump_expr (TREE_OPERAND (t, 0), flags);
1709 dump_unary_op ("*", t, flags);
1715 case TRUTH_NOT_EXPR:
1716 case PREDECREMENT_EXPR:
1717 case PREINCREMENT_EXPR:
1718 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1721 case POSTDECREMENT_EXPR:
1722 case POSTINCREMENT_EXPR:
1723 pp_cxx_left_paren (cxx_pp);
1724 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1725 pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1726 pp_cxx_right_paren (cxx_pp);
1729 case NON_LVALUE_EXPR:
1730 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1731 should be another level of INDIRECT_REF so that I don't have to do
1733 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1735 tree next = TREE_TYPE (TREE_TYPE (t));
1737 while (TREE_CODE (next) == POINTER_TYPE)
1738 next = TREE_TYPE (next);
1740 if (TREE_CODE (next) == FUNCTION_TYPE)
1742 if (flags & TFF_EXPR_IN_PARENS)
1743 pp_cxx_left_paren (cxx_pp);
1744 pp_cxx_star (cxx_pp);
1745 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1746 if (flags & TFF_EXPR_IN_PARENS)
1747 pp_cxx_right_paren (cxx_pp);
1750 /* Else fall through. */
1752 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1758 tree op = TREE_OPERAND (t, 0);
1760 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1762 /* It is a cast, but we cannot tell whether it is a
1763 reinterpret or static cast. Use the C style notation. */
1764 if (flags & TFF_EXPR_IN_PARENS)
1765 pp_cxx_left_paren (cxx_pp);
1766 pp_cxx_left_paren (cxx_pp);
1767 dump_type (TREE_TYPE (t), flags);
1768 pp_cxx_right_paren (cxx_pp);
1769 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1770 if (flags & TFF_EXPR_IN_PARENS)
1771 pp_cxx_right_paren (cxx_pp);
1774 dump_expr (op, flags);
1779 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1781 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1783 if (integer_zerop (idx))
1785 /* A NULL pointer-to-member constant. */
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 pp_character (cxx_pp, '0');
1791 pp_cxx_right_paren (cxx_pp);
1794 else if (host_integerp (idx, 0))
1797 unsigned HOST_WIDE_INT n;
1799 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1800 t = TYPE_METHOD_BASETYPE (t);
1801 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1803 n = tree_low_cst (idx, 0);
1805 /* Map vtable index back one, to allow for the null pointer to
1809 while (n > 0 && virtuals)
1812 virtuals = TREE_CHAIN (virtuals);
1816 dump_expr (BV_FN (virtuals),
1817 flags | TFF_EXPR_IN_PARENS);
1822 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
1824 dump_type (TREE_TYPE (t), 0);
1825 pp_cxx_left_paren (cxx_pp);
1826 pp_cxx_right_paren (cxx_pp);
1830 pp_cxx_left_brace (cxx_pp);
1831 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
1832 pp_cxx_right_brace (cxx_pp);
1839 tree ob = TREE_OPERAND (t, 0);
1840 if (is_dummy_object (ob))
1842 t = TREE_OPERAND (t, 1);
1843 if (TREE_CODE (t) == FUNCTION_DECL)
1845 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1846 else if (BASELINK_P (t))
1847 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1848 flags | TFF_EXPR_IN_PARENS);
1850 dump_decl (t, flags);
1854 if (TREE_CODE (ob) == INDIRECT_REF)
1856 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1857 pp_cxx_arrow (cxx_pp);
1858 pp_cxx_star (cxx_pp);
1862 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1863 pp_cxx_dot (cxx_pp);
1864 pp_cxx_star (cxx_pp);
1866 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1871 case TEMPLATE_PARM_INDEX:
1872 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1876 pp_expression (cxx_pp, t);
1880 if (TREE_OPERAND (t, 0) == NULL_TREE
1881 || TREE_CHAIN (TREE_OPERAND (t, 0)))
1883 dump_type (TREE_TYPE (t), flags);
1884 pp_cxx_left_paren (cxx_pp);
1885 dump_expr_list (TREE_OPERAND (t, 0), flags);
1886 pp_cxx_right_paren (cxx_pp);
1890 pp_cxx_left_paren (cxx_pp);
1891 dump_type (TREE_TYPE (t), flags);
1892 pp_cxx_right_paren (cxx_pp);
1893 pp_cxx_left_paren (cxx_pp);
1894 dump_expr_list (TREE_OPERAND (t, 0), flags);
1895 pp_cxx_right_paren (cxx_pp);
1899 case STATIC_CAST_EXPR:
1900 pp_cxx_identifier (cxx_pp, "static_cast");
1902 case REINTERPRET_CAST_EXPR:
1903 pp_cxx_identifier (cxx_pp, "reinterpret_cast");
1905 case CONST_CAST_EXPR:
1906 pp_cxx_identifier (cxx_pp, "const_cast");
1908 case DYNAMIC_CAST_EXPR:
1909 pp_cxx_identifier (cxx_pp, "dynamic_cast");
1911 pp_cxx_begin_template_argument_list (cxx_pp);
1912 dump_type (TREE_TYPE (t), flags);
1913 pp_cxx_end_template_argument_list (cxx_pp);
1914 pp_cxx_left_paren (cxx_pp);
1915 dump_expr (TREE_OPERAND (t, 0), flags);
1916 pp_cxx_right_paren (cxx_pp);
1920 dump_expr (TREE_OPERAND (t, 0), flags);
1921 pp_cxx_arrow (cxx_pp);
1926 if (TREE_CODE (t) == SIZEOF_EXPR)
1927 pp_cxx_identifier (cxx_pp, "sizeof");
1930 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
1931 pp_cxx_identifier (cxx_pp, "__alignof__");
1933 pp_cxx_whitespace (cxx_pp);
1934 pp_cxx_left_paren (cxx_pp);
1935 if (TYPE_P (TREE_OPERAND (t, 0)))
1936 dump_type (TREE_OPERAND (t, 0), flags);
1938 dump_expr (TREE_OPERAND (t, 0), flags);
1939 pp_cxx_right_paren (cxx_pp);
1944 pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
1945 pp_cxx_whitespace (cxx_pp);
1946 dump_expr (TREE_OPERAND (t, 0), flags);
1950 pp_identifier (cxx_pp, "<unparsed>");
1953 case TRY_CATCH_EXPR:
1954 case WITH_CLEANUP_EXPR:
1955 case CLEANUP_POINT_EXPR:
1956 dump_expr (TREE_OPERAND (t, 0), flags);
1959 case PSEUDO_DTOR_EXPR:
1960 dump_expr (TREE_OPERAND (t, 2), flags);
1961 pp_cxx_dot (cxx_pp);
1962 dump_type (TREE_OPERAND (t, 0), flags);
1963 pp_cxx_colon_colon (cxx_pp);
1964 pp_cxx_complement (cxx_pp);
1965 dump_type (TREE_OPERAND (t, 1), flags);
1968 case TEMPLATE_ID_EXPR:
1969 dump_decl (t, flags);
1974 case STATEMENT_LIST:
1975 /* We don't yet have a way of dumping statements in a
1976 human-readable format. */
1977 pp_string (cxx_pp, "({...})");
1981 pp_string (cxx_pp, "while (1) { ");
1982 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1983 pp_cxx_right_brace (cxx_pp);
1987 pp_string (cxx_pp, "if (");
1988 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1989 pp_string (cxx_pp, ") break; ");
1993 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
1996 case EMPTY_CLASS_EXPR:
1997 dump_type (TREE_TYPE (t), flags);
1998 pp_cxx_left_paren (cxx_pp);
1999 pp_cxx_right_paren (cxx_pp);
2002 case NON_DEPENDENT_EXPR:
2003 dump_expr (TREE_OPERAND (t, 0), flags);
2006 case EXPR_PACK_EXPANSION:
2007 dump_expr (PACK_EXPANSION_PATTERN (t), flags);
2008 pp_cxx_identifier (cxx_pp, "...");
2020 pp_type_specifier_seq (cxx_pp, t);
2024 /* We get here when we want to print a dependent type as an
2025 id-expression, without any disambiguator decoration. */
2026 pp_id_expression (cxx_pp, t);
2029 /* This list is incomplete, but should suffice for now.
2030 It is very important that `sorry' does not call
2031 `report_error_function'. That could cause an infinite loop. */
2033 pp_unsupported_tree (cxx_pp, t);
2034 /* fall through to ERROR_MARK... */
2036 pp_identifier (cxx_pp, "<expression error>");
2042 dump_binary_op (const char *opstring, tree t, int flags)
2044 pp_cxx_left_paren (cxx_pp);
2045 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2046 pp_cxx_whitespace (cxx_pp);
2048 pp_cxx_identifier (cxx_pp, opstring);
2050 pp_identifier (cxx_pp, "<unknown operator>");
2051 pp_cxx_whitespace (cxx_pp);
2052 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2053 pp_cxx_right_paren (cxx_pp);
2057 dump_unary_op (const char *opstring, tree t, int flags)
2059 if (flags & TFF_EXPR_IN_PARENS)
2060 pp_cxx_left_paren (cxx_pp);
2061 pp_cxx_identifier (cxx_pp, opstring);
2062 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2063 if (flags & TFF_EXPR_IN_PARENS)
2064 pp_cxx_right_paren (cxx_pp);
2068 reinit_cxx_pp (void)
2070 pp_clear_output_area (cxx_pp);
2071 pp_base (cxx_pp)->padding = pp_none;
2072 pp_indentation (cxx_pp) = 0;
2073 pp_needs_newline (cxx_pp) = false;
2074 cxx_pp->enclosing_scope = 0;
2078 /* Exported interface to stringifying types, exprs and decls under TFF_*
2082 type_as_string (tree typ, int flags)
2085 dump_type (typ, flags);
2086 return pp_formatted_text (cxx_pp);
2090 expr_as_string (tree decl, int flags)
2093 dump_expr (decl, flags);
2094 return pp_formatted_text (cxx_pp);
2098 decl_as_string (tree decl, int flags)
2101 dump_decl (decl, flags);
2102 return pp_formatted_text (cxx_pp);
2105 /* Generate the three forms of printable names for cxx_printable_name. */
2108 lang_decl_name (tree decl, int v)
2111 return decl_as_string (decl, TFF_DECL_SPECIFIERS);
2114 if (v == 1 && DECL_CLASS_SCOPE_P (decl))
2116 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2117 pp_cxx_colon_colon (cxx_pp);
2120 if (TREE_CODE (decl) == FUNCTION_DECL)
2121 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2123 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2125 return pp_formatted_text (cxx_pp);
2128 /* Return the location of a tree passed to %+ formats. */
2131 location_of (tree t)
2133 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2134 t = DECL_CONTEXT (t);
2135 else if (TYPE_P (t))
2136 t = TYPE_MAIN_DECL (t);
2137 else if (TREE_CODE (t) == OVERLOAD)
2138 t = OVL_FUNCTION (t);
2140 return DECL_SOURCE_LOCATION (t);
2143 /* Now the interfaces from error et al to dump_type et al. Each takes an
2144 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2148 decl_to_string (tree decl, int verbose)
2152 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2153 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2154 flags = TFF_CLASS_KEY_OR_ENUM;
2156 flags |= TFF_DECL_SPECIFIERS;
2157 else if (TREE_CODE (decl) == FUNCTION_DECL)
2158 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2159 flags |= TFF_TEMPLATE_HEADER;
2162 dump_decl (decl, flags);
2163 return pp_formatted_text (cxx_pp);
2167 expr_to_string (tree decl)
2170 dump_expr (decl, 0);
2171 return pp_formatted_text (cxx_pp);
2175 fndecl_to_string (tree fndecl, int verbose)
2179 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2180 | TFF_TEMPLATE_HEADER;
2182 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2184 dump_decl (fndecl, flags);
2185 return pp_formatted_text (cxx_pp);
2190 code_to_string (enum tree_code c)
2192 return tree_code_name [c];
2196 language_to_string (enum languages c)
2203 case lang_cplusplus:
2215 /* Return the proper printed version of a parameter to a C++ function. */
2218 parm_to_string (int p)
2222 pp_string (cxx_pp, "'this'");
2224 pp_decimal_int (cxx_pp, p + 1);
2225 return pp_formatted_text (cxx_pp);
2229 op_to_string (enum tree_code p)
2231 tree id = operator_name_info[(int) p].identifier;
2232 return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2236 type_to_string (tree typ, int verbose)
2240 flags |= TFF_CLASS_KEY_OR_ENUM;
2241 flags |= TFF_TEMPLATE_HEADER;
2244 dump_type (typ, flags);
2245 return pp_formatted_text (cxx_pp);
2249 assop_to_string (enum tree_code p)
2251 tree id = assignment_operator_name_info[(int) p].identifier;
2252 return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2256 args_to_string (tree p, int verbose)
2260 flags |= TFF_CLASS_KEY_OR_ENUM;
2265 if (TYPE_P (TREE_VALUE (p)))
2266 return type_as_string (p, flags);
2269 for (; p; p = TREE_CHAIN (p))
2271 if (TREE_VALUE (p) == null_node)
2272 pp_cxx_identifier (cxx_pp, "NULL");
2274 dump_type (error_type (TREE_VALUE (p)), flags);
2276 pp_separate_with_comma (cxx_pp);
2278 return pp_formatted_text (cxx_pp);
2282 cv_to_string (tree p, int v)
2285 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2286 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2287 return pp_formatted_text (cxx_pp);
2290 /* Langhook for print_error_function. */
2292 cxx_print_error_function (diagnostic_context *context, const char *file)
2294 lhd_print_error_function (context, file);
2295 pp_base_set_prefix (context->printer, file);
2296 maybe_print_instantiation_context (context);
2300 cp_diagnostic_starter (diagnostic_context *context,
2301 diagnostic_info *diagnostic)
2303 diagnostic_report_current_module (context);
2304 cp_print_error_function (context, diagnostic);
2305 maybe_print_instantiation_context (context);
2306 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2310 cp_diagnostic_finalizer (diagnostic_context *context,
2311 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2313 pp_base_destroy_prefix (context->printer);
2316 /* Print current function onto BUFFER, in the process of reporting
2317 a diagnostic message. Called from cp_diagnostic_starter. */
2319 cp_print_error_function (diagnostic_context *context,
2320 diagnostic_info *diagnostic)
2322 if (diagnostic_last_function_changed (context))
2324 const char *old_prefix = context->printer->prefix;
2325 const char *file = LOCATION_FILE (diagnostic->location);
2326 char *new_prefix = file ? file_name_as_prefix (file) : NULL;
2328 pp_base_set_prefix (context->printer, new_prefix);
2330 if (current_function_decl == NULL)
2331 pp_base_string (context->printer, "At global scope:");
2333 pp_printf (context->printer, "In %s %qs:",
2334 function_category (current_function_decl),
2335 cxx_printable_name (current_function_decl, 2));
2336 pp_base_newline (context->printer);
2338 diagnostic_set_last_function (context);
2339 pp_base_destroy_prefix (context->printer);
2340 context->printer->prefix = old_prefix;
2344 /* Returns a description of FUNCTION using standard terminology. */
2346 function_category (tree fn)
2348 if (DECL_FUNCTION_MEMBER_P (fn))
2350 if (DECL_STATIC_FUNCTION_P (fn))
2351 return "static member function";
2352 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2353 return "copy constructor";
2354 else if (DECL_CONSTRUCTOR_P (fn))
2355 return "constructor";
2356 else if (DECL_DESTRUCTOR_P (fn))
2357 return "destructor";
2359 return "member function";
2365 /* Report the full context of a current template instantiation,
2368 print_instantiation_full_context (diagnostic_context *context)
2370 tree p = current_instantiation ();
2371 location_t location = input_location;
2375 if (current_function_decl != TINST_DECL (p)
2376 && current_function_decl != NULL_TREE)
2377 /* We can get here during the processing of some synthesized
2378 method. Then, TINST_DECL (p) will be the function that's causing
2383 if (current_function_decl == TINST_DECL (p))
2384 /* Avoid redundancy with the "In function" line. */;
2386 pp_verbatim (context->printer,
2387 "%s: In instantiation of %qs:\n",
2388 LOCATION_FILE (location),
2389 decl_as_string (TINST_DECL (p),
2390 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2392 location = TINST_LOCATION (p);
2397 print_instantiation_partial_context (context, p, location);
2400 /* Same as above but less verbose. */
2402 print_instantiation_partial_context (diagnostic_context *context,
2403 tree t, location_t loc)
2405 expanded_location xloc;
2406 for (; ; t = TREE_CHAIN (t))
2408 xloc = expand_location (loc);
2411 pp_verbatim (context->printer, "%s:%d: instantiated from %qs\n",
2412 xloc.file, xloc.line,
2413 decl_as_string (TINST_DECL (t),
2414 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2415 loc = TINST_LOCATION (t);
2417 pp_verbatim (context->printer, "%s:%d: instantiated from here",
2418 xloc.file, xloc.line);
2419 pp_base_newline (context->printer);
2422 /* Called from cp_thing to print the template context for an error. */
2424 maybe_print_instantiation_context (diagnostic_context *context)
2426 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2429 record_last_problematic_instantiation ();
2430 print_instantiation_full_context (context);
2433 /* Report the bare minimum context of a template instantiation. */
2435 print_instantiation_context (void)
2437 print_instantiation_partial_context
2438 (global_dc, current_instantiation (), input_location);
2439 diagnostic_flush_buffer (global_dc);
2442 /* Called from output_format -- during diagnostic message processing --
2443 to handle C++ specific format specifier with the following meanings:
2444 %A function argument-list.
2448 %F function declaration.
2449 %L language as used in extern "lang".
2451 %P function parameter whose position is indicated by an integer.
2452 %Q assignment operator.
2456 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2457 int precision, bool wide, bool set_locus, bool verbose)
2461 #define next_tree (t = va_arg (*text->args_ptr, tree))
2462 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2463 #define next_lang va_arg (*text->args_ptr, enum languages)
2464 #define next_int va_arg (*text->args_ptr, int)
2466 if (precision != 0 || wide)
2469 if (text->locus == NULL)
2474 case 'A': result = args_to_string (next_tree, verbose); break;
2475 case 'C': result = code_to_string (next_tcode); break;
2478 tree temp = next_tree;
2480 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
2482 temp = DECL_DEBUG_EXPR (temp);
2485 result = expr_to_string (temp);
2489 result = decl_to_string (temp, verbose);
2492 case 'E': result = expr_to_string (next_tree); break;
2493 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2494 case 'L': result = language_to_string (next_lang); break;
2495 case 'O': result = op_to_string (next_tcode); break;
2496 case 'P': result = parm_to_string (next_int); break;
2497 case 'Q': result = assop_to_string (next_tcode); break;
2498 case 'T': result = type_to_string (next_tree, verbose); break;
2499 case 'V': result = cv_to_string (next_tree, verbose); break;
2505 pp_base_string (pp, result);
2506 if (set_locus && t != NULL)
2507 *text->locus = location_of (t);
2515 /* Callback from cpp_error for PFILE to print diagnostics arising from
2516 interpreting strings. The diagnostic is of type LEVEL; MSG is the
2517 translated message and AP the arguments. */
2520 cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
2521 const char *msg, va_list *ap)
2523 diagnostic_info diagnostic;
2524 diagnostic_t dlevel;
2527 case CPP_DL_WARNING:
2528 case CPP_DL_WARNING_SYSHDR:
2529 dlevel = DK_WARNING;
2531 case CPP_DL_PEDWARN:
2532 dlevel = pedantic_error_kind ();
2543 diagnostic_set_info_translated (&diagnostic, msg, ap,
2544 input_location, dlevel);
2545 report_diagnostic (&diagnostic);
2548 /* Warn about the use of variadic templates when appropriate. */
2550 maybe_warn_variadic_templates (void)
2552 if (!flag_cpp0x && !in_system_header)
2553 /* We really want to suppress this warning in system headers,
2554 because libstdc++ uses variadic templates even when we aren't
2556 pedwarn ("ISO C++ does not include variadic templates");