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 pp_character (cxx_pp, "&*"[TREE_CODE (t) == POINTER_TYPE]);
546 pp_base (cxx_pp)->padding = pp_before;
547 pp_cxx_cv_qualifier_seq (cxx_pp, t);
553 dump_type_prefix (TREE_TYPE (t), flags);
554 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
556 pp_maybe_space (cxx_pp);
557 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
558 pp_cxx_left_paren (cxx_pp);
559 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
560 pp_cxx_colon_colon (cxx_pp);
562 pp_cxx_star (cxx_pp);
563 pp_cxx_cv_qualifier_seq (cxx_pp, t);
564 pp_base (cxx_pp)->padding = pp_before;
567 /* Can only be reached through function pointer -- this would not be
568 correct if FUNCTION_DECLs used it. */
570 dump_type_prefix (TREE_TYPE (t), flags);
571 pp_maybe_space (cxx_pp);
572 pp_cxx_left_paren (cxx_pp);
576 dump_type_prefix (TREE_TYPE (t), flags);
577 pp_maybe_space (cxx_pp);
578 pp_cxx_left_paren (cxx_pp);
579 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
580 pp_cxx_colon_colon (cxx_pp);
584 dump_type_prefix (TREE_TYPE (t), flags);
588 case IDENTIFIER_NODE:
593 case TEMPLATE_TYPE_PARM:
594 case TEMPLATE_TEMPLATE_PARM:
595 case BOUND_TEMPLATE_TEMPLATE_PARM:
606 dump_type (t, flags);
607 pp_base (cxx_pp)->padding = pp_before;
611 pp_unsupported_tree (cxx_pp, t);
614 pp_identifier (cxx_pp, "<typeprefixerror>");
619 /* Dump the suffix of type T, under control of FLAGS. This is the part
620 which appears after the identifier (or function parms). */
623 dump_type_suffix (tree t, int flags)
625 if (TYPE_PTRMEMFUNC_P (t))
626 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
628 switch (TREE_CODE (t))
633 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
634 pp_cxx_right_paren (cxx_pp);
635 dump_type_suffix (TREE_TYPE (t), flags);
638 /* Can only be reached through function pointer. */
643 pp_cxx_right_paren (cxx_pp);
644 arg = TYPE_ARG_TYPES (t);
645 if (TREE_CODE (t) == METHOD_TYPE)
646 arg = TREE_CHAIN (arg);
648 /* Function pointers don't have default args. Not in standard C++,
649 anyway; they may in g++, but we'll just pretend otherwise. */
650 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
652 if (TREE_CODE (t) == METHOD_TYPE)
653 pp_cxx_cv_qualifier_seq
654 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
656 pp_cxx_cv_qualifier_seq(cxx_pp, t);
657 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
658 dump_type_suffix (TREE_TYPE (t), flags);
663 pp_maybe_space (cxx_pp);
664 pp_cxx_left_bracket (cxx_pp);
667 tree dtype = TYPE_DOMAIN (t);
668 tree max = TYPE_MAX_VALUE (dtype);
669 if (host_integerp (max, 0))
670 pp_wide_integer (cxx_pp, tree_low_cst (max, 0) + 1);
671 else if (TREE_CODE (max) == MINUS_EXPR)
672 dump_expr (TREE_OPERAND (max, 0),
673 flags & ~TFF_EXPR_IN_PARENS);
675 dump_expr (fold_build2 (PLUS_EXPR, dtype, max,
676 build_int_cst (dtype, 1)),
677 flags & ~TFF_EXPR_IN_PARENS);
679 pp_cxx_right_bracket (cxx_pp);
680 dump_type_suffix (TREE_TYPE (t), flags);
684 case IDENTIFIER_NODE:
689 case TEMPLATE_TYPE_PARM:
690 case TEMPLATE_TEMPLATE_PARM:
691 case BOUND_TEMPLATE_TEMPLATE_PARM:
705 pp_unsupported_tree (cxx_pp, t);
707 /* Don't mark it here, we should have already done in
714 dump_global_iord (tree t)
716 const char *p = NULL;
718 if (DECL_GLOBAL_CTOR_P (t))
720 else if (DECL_GLOBAL_DTOR_P (t))
725 pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename);
729 dump_simple_decl (tree t, tree type, int flags)
731 if (flags & TFF_DECL_SPECIFIERS)
733 dump_type_prefix (type, flags & ~TFF_UNQUALIFIED_NAME);
734 pp_maybe_space (cxx_pp);
736 if (! (flags & TFF_UNQUALIFIED_NAME)
737 && (!DECL_INITIAL (t)
738 || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
739 dump_scope (CP_DECL_CONTEXT (t), flags);
740 flags &= ~TFF_UNQUALIFIED_NAME;
742 dump_decl (DECL_NAME (t), flags);
744 pp_identifier (cxx_pp, "<anonymous>");
745 if (flags & TFF_DECL_SPECIFIERS)
746 dump_type_suffix (type, flags);
749 /* Dump a human readable string for the decl T under control of FLAGS. */
752 dump_decl (tree t, int flags)
757 switch (TREE_CODE (t))
760 /* Don't say 'typedef class A' */
761 if (DECL_ARTIFICIAL (t))
763 if ((flags & TFF_DECL_SPECIFIERS)
764 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
765 /* Say `class T' not just `T'. */
766 pp_cxx_identifier (cxx_pp, "class");
768 dump_type (TREE_TYPE (t), flags);
771 if (flags & TFF_DECL_SPECIFIERS)
772 pp_cxx_identifier (cxx_pp, "typedef");
773 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
774 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
779 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
781 pp_string (cxx_pp, "vtable for ");
782 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
783 dump_type (DECL_CONTEXT (t), flags);
786 /* Else fall through. */
789 dump_simple_decl (t, TREE_TYPE (t), flags);
793 pp_string (cxx_pp, "<return value> ");
794 dump_simple_decl (t, TREE_TYPE (t), flags);
798 if (flags & TFF_DECL_SPECIFIERS)
799 pp_cxx_declaration (cxx_pp, t);
802 if (! (flags & TFF_UNQUALIFIED_NAME))
803 dump_scope (CP_DECL_CONTEXT (t), flags);
804 flags &= ~TFF_UNQUALIFIED_NAME;
805 if (DECL_NAME (t) == NULL_TREE)
806 pp_identifier (cxx_pp, "<unnamed>");
808 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
813 pp_expression (cxx_pp, t);
817 dump_decl (TREE_OPERAND (t, 0), flags);
818 pp_cxx_left_bracket (cxx_pp);
819 dump_decl (TREE_OPERAND (t, 1), flags);
820 pp_cxx_right_bracket (cxx_pp);
823 /* So that we can do dump_decl on an aggr type. */
827 dump_type (t, flags);
831 /* This is a pseudo destructor call which has not been folded into
832 a PSEUDO_DTOR_EXPR yet. */
833 pp_cxx_complement (cxx_pp);
834 dump_type (TREE_OPERAND (t, 0), flags);
841 /* These special cases are duplicated here so that other functions
842 can feed identifiers to error and get them demangled properly. */
843 case IDENTIFIER_NODE:
844 if (IDENTIFIER_TYPENAME_P (t))
846 pp_cxx_identifier (cxx_pp, "operator");
847 /* Not exactly IDENTIFIER_TYPE_VALUE. */
848 dump_type (TREE_TYPE (t), flags);
852 pp_cxx_tree_identifier (cxx_pp, t);
859 if (DECL_CLASS_SCOPE_P (t))
861 dump_type (DECL_CONTEXT (t), flags);
862 pp_cxx_colon_colon (cxx_pp);
864 else if (DECL_CONTEXT (t))
866 dump_decl (DECL_CONTEXT (t), flags);
867 pp_cxx_colon_colon (cxx_pp);
869 dump_decl (DECL_NAME (t), flags);
873 /* If there's only one function, just treat it like an ordinary
879 if (! DECL_LANG_SPECIFIC (t))
880 pp_identifier (cxx_pp, "<built-in>");
881 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
882 dump_global_iord (t);
884 dump_function_decl (t, flags);
888 dump_template_decl (t, flags);
891 case TEMPLATE_ID_EXPR:
893 tree name = TREE_OPERAND (t, 0);
895 if (is_overloaded_fn (name))
896 name = DECL_NAME (get_first_fn (name));
897 dump_decl (name, flags);
898 pp_cxx_begin_template_argument_list (cxx_pp);
899 if (TREE_OPERAND (t, 1))
900 dump_template_argument_list (TREE_OPERAND (t, 1), flags);
901 pp_cxx_end_template_argument_list (cxx_pp);
906 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
910 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
911 || (DECL_INITIAL (t) &&
912 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
913 dump_simple_decl (t, TREE_TYPE (t), flags);
914 else if (DECL_NAME (t))
915 dump_decl (DECL_NAME (t), flags);
916 else if (DECL_INITIAL (t))
917 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
919 pp_identifier (cxx_pp, "<enumerator>");
923 pp_cxx_identifier (cxx_pp, "using");
924 dump_type (USING_DECL_SCOPE (t), flags);
925 pp_cxx_colon_colon (cxx_pp);
926 dump_decl (DECL_NAME (t), flags);
930 pp_cxx_declaration (cxx_pp, t);
934 dump_decl (BASELINK_FUNCTIONS (t), flags);
937 case NON_DEPENDENT_EXPR:
938 dump_expr (t, flags);
941 case TEMPLATE_TYPE_PARM:
942 if (flags & TFF_DECL_SPECIFIERS)
943 pp_cxx_declaration (cxx_pp, t);
945 pp_type_id (cxx_pp, t);
949 pp_unsupported_tree (cxx_pp, t);
950 /* Fall through to error. */
953 pp_identifier (cxx_pp, "<declaration error>");
958 /* Dump a template declaration T under control of FLAGS. This means the
959 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
962 dump_template_decl (tree t, int flags)
964 tree orig_parms = DECL_TEMPLATE_PARMS (t);
968 if (flags & TFF_TEMPLATE_HEADER)
970 for (parms = orig_parms = nreverse (orig_parms);
972 parms = TREE_CHAIN (parms))
974 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
975 int len = TREE_VEC_LENGTH (inner_parms);
977 pp_cxx_identifier (cxx_pp, "template");
978 pp_cxx_begin_template_argument_list (cxx_pp);
980 /* If we've shown the template prefix, we'd better show the
981 parameters' and decl's type too. */
982 flags |= TFF_DECL_SPECIFIERS;
984 for (i = 0; i < len; i++)
987 pp_separate_with_comma (cxx_pp);
988 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
990 pp_cxx_end_template_argument_list (cxx_pp);
991 pp_cxx_whitespace (cxx_pp);
993 nreverse(orig_parms);
995 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
996 /* Say `template<arg> class TT' not just `template<arg> TT'. */
997 pp_cxx_identifier (cxx_pp, "class");
1000 if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
1001 dump_type (TREE_TYPE (t),
1002 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1003 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1004 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
1005 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1008 gcc_assert (TREE_TYPE (t));
1009 switch (NEXT_CODE (t))
1013 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1016 /* This case can occur with some invalid code. */
1017 dump_type (TREE_TYPE (t),
1018 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1019 | (flags & TFF_DECL_SPECIFIERS
1020 ? TFF_CLASS_KEY_OR_ENUM : 0));
1025 /* Pretty print a function decl. There are several ways we want to print a
1026 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1027 As error can only apply the '#' flag once to give 0 and 1 for V, there
1028 is %D which doesn't print the throw specs, and %F which does. */
1031 dump_function_decl (tree t, int flags)
1035 tree cname = NULL_TREE;
1036 tree template_args = NULL_TREE;
1037 tree template_parms = NULL_TREE;
1038 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1039 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1041 flags &= ~TFF_UNQUALIFIED_NAME;
1042 if (TREE_CODE (t) == TEMPLATE_DECL)
1043 t = DECL_TEMPLATE_RESULT (t);
1045 /* Pretty print template instantiations only. */
1046 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t))
1050 template_args = DECL_TI_ARGS (t);
1051 tmpl = most_general_template (t);
1052 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1054 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1059 fntype = TREE_TYPE (t);
1060 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1062 if (DECL_CLASS_SCOPE_P (t))
1063 cname = DECL_CONTEXT (t);
1064 /* This is for partially instantiated template methods. */
1065 else if (TREE_CODE (fntype) == METHOD_TYPE)
1066 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1068 if (!(flags & TFF_DECL_SPECIFIERS))
1070 else if (DECL_STATIC_FUNCTION_P (t))
1071 pp_cxx_identifier (cxx_pp, "static");
1072 else if (DECL_VIRTUAL_P (t))
1073 pp_cxx_identifier (cxx_pp, "virtual");
1075 /* Print the return type? */
1077 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1078 && !DECL_DESTRUCTOR_P (t);
1080 dump_type_prefix (TREE_TYPE (fntype), flags);
1082 /* Print the function name. */
1083 if (!do_outer_scope)
1087 dump_type (cname, flags);
1088 pp_cxx_colon_colon (cxx_pp);
1091 dump_scope (CP_DECL_CONTEXT (t), flags);
1093 dump_function_name (t, flags);
1095 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1097 dump_parameters (parmtypes, flags);
1099 if (TREE_CODE (fntype) == METHOD_TYPE)
1101 pp_base (cxx_pp)->padding = pp_before;
1102 pp_cxx_cv_qualifier_seq
1103 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1106 if (flags & TFF_EXCEPTION_SPECIFICATION)
1108 pp_base (cxx_pp)->padding = pp_before;
1109 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
1113 dump_type_suffix (TREE_TYPE (fntype), flags);
1116 /* If T is a template instantiation, dump the parameter binding. */
1117 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1119 pp_cxx_whitespace (cxx_pp);
1120 pp_cxx_left_bracket (cxx_pp);
1121 pp_cxx_identifier (cxx_pp, "with");
1122 pp_cxx_whitespace (cxx_pp);
1123 dump_template_bindings (template_parms, template_args);
1124 pp_cxx_right_bracket (cxx_pp);
1128 /* Print a parameter list. If this is for a member function, the
1129 member object ptr (and any other hidden args) should have
1130 already been removed. */
1133 dump_parameters (tree parmtypes, int flags)
1136 pp_cxx_left_paren (cxx_pp);
1138 for (first = 1; parmtypes != void_list_node;
1139 parmtypes = TREE_CHAIN (parmtypes))
1142 pp_separate_with_comma (cxx_pp);
1146 pp_cxx_identifier (cxx_pp, "...");
1149 if (ARGUMENT_PACK_P (TREE_VALUE (parmtypes)))
1151 tree types = ARGUMENT_PACK_ARGS (TREE_VALUE (parmtypes));
1152 int i, len = TREE_VEC_LENGTH (types);
1154 for (i = 0; i < len; ++i)
1157 pp_separate_with_comma (cxx_pp);
1160 dump_type (TREE_VEC_ELT (types, i), flags);
1164 dump_type (TREE_VALUE (parmtypes), flags);
1166 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1168 pp_cxx_whitespace (cxx_pp);
1170 pp_cxx_whitespace (cxx_pp);
1171 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1175 pp_cxx_right_paren (cxx_pp);
1178 /* Print an exception specification. T is the exception specification. */
1181 dump_exception_spec (tree t, int flags)
1185 pp_cxx_identifier (cxx_pp, "throw");
1186 pp_cxx_whitespace (cxx_pp);
1187 pp_cxx_left_paren (cxx_pp);
1188 if (TREE_VALUE (t) != NULL_TREE)
1191 dump_type (TREE_VALUE (t), flags);
1195 pp_separate_with_comma (cxx_pp);
1197 pp_cxx_right_paren (cxx_pp);
1201 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1202 and destructors properly. */
1205 dump_function_name (tree t, int flags)
1207 tree name = DECL_NAME (t);
1209 /* We can get here with a decl that was synthesized by language-
1210 independent machinery (e.g. coverage.c) in which case it won't
1211 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1212 will crash. In this case it is safe just to print out the
1214 if (!DECL_LANG_SPECIFIC (t))
1216 pp_cxx_tree_identifier (cxx_pp, name);
1220 if (TREE_CODE (t) == TEMPLATE_DECL)
1221 t = DECL_TEMPLATE_RESULT (t);
1223 /* Don't let the user see __comp_ctor et al. */
1224 if (DECL_CONSTRUCTOR_P (t)
1225 || DECL_DESTRUCTOR_P (t))
1226 name = constructor_name (DECL_CONTEXT (t));
1228 if (DECL_DESTRUCTOR_P (t))
1230 pp_cxx_complement (cxx_pp);
1231 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1233 else if (DECL_CONV_FN_P (t))
1235 /* This cannot use the hack that the operator's return
1236 type is stashed off of its name because it may be
1237 used for error reporting. In the case of conflicting
1238 declarations, both will have the same name, yet
1239 the types will be different, hence the TREE_TYPE field
1240 of the first name will be clobbered by the second. */
1241 pp_cxx_identifier (cxx_pp, "operator");
1242 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1244 else if (IDENTIFIER_OPNAME_P (name))
1245 pp_cxx_tree_identifier (cxx_pp, name);
1247 dump_decl (name, flags);
1249 if (DECL_TEMPLATE_INFO (t)
1250 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1251 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1252 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1253 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1256 /* Dump the template parameters from the template info INFO under control of
1257 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1258 specialization (partial or complete). For partial specializations we show
1259 the specialized parameter values. For a primary template we show no
1263 dump_template_parms (tree info, int primary, int flags)
1265 tree args = info ? TI_ARGS (info) : NULL_TREE;
1267 if (primary && flags & TFF_TEMPLATE_NAME)
1269 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1270 pp_cxx_begin_template_argument_list (cxx_pp);
1272 /* Be careful only to print things when we have them, so as not
1273 to crash producing error messages. */
1274 if (args && !primary)
1278 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
1279 args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
1281 len = TREE_VEC_LENGTH (args);
1283 for (ix = 0; ix != len; ix++)
1285 tree arg = TREE_VEC_ELT (args, ix);
1287 /* Only print a comma if we know there is an argument coming. In
1288 the case of an empty template argument pack, no actual
1289 argument will be printed. */
1291 && (!ARGUMENT_PACK_P (arg)
1292 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1293 pp_separate_with_comma (cxx_pp);
1296 pp_identifier (cxx_pp, "<template parameter error>");
1298 dump_template_argument (arg, flags);
1303 tree tpl = TI_TEMPLATE (info);
1304 tree parms = DECL_TEMPLATE_PARMS (tpl);
1307 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1308 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1310 for (ix = 0; ix != len; ix++)
1314 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1316 pp_identifier (cxx_pp, "<template parameter error>");
1320 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1323 pp_separate_with_comma (cxx_pp);
1325 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1328 pp_cxx_end_template_argument_list (cxx_pp);
1331 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1332 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1335 dump_call_expr_args (tree t, int flags, bool skipfirst)
1338 call_expr_arg_iterator iter;
1340 pp_cxx_left_paren (cxx_pp);
1341 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1347 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1348 if (more_call_expr_args_p (&iter))
1349 pp_separate_with_comma (cxx_pp);
1352 pp_cxx_right_paren (cxx_pp);
1355 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1356 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1360 dump_aggr_init_expr_args (tree t, int flags, bool skipfirst)
1363 aggr_init_expr_arg_iterator iter;
1365 pp_cxx_left_paren (cxx_pp);
1366 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1372 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1373 if (more_aggr_init_expr_args_p (&iter))
1374 pp_separate_with_comma (cxx_pp);
1377 pp_cxx_right_paren (cxx_pp);
1380 /* Print out a list of initializers (subr of dump_expr). */
1383 dump_expr_list (tree l, int flags)
1387 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1390 pp_separate_with_comma (cxx_pp);
1394 /* Print out a vector of initializers (subr of dump_expr). */
1397 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1399 unsigned HOST_WIDE_INT idx;
1402 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1404 dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1405 if (idx != VEC_length (constructor_elt, v) - 1)
1406 pp_separate_with_comma (cxx_pp);
1411 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1412 function. Resolve it to a close relative -- in the sense of static
1413 type -- variant being overridden. That is close to what was written in
1414 the source code. Subroutine of dump_expr. */
1417 resolve_virtual_fun_from_obj_type_ref (tree ref)
1419 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1420 int index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1421 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1423 fun = TREE_CHAIN (fun);
1428 /* Print out an expression E under control of FLAGS. */
1431 dump_expr (tree t, int flags)
1436 switch (TREE_CODE (t))
1444 case NAMESPACE_DECL:
1447 case IDENTIFIER_NODE:
1448 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1454 pp_constant (cxx_pp, t);
1458 pp_cxx_identifier (cxx_pp, "throw");
1459 dump_expr (TREE_OPERAND (t, 0), flags);
1463 pp_ampersand (cxx_pp);
1464 dump_type (PTRMEM_CST_CLASS (t), flags);
1465 pp_cxx_colon_colon (cxx_pp);
1466 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1470 pp_cxx_left_paren (cxx_pp);
1471 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1472 pp_separate_with_comma (cxx_pp);
1473 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1474 pp_cxx_right_paren (cxx_pp);
1478 pp_cxx_left_paren (cxx_pp);
1479 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1480 pp_string (cxx_pp, " ? ");
1481 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1482 pp_string (cxx_pp, " : ");
1483 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1484 pp_cxx_right_paren (cxx_pp);
1488 if (TREE_HAS_CONSTRUCTOR (t))
1490 pp_cxx_identifier (cxx_pp, "new");
1491 pp_cxx_whitespace (cxx_pp);
1492 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1495 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1498 case AGGR_INIT_EXPR:
1500 tree fn = NULL_TREE;
1502 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
1503 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
1505 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1507 if (DECL_CONSTRUCTOR_P (fn))
1508 dump_type (DECL_CONTEXT (fn), flags);
1513 dump_expr (AGGR_INIT_EXPR_FN (t), 0);
1515 dump_aggr_init_expr_args (t, flags, false);
1520 tree fn = CALL_EXPR_FN (t);
1521 bool skipfirst = false;
1523 if (TREE_CODE (fn) == ADDR_EXPR)
1524 fn = TREE_OPERAND (fn, 0);
1526 /* Nobody is interested in seeing the guts of vcalls. */
1527 if (TREE_CODE (fn) == OBJ_TYPE_REF)
1528 fn = resolve_virtual_fun_from_obj_type_ref (fn);
1530 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1532 tree ob = CALL_EXPR_ARG (t, 0);
1533 if (TREE_CODE (ob) == ADDR_EXPR)
1535 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1538 else if (TREE_CODE (ob) != PARM_DECL
1539 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1541 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1546 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1547 dump_call_expr_args (t, flags, skipfirst);
1553 tree type = TREE_OPERAND (t, 1);
1554 tree init = TREE_OPERAND (t, 2);
1555 if (NEW_EXPR_USE_GLOBAL (t))
1556 pp_cxx_colon_colon (cxx_pp);
1557 pp_cxx_identifier (cxx_pp, "new");
1558 if (TREE_OPERAND (t, 0))
1560 pp_cxx_left_paren (cxx_pp);
1561 dump_expr_list (TREE_OPERAND (t, 0), flags);
1562 pp_cxx_right_paren (cxx_pp);
1563 pp_cxx_whitespace (cxx_pp);
1565 if (TREE_CODE (type) == ARRAY_REF)
1566 type = build_cplus_array_type
1567 (TREE_OPERAND (type, 0),
1568 build_index_type (fold_build2 (MINUS_EXPR, integer_type_node,
1569 TREE_OPERAND (type, 1),
1570 integer_one_node)));
1571 dump_type (type, flags);
1574 pp_cxx_left_paren (cxx_pp);
1575 if (TREE_CODE (init) == TREE_LIST)
1576 dump_expr_list (init, flags);
1577 else if (init == void_zero_node)
1578 /* This representation indicates an empty initializer,
1579 e.g.: "new int()". */
1582 dump_expr (init, flags);
1583 pp_cxx_right_paren (cxx_pp);
1589 /* Note that this only works for G++ target exprs. If somebody
1590 builds a general TARGET_EXPR, there's no way to represent that
1591 it initializes anything other that the parameter slot for the
1592 default argument. Note we may have cleared out the first
1593 operand in expand_expr, so don't go killing ourselves. */
1594 if (TREE_OPERAND (t, 1))
1595 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1603 case TRUNC_DIV_EXPR:
1604 case TRUNC_MOD_EXPR:
1612 case TRUTH_ANDIF_EXPR:
1613 case TRUTH_ORIF_EXPR:
1620 case EXACT_DIV_EXPR:
1621 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1625 case FLOOR_DIV_EXPR:
1626 case ROUND_DIV_EXPR:
1628 dump_binary_op ("/", t, flags);
1632 case FLOOR_MOD_EXPR:
1633 case ROUND_MOD_EXPR:
1634 dump_binary_op ("%", t, flags);
1639 tree ob = TREE_OPERAND (t, 0);
1640 if (TREE_CODE (ob) == INDIRECT_REF)
1642 ob = TREE_OPERAND (ob, 0);
1643 if (TREE_CODE (ob) != PARM_DECL
1645 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1647 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1648 pp_cxx_arrow (cxx_pp);
1653 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1654 pp_cxx_dot (cxx_pp);
1656 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1661 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1662 pp_cxx_left_bracket (cxx_pp);
1663 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1664 pp_cxx_right_bracket (cxx_pp);
1667 case UNARY_PLUS_EXPR:
1668 dump_unary_op ("+", t, flags);
1672 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1673 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1674 /* An ADDR_EXPR can have reference type. In that case, we
1675 shouldn't print the `&' doing so indicates to the user
1676 that the expression has pointer type. */
1678 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1679 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1680 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1681 dump_unary_op ("&&", t, flags);
1683 dump_unary_op ("&", t, flags);
1687 if (TREE_HAS_CONSTRUCTOR (t))
1689 t = TREE_OPERAND (t, 0);
1690 gcc_assert (TREE_CODE (t) == CALL_EXPR);
1691 dump_expr (CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
1692 dump_call_expr_args (t, flags, true);
1696 if (TREE_OPERAND (t,0) != NULL_TREE
1697 && TREE_TYPE (TREE_OPERAND (t, 0))
1698 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1699 dump_expr (TREE_OPERAND (t, 0), flags);
1701 dump_unary_op ("*", t, flags);
1707 case TRUTH_NOT_EXPR:
1708 case PREDECREMENT_EXPR:
1709 case PREINCREMENT_EXPR:
1710 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1713 case POSTDECREMENT_EXPR:
1714 case POSTINCREMENT_EXPR:
1715 pp_cxx_left_paren (cxx_pp);
1716 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1717 pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1718 pp_cxx_right_paren (cxx_pp);
1721 case NON_LVALUE_EXPR:
1722 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1723 should be another level of INDIRECT_REF so that I don't have to do
1725 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1727 tree next = TREE_TYPE (TREE_TYPE (t));
1729 while (TREE_CODE (next) == POINTER_TYPE)
1730 next = TREE_TYPE (next);
1732 if (TREE_CODE (next) == FUNCTION_TYPE)
1734 if (flags & TFF_EXPR_IN_PARENS)
1735 pp_cxx_left_paren (cxx_pp);
1736 pp_cxx_star (cxx_pp);
1737 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1738 if (flags & TFF_EXPR_IN_PARENS)
1739 pp_cxx_right_paren (cxx_pp);
1742 /* Else fall through. */
1744 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1750 tree op = TREE_OPERAND (t, 0);
1752 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1754 /* It is a cast, but we cannot tell whether it is a
1755 reinterpret or static cast. Use the C style notation. */
1756 if (flags & TFF_EXPR_IN_PARENS)
1757 pp_cxx_left_paren (cxx_pp);
1758 pp_cxx_left_paren (cxx_pp);
1759 dump_type (TREE_TYPE (t), flags);
1760 pp_cxx_right_paren (cxx_pp);
1761 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1762 if (flags & TFF_EXPR_IN_PARENS)
1763 pp_cxx_right_paren (cxx_pp);
1766 dump_expr (op, flags);
1771 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1773 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1775 if (integer_zerop (idx))
1777 /* A NULL pointer-to-member constant. */
1778 pp_cxx_left_paren (cxx_pp);
1779 pp_cxx_left_paren (cxx_pp);
1780 dump_type (TREE_TYPE (t), flags);
1781 pp_cxx_right_paren (cxx_pp);
1782 pp_character (cxx_pp, '0');
1783 pp_cxx_right_paren (cxx_pp);
1786 else if (host_integerp (idx, 0))
1789 unsigned HOST_WIDE_INT n;
1791 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1792 t = TYPE_METHOD_BASETYPE (t);
1793 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1795 n = tree_low_cst (idx, 0);
1797 /* Map vtable index back one, to allow for the null pointer to
1801 while (n > 0 && virtuals)
1804 virtuals = TREE_CHAIN (virtuals);
1808 dump_expr (BV_FN (virtuals),
1809 flags | TFF_EXPR_IN_PARENS);
1814 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
1816 dump_type (TREE_TYPE (t), 0);
1817 pp_cxx_left_paren (cxx_pp);
1818 pp_cxx_right_paren (cxx_pp);
1822 pp_cxx_left_brace (cxx_pp);
1823 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
1824 pp_cxx_right_brace (cxx_pp);
1831 tree ob = TREE_OPERAND (t, 0);
1832 if (is_dummy_object (ob))
1834 t = TREE_OPERAND (t, 1);
1835 if (TREE_CODE (t) == FUNCTION_DECL)
1837 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1838 else if (BASELINK_P (t))
1839 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1840 flags | TFF_EXPR_IN_PARENS);
1842 dump_decl (t, flags);
1846 if (TREE_CODE (ob) == INDIRECT_REF)
1848 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1849 pp_cxx_arrow (cxx_pp);
1850 pp_cxx_star (cxx_pp);
1854 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1855 pp_cxx_dot (cxx_pp);
1856 pp_cxx_star (cxx_pp);
1858 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1863 case TEMPLATE_PARM_INDEX:
1864 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1868 pp_expression (cxx_pp, t);
1872 if (TREE_OPERAND (t, 0) == NULL_TREE
1873 || TREE_CHAIN (TREE_OPERAND (t, 0)))
1875 dump_type (TREE_TYPE (t), flags);
1876 pp_cxx_left_paren (cxx_pp);
1877 dump_expr_list (TREE_OPERAND (t, 0), flags);
1878 pp_cxx_right_paren (cxx_pp);
1882 pp_cxx_left_paren (cxx_pp);
1883 dump_type (TREE_TYPE (t), flags);
1884 pp_cxx_right_paren (cxx_pp);
1885 pp_cxx_left_paren (cxx_pp);
1886 dump_expr_list (TREE_OPERAND (t, 0), flags);
1887 pp_cxx_right_paren (cxx_pp);
1891 case STATIC_CAST_EXPR:
1892 pp_cxx_identifier (cxx_pp, "static_cast");
1894 case REINTERPRET_CAST_EXPR:
1895 pp_cxx_identifier (cxx_pp, "reinterpret_cast");
1897 case CONST_CAST_EXPR:
1898 pp_cxx_identifier (cxx_pp, "const_cast");
1900 case DYNAMIC_CAST_EXPR:
1901 pp_cxx_identifier (cxx_pp, "dynamic_cast");
1903 pp_cxx_begin_template_argument_list (cxx_pp);
1904 dump_type (TREE_TYPE (t), flags);
1905 pp_cxx_end_template_argument_list (cxx_pp);
1906 pp_cxx_left_paren (cxx_pp);
1907 dump_expr (TREE_OPERAND (t, 0), flags);
1908 pp_cxx_right_paren (cxx_pp);
1912 dump_expr (TREE_OPERAND (t, 0), flags);
1913 pp_cxx_arrow (cxx_pp);
1918 if (TREE_CODE (t) == SIZEOF_EXPR)
1919 pp_cxx_identifier (cxx_pp, "sizeof");
1922 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
1923 pp_cxx_identifier (cxx_pp, "__alignof__");
1925 pp_cxx_whitespace (cxx_pp);
1926 pp_cxx_left_paren (cxx_pp);
1927 if (TYPE_P (TREE_OPERAND (t, 0)))
1928 dump_type (TREE_OPERAND (t, 0), flags);
1930 dump_expr (TREE_OPERAND (t, 0), flags);
1931 pp_cxx_right_paren (cxx_pp);
1936 pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
1937 pp_cxx_whitespace (cxx_pp);
1938 dump_expr (TREE_OPERAND (t, 0), flags);
1942 pp_identifier (cxx_pp, "<unparsed>");
1945 case TRY_CATCH_EXPR:
1946 case WITH_CLEANUP_EXPR:
1947 case CLEANUP_POINT_EXPR:
1948 dump_expr (TREE_OPERAND (t, 0), flags);
1951 case PSEUDO_DTOR_EXPR:
1952 dump_expr (TREE_OPERAND (t, 2), flags);
1953 pp_cxx_dot (cxx_pp);
1954 dump_type (TREE_OPERAND (t, 0), flags);
1955 pp_cxx_colon_colon (cxx_pp);
1956 pp_cxx_complement (cxx_pp);
1957 dump_type (TREE_OPERAND (t, 1), flags);
1960 case TEMPLATE_ID_EXPR:
1961 dump_decl (t, flags);
1966 case STATEMENT_LIST:
1967 /* We don't yet have a way of dumping statements in a
1968 human-readable format. */
1969 pp_string (cxx_pp, "({...})");
1973 pp_string (cxx_pp, "while (1) { ");
1974 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1975 pp_cxx_right_brace (cxx_pp);
1979 pp_string (cxx_pp, "if (");
1980 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1981 pp_string (cxx_pp, ") break; ");
1985 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
1988 case EMPTY_CLASS_EXPR:
1989 dump_type (TREE_TYPE (t), flags);
1990 pp_cxx_left_paren (cxx_pp);
1991 pp_cxx_right_paren (cxx_pp);
1994 case NON_DEPENDENT_EXPR:
1995 dump_expr (TREE_OPERAND (t, 0), flags);
1998 case EXPR_PACK_EXPANSION:
1999 dump_expr (PACK_EXPANSION_PATTERN (t), flags);
2000 pp_cxx_identifier (cxx_pp, "...");
2012 pp_type_specifier_seq (cxx_pp, t);
2016 /* We get here when we want to print a dependent type as an
2017 id-expression, without any disambiguator decoration. */
2018 pp_id_expression (cxx_pp, t);
2021 /* This list is incomplete, but should suffice for now.
2022 It is very important that `sorry' does not call
2023 `report_error_function'. That could cause an infinite loop. */
2025 pp_unsupported_tree (cxx_pp, t);
2026 /* fall through to ERROR_MARK... */
2028 pp_identifier (cxx_pp, "<expression error>");
2034 dump_binary_op (const char *opstring, tree t, int flags)
2036 pp_cxx_left_paren (cxx_pp);
2037 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2038 pp_cxx_whitespace (cxx_pp);
2040 pp_cxx_identifier (cxx_pp, opstring);
2042 pp_identifier (cxx_pp, "<unknown operator>");
2043 pp_cxx_whitespace (cxx_pp);
2044 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2045 pp_cxx_right_paren (cxx_pp);
2049 dump_unary_op (const char *opstring, tree t, int flags)
2051 if (flags & TFF_EXPR_IN_PARENS)
2052 pp_cxx_left_paren (cxx_pp);
2053 pp_cxx_identifier (cxx_pp, opstring);
2054 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2055 if (flags & TFF_EXPR_IN_PARENS)
2056 pp_cxx_right_paren (cxx_pp);
2060 reinit_cxx_pp (void)
2062 pp_clear_output_area (cxx_pp);
2063 pp_base (cxx_pp)->padding = pp_none;
2064 pp_indentation (cxx_pp) = 0;
2065 pp_needs_newline (cxx_pp) = false;
2066 cxx_pp->enclosing_scope = 0;
2070 /* Exported interface to stringifying types, exprs and decls under TFF_*
2074 type_as_string (tree typ, int flags)
2077 dump_type (typ, flags);
2078 return pp_formatted_text (cxx_pp);
2082 expr_as_string (tree decl, int flags)
2085 dump_expr (decl, flags);
2086 return pp_formatted_text (cxx_pp);
2090 decl_as_string (tree decl, int flags)
2093 dump_decl (decl, flags);
2094 return pp_formatted_text (cxx_pp);
2097 /* Generate the three forms of printable names for cxx_printable_name. */
2100 lang_decl_name (tree decl, int v)
2103 return decl_as_string (decl, TFF_DECL_SPECIFIERS);
2106 if (v == 1 && DECL_CLASS_SCOPE_P (decl))
2108 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2109 pp_cxx_colon_colon (cxx_pp);
2112 if (TREE_CODE (decl) == FUNCTION_DECL)
2113 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2115 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2117 return pp_formatted_text (cxx_pp);
2120 /* Return the location of a tree passed to %+ formats. */
2123 location_of (tree t)
2125 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2126 t = DECL_CONTEXT (t);
2127 else if (TYPE_P (t))
2128 t = TYPE_MAIN_DECL (t);
2129 else if (TREE_CODE (t) == OVERLOAD)
2130 t = OVL_FUNCTION (t);
2132 return DECL_SOURCE_LOCATION (t);
2135 /* Now the interfaces from error et al to dump_type et al. Each takes an
2136 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2140 decl_to_string (tree decl, int verbose)
2144 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2145 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2146 flags = TFF_CLASS_KEY_OR_ENUM;
2148 flags |= TFF_DECL_SPECIFIERS;
2149 else if (TREE_CODE (decl) == FUNCTION_DECL)
2150 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2151 flags |= TFF_TEMPLATE_HEADER;
2154 dump_decl (decl, flags);
2155 return pp_formatted_text (cxx_pp);
2159 expr_to_string (tree decl)
2162 dump_expr (decl, 0);
2163 return pp_formatted_text (cxx_pp);
2167 fndecl_to_string (tree fndecl, int verbose)
2171 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2172 | TFF_TEMPLATE_HEADER;
2174 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2176 dump_decl (fndecl, flags);
2177 return pp_formatted_text (cxx_pp);
2182 code_to_string (enum tree_code c)
2184 return tree_code_name [c];
2188 language_to_string (enum languages c)
2195 case lang_cplusplus:
2207 /* Return the proper printed version of a parameter to a C++ function. */
2210 parm_to_string (int p)
2214 pp_string (cxx_pp, "'this'");
2216 pp_decimal_int (cxx_pp, p + 1);
2217 return pp_formatted_text (cxx_pp);
2221 op_to_string (enum tree_code p)
2223 tree id = operator_name_info[(int) p].identifier;
2224 return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2228 type_to_string (tree typ, int verbose)
2232 flags |= TFF_CLASS_KEY_OR_ENUM;
2233 flags |= TFF_TEMPLATE_HEADER;
2236 dump_type (typ, flags);
2237 return pp_formatted_text (cxx_pp);
2241 assop_to_string (enum tree_code p)
2243 tree id = assignment_operator_name_info[(int) p].identifier;
2244 return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2248 args_to_string (tree p, int verbose)
2252 flags |= TFF_CLASS_KEY_OR_ENUM;
2257 if (TYPE_P (TREE_VALUE (p)))
2258 return type_as_string (p, flags);
2261 for (; p; p = TREE_CHAIN (p))
2263 if (TREE_VALUE (p) == null_node)
2264 pp_cxx_identifier (cxx_pp, "NULL");
2266 dump_type (error_type (TREE_VALUE (p)), flags);
2268 pp_separate_with_comma (cxx_pp);
2270 return pp_formatted_text (cxx_pp);
2274 cv_to_string (tree p, int v)
2277 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2278 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2279 return pp_formatted_text (cxx_pp);
2282 /* Langhook for print_error_function. */
2284 cxx_print_error_function (diagnostic_context *context, const char *file)
2286 lhd_print_error_function (context, file);
2287 pp_base_set_prefix (context->printer, file);
2288 maybe_print_instantiation_context (context);
2292 cp_diagnostic_starter (diagnostic_context *context,
2293 diagnostic_info *diagnostic)
2295 diagnostic_report_current_module (context);
2296 cp_print_error_function (context, diagnostic);
2297 maybe_print_instantiation_context (context);
2298 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2302 cp_diagnostic_finalizer (diagnostic_context *context,
2303 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2305 pp_base_destroy_prefix (context->printer);
2308 /* Print current function onto BUFFER, in the process of reporting
2309 a diagnostic message. Called from cp_diagnostic_starter. */
2311 cp_print_error_function (diagnostic_context *context,
2312 diagnostic_info *diagnostic)
2314 if (diagnostic_last_function_changed (context))
2316 const char *old_prefix = context->printer->prefix;
2317 const char *file = LOCATION_FILE (diagnostic->location);
2318 char *new_prefix = file ? file_name_as_prefix (file) : NULL;
2320 pp_base_set_prefix (context->printer, new_prefix);
2322 if (current_function_decl == NULL)
2323 pp_base_string (context->printer, "At global scope:");
2325 pp_printf (context->printer, "In %s %qs:",
2326 function_category (current_function_decl),
2327 cxx_printable_name (current_function_decl, 2));
2328 pp_base_newline (context->printer);
2330 diagnostic_set_last_function (context);
2331 pp_base_destroy_prefix (context->printer);
2332 context->printer->prefix = old_prefix;
2336 /* Returns a description of FUNCTION using standard terminology. */
2338 function_category (tree fn)
2340 if (DECL_FUNCTION_MEMBER_P (fn))
2342 if (DECL_STATIC_FUNCTION_P (fn))
2343 return "static member function";
2344 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2345 return "copy constructor";
2346 else if (DECL_CONSTRUCTOR_P (fn))
2347 return "constructor";
2348 else if (DECL_DESTRUCTOR_P (fn))
2349 return "destructor";
2351 return "member function";
2357 /* Report the full context of a current template instantiation,
2360 print_instantiation_full_context (diagnostic_context *context)
2362 tree p = current_instantiation ();
2363 location_t location = input_location;
2367 if (current_function_decl != TINST_DECL (p)
2368 && current_function_decl != NULL_TREE)
2369 /* We can get here during the processing of some synthesized
2370 method. Then, TINST_DECL (p) will be the function that's causing
2375 if (current_function_decl == TINST_DECL (p))
2376 /* Avoid redundancy with the "In function" line. */;
2378 pp_verbatim (context->printer,
2379 "%s: In instantiation of %qs:\n",
2380 LOCATION_FILE (location),
2381 decl_as_string (TINST_DECL (p),
2382 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2384 location = TINST_LOCATION (p);
2389 print_instantiation_partial_context (context, p, location);
2392 /* Same as above but less verbose. */
2394 print_instantiation_partial_context (diagnostic_context *context,
2395 tree t, location_t loc)
2397 expanded_location xloc;
2398 for (; ; t = TREE_CHAIN (t))
2400 xloc = expand_location (loc);
2403 pp_verbatim (context->printer, "%s:%d: instantiated from %qs\n",
2404 xloc.file, xloc.line,
2405 decl_as_string (TINST_DECL (t),
2406 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2407 loc = TINST_LOCATION (t);
2409 pp_verbatim (context->printer, "%s:%d: instantiated from here",
2410 xloc.file, xloc.line);
2411 pp_base_newline (context->printer);
2414 /* Called from cp_thing to print the template context for an error. */
2416 maybe_print_instantiation_context (diagnostic_context *context)
2418 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2421 record_last_problematic_instantiation ();
2422 print_instantiation_full_context (context);
2425 /* Report the bare minimum context of a template instantiation. */
2427 print_instantiation_context (void)
2429 print_instantiation_partial_context
2430 (global_dc, current_instantiation (), input_location);
2431 diagnostic_flush_buffer (global_dc);
2434 /* Called from output_format -- during diagnostic message processing --
2435 to handle C++ specific format specifier with the following meanings:
2436 %A function argument-list.
2440 %F function declaration.
2441 %L language as used in extern "lang".
2443 %P function parameter whose position is indicated by an integer.
2444 %Q assignment operator.
2448 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2449 int precision, bool wide, bool set_locus, bool verbose)
2453 #define next_tree (t = va_arg (*text->args_ptr, tree))
2454 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2455 #define next_lang va_arg (*text->args_ptr, enum languages)
2456 #define next_int va_arg (*text->args_ptr, int)
2458 if (precision != 0 || wide)
2461 if (text->locus == NULL)
2466 case 'A': result = args_to_string (next_tree, verbose); break;
2467 case 'C': result = code_to_string (next_tcode); break;
2470 tree temp = next_tree;
2472 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
2474 temp = DECL_DEBUG_EXPR (temp);
2477 result = expr_to_string (temp);
2481 result = decl_to_string (temp, verbose);
2484 case 'E': result = expr_to_string (next_tree); break;
2485 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2486 case 'L': result = language_to_string (next_lang); break;
2487 case 'O': result = op_to_string (next_tcode); break;
2488 case 'P': result = parm_to_string (next_int); break;
2489 case 'Q': result = assop_to_string (next_tcode); break;
2490 case 'T': result = type_to_string (next_tree, verbose); break;
2491 case 'V': result = cv_to_string (next_tree, verbose); break;
2497 pp_base_string (pp, result);
2498 if (set_locus && t != NULL)
2499 *text->locus = location_of (t);
2507 /* Callback from cpp_error for PFILE to print diagnostics arising from
2508 interpreting strings. The diagnostic is of type LEVEL; MSG is the
2509 translated message and AP the arguments. */
2512 cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
2513 const char *msg, va_list *ap)
2515 diagnostic_info diagnostic;
2516 diagnostic_t dlevel;
2519 case CPP_DL_WARNING:
2520 case CPP_DL_WARNING_SYSHDR:
2521 dlevel = DK_WARNING;
2523 case CPP_DL_PEDWARN:
2524 dlevel = pedantic_error_kind ();
2535 diagnostic_set_info_translated (&diagnostic, msg, ap,
2536 input_location, dlevel);
2537 report_diagnostic (&diagnostic);
2540 /* Warn about the use of variadic templates when appropriate. */
2542 maybe_warn_variadic_templates (void)
2544 if (!flag_cpp0x && !in_system_header)
2545 /* We really want to suppress this warning in system headers,
2546 because libstdc++ uses variadic templates even when we aren't
2548 pedwarn ("ISO C++ does not include variadic templates");