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 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_expr_list (tree
, int);
70 static void dump_global_iord (tree
);
71 static void dump_parameters (tree
, int);
72 static void dump_exception_spec (tree
, int);
73 static void dump_template_argument (tree
, int);
74 static void dump_template_argument_list (tree
, int);
75 static void dump_template_parameter (tree
, int);
76 static void dump_template_bindings (tree
, tree
);
77 static void dump_scope (tree
, int);
78 static void dump_template_parms (tree
, int, int);
80 static const char *function_category (tree
);
81 static void maybe_print_instantiation_context (diagnostic_context
*);
82 static void print_instantiation_full_context (diagnostic_context
*);
83 static void print_instantiation_partial_context (diagnostic_context
*,
85 static void cp_diagnostic_starter (diagnostic_context
*, diagnostic_info
*);
86 static void cp_diagnostic_finalizer (diagnostic_context
*, diagnostic_info
*);
87 static void cp_print_error_function (diagnostic_context
*, diagnostic_info
*);
89 static bool cp_printer (pretty_printer
*, text_info
*, const char *,
90 int, bool, bool, bool);
91 static location_t
location_of (tree
);
96 diagnostic_starter (global_dc
) = cp_diagnostic_starter
;
97 diagnostic_finalizer (global_dc
) = cp_diagnostic_finalizer
;
98 diagnostic_format_decoder (global_dc
) = cp_printer
;
100 pp_construct (pp_base (cxx_pp
), NULL
, 0);
101 pp_cxx_pretty_printer_init (cxx_pp
);
104 /* Dump a scope, if deemed necessary. */
107 dump_scope (tree scope
, int flags
)
109 int f
= ~TFF_RETURN_TYPE
& (flags
& (TFF_SCOPE
| TFF_CHASE_TYPEDEF
));
111 if (scope
== NULL_TREE
)
114 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
116 if (scope
!= global_namespace
)
118 dump_decl (scope
, f
);
119 pp_cxx_colon_colon (cxx_pp
);
122 else if (AGGREGATE_TYPE_P (scope
))
124 dump_type (scope
, f
);
125 pp_cxx_colon_colon (cxx_pp
);
127 else if ((flags
& TFF_SCOPE
) && TREE_CODE (scope
) == FUNCTION_DECL
)
129 dump_function_decl (scope
, f
);
130 pp_cxx_colon_colon (cxx_pp
);
134 /* Dump the template ARGument under control of FLAGS. */
137 dump_template_argument (tree arg
, int flags
)
139 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
140 dump_type (arg
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
142 dump_expr (arg
, (flags
| TFF_EXPR_IN_PARENS
) & ~TFF_CLASS_KEY_OR_ENUM
);
145 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
149 dump_template_argument_list (tree args
, int flags
)
151 int n
= TREE_VEC_LENGTH (args
);
155 for (i
= 0; i
< n
; ++i
)
158 pp_separate_with_comma (cxx_pp
);
159 dump_template_argument (TREE_VEC_ELT (args
, i
), flags
);
164 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
167 dump_template_parameter (tree parm
, int flags
)
169 tree p
= TREE_VALUE (parm
);
170 tree a
= TREE_PURPOSE (parm
);
172 if (TREE_CODE (p
) == TYPE_DECL
)
174 if (flags
& TFF_DECL_SPECIFIERS
)
176 pp_cxx_identifier (cxx_pp
, "class");
178 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (p
));
180 else if (DECL_NAME (p
))
181 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (p
));
183 pp_cxx_canonical_template_parameter (cxx_pp
, TREE_TYPE (p
));
186 dump_decl (p
, flags
| TFF_DECL_SPECIFIERS
);
188 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && a
!= NULL_TREE
)
190 pp_cxx_whitespace (cxx_pp
);
192 pp_cxx_whitespace (cxx_pp
);
193 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
194 dump_type (a
, flags
& ~TFF_CHASE_TYPEDEF
);
196 dump_expr (a
, flags
| TFF_EXPR_IN_PARENS
);
200 /* Dump, under control of FLAGS, a template-parameter-list binding.
201 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
205 dump_template_bindings (tree parms
, tree args
)
211 tree p
= TREE_VALUE (parms
);
212 int lvl
= TMPL_PARMS_DEPTH (parms
);
216 for (i
= 0; i
< TREE_VEC_LENGTH (p
); ++i
)
218 tree arg
= NULL_TREE
;
220 /* Don't crash if we had an invalid argument list. */
221 if (TMPL_ARGS_DEPTH (args
) >= lvl
)
223 tree lvl_args
= TMPL_ARGS_LEVEL (args
, lvl
);
224 if (NUM_TMPL_ARGS (lvl_args
) > arg_idx
)
225 arg
= TREE_VEC_ELT (lvl_args
, arg_idx
);
229 pp_separate_with_comma (cxx_pp
);
230 dump_template_parameter (TREE_VEC_ELT (p
, i
), TFF_PLAIN_IDENTIFIER
);
231 pp_cxx_whitespace (cxx_pp
);
233 pp_cxx_whitespace (cxx_pp
);
235 dump_template_argument (arg
, TFF_PLAIN_IDENTIFIER
);
237 pp_identifier (cxx_pp
, "<missing>");
243 parms
= TREE_CHAIN (parms
);
247 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
251 dump_type (tree t
, int flags
)
256 if (TYPE_PTRMEMFUNC_P (t
))
259 switch (TREE_CODE (t
))
262 pp_identifier (cxx_pp
, "<unresolved overloaded function type>");
266 /* A list of function parms. */
267 dump_parameters (t
, flags
);
270 case IDENTIFIER_NODE
:
271 pp_cxx_tree_identifier (cxx_pp
, t
);
275 dump_type (BINFO_TYPE (t
), flags
);
281 dump_aggr_type (t
, flags
);
285 if (flags
& TFF_CHASE_TYPEDEF
)
287 dump_type (DECL_ORIGINAL_TYPE (t
)
288 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
), flags
);
291 /* Else fall through. */
295 dump_decl (t
, flags
& ~TFF_DECL_SPECIFIERS
);
304 pp_type_specifier_seq (cxx_pp
, t
);
307 case TEMPLATE_TEMPLATE_PARM
:
308 /* For parameters inside template signature. */
309 if (TYPE_IDENTIFIER (t
))
310 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (t
));
312 pp_cxx_canonical_template_parameter (cxx_pp
, t
);
315 case BOUND_TEMPLATE_TEMPLATE_PARM
:
317 tree args
= TYPE_TI_ARGS (t
);
318 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
319 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (t
));
320 pp_cxx_begin_template_argument_list (cxx_pp
);
321 dump_template_argument_list (args
, flags
);
322 pp_cxx_end_template_argument_list (cxx_pp
);
326 case TEMPLATE_TYPE_PARM
:
327 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
328 if (TYPE_IDENTIFIER (t
))
329 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (t
));
331 pp_cxx_canonical_template_parameter
332 (cxx_pp
, TEMPLATE_TYPE_PARM_INDEX (t
));
335 /* This is not always necessary for pointers and such, but doing this
336 reduces code size. */
345 dump_type_prefix (t
, flags
);
346 dump_type_suffix (t
, flags
);
350 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
351 pp_cxx_identifier (cxx_pp
,
352 TYPENAME_IS_ENUM_P (t
) ? "enum"
353 : TYPENAME_IS_CLASS_P (t
) ? "class"
355 dump_typename (t
, flags
);
358 case UNBOUND_CLASS_TEMPLATE
:
359 dump_type (TYPE_CONTEXT (t
), flags
);
360 pp_cxx_colon_colon (cxx_pp
);
361 pp_cxx_identifier (cxx_pp
, "template");
362 dump_type (DECL_NAME (TYPE_NAME (t
)), flags
);
366 pp_cxx_identifier (cxx_pp
, "__typeof__");
367 pp_cxx_whitespace (cxx_pp
);
368 pp_cxx_left_paren (cxx_pp
);
369 dump_expr (TYPEOF_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
370 pp_cxx_right_paren (cxx_pp
);
374 pp_unsupported_tree (cxx_pp
, t
);
375 /* Fall through to error. */
378 pp_identifier (cxx_pp
, "<type error>");
383 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
387 dump_typename (tree t
, int flags
)
389 tree ctx
= TYPE_CONTEXT (t
);
391 if (TREE_CODE (ctx
) == TYPENAME_TYPE
)
392 dump_typename (ctx
, flags
);
394 dump_type (ctx
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
395 pp_cxx_colon_colon (cxx_pp
);
396 dump_decl (TYPENAME_TYPE_FULLNAME (t
), flags
);
399 /* Return the name of the supplied aggregate, or enumeral type. */
402 class_key_or_enum_as_string (tree t
)
404 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
406 else if (TREE_CODE (t
) == UNION_TYPE
)
408 else if (TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_DECLARED_CLASS (t
))
414 /* Print out a class declaration T under the control of FLAGS,
415 in the form `class foo'. */
418 dump_aggr_type (tree t
, int flags
)
421 const char *variety
= class_key_or_enum_as_string (t
);
425 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
427 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
428 pp_cxx_identifier (cxx_pp
, variety
);
430 if (flags
& TFF_CHASE_TYPEDEF
)
431 t
= TYPE_MAIN_VARIANT (t
);
433 name
= TYPE_NAME (t
);
437 typdef
= !DECL_ARTIFICIAL (name
);
438 tmplate
= !typdef
&& TREE_CODE (t
) != ENUMERAL_TYPE
439 && TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_TEMPLATE_INFO (t
)
440 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t
)) != TEMPLATE_DECL
441 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)));
442 dump_scope (CP_DECL_CONTEXT (name
), flags
| TFF_SCOPE
);
445 /* Because the template names are mangled, we have to locate
446 the most general template, and use that name. */
447 tree tpl
= CLASSTYPE_TI_TEMPLATE (t
);
449 while (DECL_TEMPLATE_INFO (tpl
))
450 tpl
= DECL_TI_TEMPLATE (tpl
);
453 name
= DECL_NAME (name
);
456 if (name
== 0 || ANON_AGGRNAME_P (name
))
458 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
459 pp_identifier (cxx_pp
, "<anonymous>");
461 pp_printf (pp_base (cxx_pp
), "<anonymous %s>", variety
);
464 pp_cxx_tree_identifier (cxx_pp
, name
);
466 dump_template_parms (TYPE_TEMPLATE_INFO (t
),
467 !CLASSTYPE_USE_TEMPLATE (t
),
468 flags
& ~TFF_TEMPLATE_HEADER
);
471 /* Dump into the obstack the initial part of the output for a given type.
472 This is necessary when dealing with things like functions returning
475 return type of `int (* fee ())()': pointer -> function -> int. Both
476 pointer (and reference and offset) and function (and member) types must
477 deal with prefix and suffix.
479 Arrays must also do this for DECL nodes, like int a[], and for things like
483 dump_type_prefix (tree t
, int flags
)
485 if (TYPE_PTRMEMFUNC_P (t
))
487 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
491 switch (TREE_CODE (t
))
496 tree sub
= TREE_TYPE (t
);
498 dump_type_prefix (sub
, flags
);
499 if (TREE_CODE (sub
) == ARRAY_TYPE
)
501 pp_cxx_whitespace (cxx_pp
);
502 pp_cxx_left_paren (cxx_pp
);
504 pp_character (cxx_pp
, "&*"[TREE_CODE (t
) == POINTER_TYPE
]);
505 pp_base (cxx_pp
)->padding
= pp_before
;
506 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
512 dump_type_prefix (TREE_TYPE (t
), flags
);
513 if (TREE_CODE (t
) == OFFSET_TYPE
) /* pmfs deal with this in d_t_p */
515 pp_maybe_space (cxx_pp
);
516 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
517 pp_cxx_left_paren (cxx_pp
);
518 dump_type (TYPE_OFFSET_BASETYPE (t
), flags
);
519 pp_cxx_colon_colon (cxx_pp
);
521 pp_cxx_star (cxx_pp
);
522 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
523 pp_base (cxx_pp
)->padding
= pp_before
;
526 /* Can only be reached through function pointer -- this would not be
527 correct if FUNCTION_DECLs used it. */
529 dump_type_prefix (TREE_TYPE (t
), flags
);
530 pp_maybe_space (cxx_pp
);
531 pp_cxx_left_paren (cxx_pp
);
535 dump_type_prefix (TREE_TYPE (t
), flags
);
536 pp_maybe_space (cxx_pp
);
537 pp_cxx_left_paren (cxx_pp
);
538 dump_aggr_type (TYPE_METHOD_BASETYPE (t
), flags
);
539 pp_cxx_colon_colon (cxx_pp
);
543 dump_type_prefix (TREE_TYPE (t
), flags
);
547 case IDENTIFIER_NODE
:
552 case TEMPLATE_TYPE_PARM
:
553 case TEMPLATE_TEMPLATE_PARM
:
554 case BOUND_TEMPLATE_TEMPLATE_PARM
:
565 dump_type (t
, flags
);
566 pp_base (cxx_pp
)->padding
= pp_before
;
570 pp_unsupported_tree (cxx_pp
, t
);
573 pp_identifier (cxx_pp
, "<typeprefixerror>");
578 /* Dump the suffix of type T, under control of FLAGS. This is the part
579 which appears after the identifier (or function parms). */
582 dump_type_suffix (tree t
, int flags
)
584 if (TYPE_PTRMEMFUNC_P (t
))
585 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
587 switch (TREE_CODE (t
))
592 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
593 pp_cxx_right_paren (cxx_pp
);
594 dump_type_suffix (TREE_TYPE (t
), flags
);
597 /* Can only be reached through function pointer. */
602 pp_cxx_right_paren (cxx_pp
);
603 arg
= TYPE_ARG_TYPES (t
);
604 if (TREE_CODE (t
) == METHOD_TYPE
)
605 arg
= TREE_CHAIN (arg
);
607 /* Function pointers don't have default args. Not in standard C++,
608 anyway; they may in g++, but we'll just pretend otherwise. */
609 dump_parameters (arg
, flags
& ~TFF_FUNCTION_DEFAULT_ARGUMENTS
);
611 if (TREE_CODE (t
) == METHOD_TYPE
)
612 pp_cxx_cv_qualifier_seq
613 (cxx_pp
, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t
))));
615 pp_cxx_cv_qualifier_seq(cxx_pp
, t
);
616 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t
), flags
);
617 dump_type_suffix (TREE_TYPE (t
), flags
);
622 pp_maybe_space (cxx_pp
);
623 pp_cxx_left_bracket (cxx_pp
);
626 if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t
)), 0))
628 (cxx_pp
, tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t
)), 0) + 1);
629 else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t
))) == MINUS_EXPR
)
630 dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t
)), 0),
631 flags
& ~TFF_EXPR_IN_PARENS
);
633 dump_expr (fold (cp_build_binary_op
634 (PLUS_EXPR
, TYPE_MAX_VALUE (TYPE_DOMAIN (t
)),
636 flags
& ~TFF_EXPR_IN_PARENS
);
638 pp_cxx_right_bracket (cxx_pp
);
639 dump_type_suffix (TREE_TYPE (t
), flags
);
643 case IDENTIFIER_NODE
:
648 case TEMPLATE_TYPE_PARM
:
649 case TEMPLATE_TEMPLATE_PARM
:
650 case BOUND_TEMPLATE_TEMPLATE_PARM
:
664 pp_unsupported_tree (cxx_pp
, t
);
666 /* Don't mark it here, we should have already done in
673 dump_global_iord (tree t
)
675 const char *p
= NULL
;
677 if (DECL_GLOBAL_CTOR_P (t
))
679 else if (DECL_GLOBAL_DTOR_P (t
))
684 pp_printf (pp_base (cxx_pp
), "(static %s for %s)", p
, input_filename
);
688 dump_simple_decl (tree t
, tree type
, int flags
)
690 if (flags
& TFF_DECL_SPECIFIERS
)
692 dump_type_prefix (type
, flags
);
693 pp_maybe_space (cxx_pp
);
695 if (!DECL_INITIAL (t
) || TREE_CODE (DECL_INITIAL (t
)) != TEMPLATE_PARM_INDEX
)
696 dump_scope (CP_DECL_CONTEXT (t
), flags
);
698 dump_decl (DECL_NAME (t
), flags
);
700 pp_identifier (cxx_pp
, "<anonymous>");
701 if (flags
& TFF_DECL_SPECIFIERS
)
702 dump_type_suffix (type
, flags
);
705 /* Dump a human readable string for the decl T under control of FLAGS. */
708 dump_decl (tree t
, int flags
)
713 switch (TREE_CODE (t
))
716 /* Don't say 'typedef class A' */
717 if (DECL_ARTIFICIAL (t
))
719 if ((flags
& TFF_DECL_SPECIFIERS
)
720 && TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TYPE_PARM
)
721 /* Say `class T' not just `T'. */
722 pp_cxx_identifier (cxx_pp
, "class");
724 dump_type (TREE_TYPE (t
), flags
);
727 if (flags
& TFF_DECL_SPECIFIERS
)
728 pp_cxx_identifier (cxx_pp
, "typedef");
729 dump_simple_decl (t
, DECL_ORIGINAL_TYPE (t
)
730 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
),
735 if (DECL_NAME (t
) && VTABLE_NAME_P (DECL_NAME (t
)))
737 pp_string (cxx_pp
, "vtable for ");
738 gcc_assert (TYPE_P (DECL_CONTEXT (t
)));
739 dump_type (DECL_CONTEXT (t
), flags
);
742 /* Else fall through. */
745 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
749 pp_string (cxx_pp
, "<return value> ");
750 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
754 if (flags
& TFF_DECL_SPECIFIERS
)
755 pp_cxx_declaration (cxx_pp
, t
);
758 dump_scope (CP_DECL_CONTEXT (t
), flags
);
759 if (DECL_NAME (t
) == NULL_TREE
)
760 pp_identifier (cxx_pp
, "<unnamed>");
762 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (t
));
767 pp_expression (cxx_pp
, t
);
771 dump_decl (TREE_OPERAND (t
, 0), flags
);
772 pp_cxx_left_bracket (cxx_pp
);
773 dump_decl (TREE_OPERAND (t
, 1), flags
);
774 pp_cxx_right_bracket (cxx_pp
);
777 /* So that we can do dump_decl on an aggr type. */
781 dump_type (t
, flags
);
785 /* This is a pseudo destructor call which has not been folded into
786 a PSEUDO_DTOR_EXPR yet. */
787 pp_cxx_complement (cxx_pp
);
788 dump_type (TREE_OPERAND (t
, 0), flags
);
795 /* These special cases are duplicated here so that other functions
796 can feed identifiers to error and get them demangled properly. */
797 case IDENTIFIER_NODE
:
798 if (IDENTIFIER_TYPENAME_P (t
))
800 pp_cxx_identifier (cxx_pp
, "operator");
801 /* Not exactly IDENTIFIER_TYPE_VALUE. */
802 dump_type (TREE_TYPE (t
), flags
);
806 pp_cxx_tree_identifier (cxx_pp
, t
);
813 if (DECL_CLASS_SCOPE_P (t
))
815 dump_type (DECL_CONTEXT (t
), flags
);
816 pp_cxx_colon_colon (cxx_pp
);
818 else if (DECL_CONTEXT (t
))
820 dump_decl (DECL_CONTEXT (t
), flags
);
821 pp_cxx_colon_colon (cxx_pp
);
823 dump_decl (DECL_NAME (t
), flags
);
827 /* If there's only one function, just treat it like an ordinary
833 if (! DECL_LANG_SPECIFIC (t
))
834 pp_identifier (cxx_pp
, "<built-in>");
835 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
836 dump_global_iord (t
);
838 dump_function_decl (t
, flags
);
842 dump_template_decl (t
, flags
);
845 case TEMPLATE_ID_EXPR
:
847 tree name
= TREE_OPERAND (t
, 0);
849 if (is_overloaded_fn (name
))
850 name
= DECL_NAME (get_first_fn (name
));
851 dump_decl (name
, flags
);
852 pp_cxx_begin_template_argument_list (cxx_pp
);
853 if (TREE_OPERAND (t
, 1))
854 dump_template_argument_list (TREE_OPERAND (t
, 1), flags
);
855 pp_cxx_end_template_argument_list (cxx_pp
);
860 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (t
));
864 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
865 || (DECL_INITIAL (t
) &&
866 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
867 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
868 else if (DECL_NAME (t
))
869 dump_decl (DECL_NAME (t
), flags
);
870 else if (DECL_INITIAL (t
))
871 dump_expr (DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
873 pp_identifier (cxx_pp
, "<enumerator>");
877 pp_cxx_identifier (cxx_pp
, "using");
878 dump_type (USING_DECL_SCOPE (t
), flags
);
879 pp_cxx_colon_colon (cxx_pp
);
880 dump_decl (DECL_NAME (t
), flags
);
884 dump_decl (BASELINK_FUNCTIONS (t
), flags
);
887 case NON_DEPENDENT_EXPR
:
888 dump_expr (t
, flags
);
891 case TEMPLATE_TYPE_PARM
:
892 if (flags
& TFF_DECL_SPECIFIERS
)
893 pp_cxx_declaration (cxx_pp
, t
);
895 pp_type_id (cxx_pp
, t
);
899 pp_unsupported_tree (cxx_pp
, t
);
900 /* Fall through to error. */
903 pp_identifier (cxx_pp
, "<declaration error>");
908 /* Dump a template declaration T under control of FLAGS. This means the
909 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
912 dump_template_decl (tree t
, int flags
)
914 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
918 if (flags
& TFF_TEMPLATE_HEADER
)
920 for (parms
= orig_parms
= nreverse (orig_parms
);
922 parms
= TREE_CHAIN (parms
))
924 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
925 int len
= TREE_VEC_LENGTH (inner_parms
);
927 pp_cxx_identifier (cxx_pp
, "template");
928 pp_cxx_begin_template_argument_list (cxx_pp
);
930 /* If we've shown the template prefix, we'd better show the
931 parameters' and decl's type too. */
932 flags
|= TFF_DECL_SPECIFIERS
;
934 for (i
= 0; i
< len
; i
++)
937 pp_separate_with_comma (cxx_pp
);
938 dump_template_parameter (TREE_VEC_ELT (inner_parms
, i
), flags
);
940 pp_cxx_end_template_argument_list (cxx_pp
);
941 pp_cxx_whitespace (cxx_pp
);
943 nreverse(orig_parms
);
945 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
946 /* Say `template<arg> class TT' not just `template<arg> TT'. */
947 pp_cxx_identifier (cxx_pp
, "class");
950 if (TREE_CODE (DECL_TEMPLATE_RESULT (t
)) == TYPE_DECL
)
951 dump_type (TREE_TYPE (t
),
952 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
953 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
954 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t
)) == VAR_DECL
)
955 dump_decl (DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
958 gcc_assert (TREE_TYPE (t
));
959 switch (NEXT_CODE (t
))
963 dump_function_decl (t
, flags
| TFF_TEMPLATE_NAME
);
966 /* This case can occur with some invalid code. */
967 dump_type (TREE_TYPE (t
),
968 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
969 | (flags
& TFF_DECL_SPECIFIERS
970 ? TFF_CLASS_KEY_OR_ENUM
: 0));
975 /* Pretty print a function decl. There are several ways we want to print a
976 function declaration. The TFF_ bits in FLAGS tells us how to behave.
977 As error can only apply the '#' flag once to give 0 and 1 for V, there
978 is %D which doesn't print the throw specs, and %F which does. */
981 dump_function_decl (tree t
, int flags
)
985 tree cname
= NULL_TREE
;
986 tree template_args
= NULL_TREE
;
987 tree template_parms
= NULL_TREE
;
988 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
990 if (TREE_CODE (t
) == TEMPLATE_DECL
)
991 t
= DECL_TEMPLATE_RESULT (t
);
993 /* Pretty print template instantiations only. */
994 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
))
998 template_args
= DECL_TI_ARGS (t
);
999 tmpl
= most_general_template (t
);
1000 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1002 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1007 fntype
= TREE_TYPE (t
);
1008 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1010 if (DECL_CLASS_SCOPE_P (t
))
1011 cname
= DECL_CONTEXT (t
);
1012 /* This is for partially instantiated template methods. */
1013 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1014 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1016 if (!(flags
& TFF_DECL_SPECIFIERS
))
1018 else if (DECL_STATIC_FUNCTION_P (t
))
1019 pp_cxx_identifier (cxx_pp
, "static");
1020 else if (DECL_VIRTUAL_P (t
))
1021 pp_cxx_identifier (cxx_pp
, "virtual");
1023 /* Print the return type? */
1025 show_return
= !DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1026 && !DECL_DESTRUCTOR_P (t
);
1028 dump_type_prefix (TREE_TYPE (fntype
), flags
);
1030 /* Print the function name. */
1033 dump_type (cname
, flags
);
1034 pp_cxx_colon_colon (cxx_pp
);
1037 dump_scope (CP_DECL_CONTEXT (t
), flags
);
1039 dump_function_name (t
, flags
);
1041 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1043 dump_parameters (parmtypes
, flags
);
1045 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1047 pp_base (cxx_pp
)->padding
= pp_before
;
1048 pp_cxx_cv_qualifier_seq
1049 (cxx_pp
, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype
))));
1052 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1054 pp_base (cxx_pp
)->padding
= pp_before
;
1055 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype
), flags
);
1059 dump_type_suffix (TREE_TYPE (fntype
), flags
);
1062 /* If T is a template instantiation, dump the parameter binding. */
1063 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
)
1065 pp_cxx_whitespace (cxx_pp
);
1066 pp_cxx_left_bracket (cxx_pp
);
1067 pp_cxx_identifier (cxx_pp
, "with");
1068 pp_cxx_whitespace (cxx_pp
);
1069 dump_template_bindings (template_parms
, template_args
);
1070 pp_cxx_right_bracket (cxx_pp
);
1074 /* Print a parameter list. If this is for a member function, the
1075 member object ptr (and any other hidden args) should have
1076 already been removed. */
1079 dump_parameters (tree parmtypes
, int flags
)
1083 pp_cxx_left_paren (cxx_pp
);
1085 for (first
= 1; parmtypes
!= void_list_node
;
1086 parmtypes
= TREE_CHAIN (parmtypes
))
1089 pp_separate_with_comma (cxx_pp
);
1093 pp_cxx_identifier (cxx_pp
, "...");
1096 dump_type (TREE_VALUE (parmtypes
), flags
);
1098 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1100 pp_cxx_whitespace (cxx_pp
);
1102 pp_cxx_whitespace (cxx_pp
);
1103 dump_expr (TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1107 pp_cxx_right_paren (cxx_pp
);
1110 /* Print an exception specification. T is the exception specification. */
1113 dump_exception_spec (tree t
, int flags
)
1117 pp_cxx_identifier (cxx_pp
, "throw");
1118 pp_cxx_whitespace (cxx_pp
);
1119 pp_cxx_left_paren (cxx_pp
);
1120 if (TREE_VALUE (t
) != NULL_TREE
)
1123 dump_type (TREE_VALUE (t
), flags
);
1127 pp_separate_with_comma (cxx_pp
);
1129 pp_cxx_right_paren (cxx_pp
);
1133 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1134 and destructors properly. */
1137 dump_function_name (tree t
, int flags
)
1139 tree name
= DECL_NAME (t
);
1141 /* We can get here with a decl that was synthesized by language-
1142 independent machinery (e.g. coverage.c) in which case it won't
1143 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1144 will crash. In this case it is safe just to print out the
1146 if (!DECL_LANG_SPECIFIC (t
))
1148 pp_cxx_tree_identifier (cxx_pp
, name
);
1152 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1153 t
= DECL_TEMPLATE_RESULT (t
);
1155 /* Don't let the user see __comp_ctor et al. */
1156 if (DECL_CONSTRUCTOR_P (t
)
1157 || DECL_DESTRUCTOR_P (t
))
1158 name
= constructor_name (DECL_CONTEXT (t
));
1160 if (DECL_DESTRUCTOR_P (t
))
1162 pp_cxx_complement (cxx_pp
);
1163 dump_decl (name
, TFF_PLAIN_IDENTIFIER
);
1165 else if (DECL_CONV_FN_P (t
))
1167 /* This cannot use the hack that the operator's return
1168 type is stashed off of its name because it may be
1169 used for error reporting. In the case of conflicting
1170 declarations, both will have the same name, yet
1171 the types will be different, hence the TREE_TYPE field
1172 of the first name will be clobbered by the second. */
1173 pp_cxx_identifier (cxx_pp
, "operator");
1174 dump_type (TREE_TYPE (TREE_TYPE (t
)), flags
);
1176 else if (IDENTIFIER_OPNAME_P (name
))
1177 pp_cxx_tree_identifier (cxx_pp
, name
);
1179 dump_decl (name
, flags
);
1181 if (DECL_TEMPLATE_INFO (t
)
1182 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1183 && (TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1184 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1185 dump_template_parms (DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
), flags
);
1188 /* Dump the template parameters from the template info INFO under control of
1189 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1190 specialization (partial or complete). For partial specializations we show
1191 the specialized parameter values. For a primary template we show no
1195 dump_template_parms (tree info
, int primary
, int flags
)
1197 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1199 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1201 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1202 pp_cxx_begin_template_argument_list (cxx_pp
);
1204 /* Be careful only to print things when we have them, so as not
1205 to crash producing error messages. */
1206 if (args
&& !primary
)
1210 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
1211 args
= TREE_VEC_ELT (args
, TREE_VEC_LENGTH (args
) - 1);
1213 len
= TREE_VEC_LENGTH (args
);
1215 for (ix
= 0; ix
!= len
; ix
++)
1217 tree arg
= TREE_VEC_ELT (args
, ix
);
1220 pp_separate_with_comma (cxx_pp
);
1223 pp_identifier (cxx_pp
, "<template parameter error>");
1225 dump_template_argument (arg
, flags
);
1230 tree tpl
= TI_TEMPLATE (info
);
1231 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1234 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1235 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1237 for (ix
= 0; ix
!= len
; ix
++)
1239 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1242 pp_separate_with_comma (cxx_pp
);
1244 dump_decl (parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1247 pp_cxx_end_template_argument_list (cxx_pp
);
1250 /* Print out a list of initializers (subr of dump_expr). */
1253 dump_expr_list (tree l
, int flags
)
1257 dump_expr (TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1260 pp_separate_with_comma (cxx_pp
);
1264 /* Print out a vector of initializers (subr of dump_expr). */
1267 dump_expr_init_vec (VEC(constructor_elt
,gc
) *v
, int flags
)
1269 unsigned HOST_WIDE_INT idx
;
1272 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1274 dump_expr (value
, flags
| TFF_EXPR_IN_PARENS
);
1275 if (idx
!= VEC_length (constructor_elt
, v
) - 1)
1276 pp_separate_with_comma (cxx_pp
);
1281 /* Print out an expression E under control of FLAGS. */
1284 dump_expr (tree t
, int flags
)
1289 switch (TREE_CODE (t
))
1297 case NAMESPACE_DECL
:
1300 case IDENTIFIER_NODE
:
1301 dump_decl (t
, (flags
& ~TFF_DECL_SPECIFIERS
) | TFF_NO_FUNCTION_ARGUMENTS
);
1305 if (PAREN_STRING_LITERAL_P (t
))
1306 pp_cxx_left_paren (cxx_pp
);
1307 pp_c_constant (pp_c_base (cxx_pp
), t
);
1308 if (PAREN_STRING_LITERAL_P (t
))
1309 pp_cxx_right_paren (cxx_pp
);
1314 pp_c_constant (pp_c_base (cxx_pp
), t
);
1318 pp_cxx_identifier (cxx_pp
, "throw");
1319 dump_expr (TREE_OPERAND (t
, 0), flags
);
1323 pp_ampersand (cxx_pp
);
1324 dump_type (PTRMEM_CST_CLASS (t
), flags
);
1325 pp_cxx_colon_colon (cxx_pp
);
1326 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
1330 pp_cxx_left_paren (cxx_pp
);
1331 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1332 pp_separate_with_comma (cxx_pp
);
1333 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1334 pp_cxx_right_paren (cxx_pp
);
1338 pp_cxx_left_paren (cxx_pp
);
1339 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1340 pp_string (cxx_pp
, " ? ");
1341 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1342 pp_string (cxx_pp
, " : ");
1343 dump_expr (TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
1344 pp_cxx_right_paren (cxx_pp
);
1348 if (TREE_HAS_CONSTRUCTOR (t
))
1350 pp_cxx_identifier (cxx_pp
, "new");
1351 pp_cxx_whitespace (cxx_pp
);
1352 dump_type (TREE_TYPE (TREE_TYPE (t
)), flags
);
1355 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1358 case AGGR_INIT_EXPR
:
1360 tree fn
= NULL_TREE
;
1362 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
)
1363 fn
= TREE_OPERAND (TREE_OPERAND (t
, 0), 0);
1365 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
1367 if (DECL_CONSTRUCTOR_P (fn
))
1368 dump_type (DECL_CONTEXT (fn
), flags
);
1373 dump_expr (TREE_OPERAND (t
, 0), 0);
1375 pp_cxx_left_paren (cxx_pp
);
1376 if (TREE_OPERAND (t
, 1))
1377 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t
, 1)), flags
);
1378 pp_cxx_right_paren (cxx_pp
);
1383 tree fn
= TREE_OPERAND (t
, 0);
1384 tree args
= TREE_OPERAND (t
, 1);
1386 if (TREE_CODE (fn
) == ADDR_EXPR
)
1387 fn
= TREE_OPERAND (fn
, 0);
1389 if (TREE_TYPE (fn
) != NULL_TREE
&& NEXT_CODE (fn
) == METHOD_TYPE
)
1391 tree ob
= TREE_VALUE (args
);
1392 if (TREE_CODE (ob
) == ADDR_EXPR
)
1394 dump_expr (TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
1397 else if (TREE_CODE (ob
) != PARM_DECL
1398 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
1400 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1403 args
= TREE_CHAIN (args
);
1405 dump_expr (fn
, flags
| TFF_EXPR_IN_PARENS
);
1406 pp_cxx_left_paren (cxx_pp
);
1407 dump_expr_list (args
, flags
);
1408 pp_cxx_right_paren (cxx_pp
);
1414 tree type
= TREE_OPERAND (t
, 1);
1415 tree init
= TREE_OPERAND (t
, 2);
1416 if (NEW_EXPR_USE_GLOBAL (t
))
1417 pp_cxx_colon_colon (cxx_pp
);
1418 pp_cxx_identifier (cxx_pp
, "new");
1419 if (TREE_OPERAND (t
, 0))
1421 pp_cxx_left_paren (cxx_pp
);
1422 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
1423 pp_cxx_right_paren (cxx_pp
);
1424 pp_cxx_whitespace (cxx_pp
);
1426 if (TREE_CODE (type
) == ARRAY_REF
)
1427 type
= build_cplus_array_type
1428 (TREE_OPERAND (type
, 0),
1429 build_index_type (fold_build2 (MINUS_EXPR
, integer_type_node
,
1430 TREE_OPERAND (type
, 1),
1431 integer_one_node
)));
1432 dump_type (type
, flags
);
1435 pp_cxx_left_paren (cxx_pp
);
1436 if (TREE_CODE (init
) == TREE_LIST
)
1437 dump_expr_list (init
, flags
);
1438 else if (init
== void_zero_node
)
1439 /* This representation indicates an empty initializer,
1440 e.g.: "new int()". */
1443 dump_expr (init
, flags
);
1444 pp_cxx_right_paren (cxx_pp
);
1450 /* Note that this only works for G++ target exprs. If somebody
1451 builds a general TARGET_EXPR, there's no way to represent that
1452 it initializes anything other that the parameter slot for the
1453 default argument. Note we may have cleared out the first
1454 operand in expand_expr, so don't go killing ourselves. */
1455 if (TREE_OPERAND (t
, 1))
1456 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1464 case TRUNC_DIV_EXPR
:
1465 case TRUNC_MOD_EXPR
:
1473 case TRUTH_ANDIF_EXPR
:
1474 case TRUTH_ORIF_EXPR
:
1481 case EXACT_DIV_EXPR
:
1482 dump_binary_op (operator_name_info
[(int) TREE_CODE (t
)].name
, t
, flags
);
1486 case FLOOR_DIV_EXPR
:
1487 case ROUND_DIV_EXPR
:
1489 dump_binary_op ("/", t
, flags
);
1493 case FLOOR_MOD_EXPR
:
1494 case ROUND_MOD_EXPR
:
1495 dump_binary_op ("%", t
, flags
);
1500 tree ob
= TREE_OPERAND (t
, 0);
1501 if (TREE_CODE (ob
) == INDIRECT_REF
)
1503 ob
= TREE_OPERAND (ob
, 0);
1504 if (TREE_CODE (ob
) != PARM_DECL
1506 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this")))
1508 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1509 pp_cxx_arrow (cxx_pp
);
1514 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1515 pp_cxx_dot (cxx_pp
);
1517 dump_expr (TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
1522 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1523 pp_cxx_left_bracket (cxx_pp
);
1524 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1525 pp_cxx_right_bracket (cxx_pp
);
1528 case UNARY_PLUS_EXPR
:
1529 dump_unary_op ("+", t
, flags
);
1533 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
1534 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
1535 /* An ADDR_EXPR can have reference type. In that case, we
1536 shouldn't print the `&' doing so indicates to the user
1537 that the expression has pointer type. */
1539 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
1540 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1541 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
1542 dump_unary_op ("&&", t
, flags
);
1544 dump_unary_op ("&", t
, flags
);
1548 if (TREE_HAS_CONSTRUCTOR (t
))
1550 t
= TREE_OPERAND (t
, 0);
1551 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
1552 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1553 pp_cxx_left_paren (cxx_pp
);
1554 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t
, 1)), flags
);
1555 pp_cxx_right_paren (cxx_pp
);
1559 if (TREE_OPERAND (t
,0) != NULL_TREE
1560 && TREE_TYPE (TREE_OPERAND (t
, 0))
1561 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
1562 dump_expr (TREE_OPERAND (t
, 0), flags
);
1564 dump_unary_op ("*", t
, flags
);
1570 case TRUTH_NOT_EXPR
:
1571 case PREDECREMENT_EXPR
:
1572 case PREINCREMENT_EXPR
:
1573 dump_unary_op (operator_name_info
[(int)TREE_CODE (t
)].name
, t
, flags
);
1576 case POSTDECREMENT_EXPR
:
1577 case POSTINCREMENT_EXPR
:
1578 pp_cxx_left_paren (cxx_pp
);
1579 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1580 pp_cxx_identifier (cxx_pp
, operator_name_info
[(int)TREE_CODE (t
)].name
);
1581 pp_cxx_right_paren (cxx_pp
);
1584 case NON_LVALUE_EXPR
:
1585 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1586 should be another level of INDIRECT_REF so that I don't have to do
1588 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
1590 tree next
= TREE_TYPE (TREE_TYPE (t
));
1592 while (TREE_CODE (next
) == POINTER_TYPE
)
1593 next
= TREE_TYPE (next
);
1595 if (TREE_CODE (next
) == FUNCTION_TYPE
)
1597 if (flags
& TFF_EXPR_IN_PARENS
)
1598 pp_cxx_left_paren (cxx_pp
);
1599 pp_cxx_star (cxx_pp
);
1600 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1601 if (flags
& TFF_EXPR_IN_PARENS
)
1602 pp_cxx_right_paren (cxx_pp
);
1605 /* Else fall through. */
1607 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1613 tree op
= TREE_OPERAND (t
, 0);
1615 if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
1617 /* It is a cast, but we cannot tell whether it is a
1618 reinterpret or static cast. Use the C style notation. */
1619 if (flags
& TFF_EXPR_IN_PARENS
)
1620 pp_cxx_left_paren (cxx_pp
);
1621 pp_cxx_left_paren (cxx_pp
);
1622 dump_type (TREE_TYPE (t
), flags
);
1623 pp_cxx_right_paren (cxx_pp
);
1624 dump_expr (op
, flags
| TFF_EXPR_IN_PARENS
);
1625 if (flags
& TFF_EXPR_IN_PARENS
)
1626 pp_cxx_right_paren (cxx_pp
);
1629 dump_expr (op
, flags
);
1634 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
1636 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
1638 if (integer_zerop (idx
))
1640 /* A NULL pointer-to-member constant. */
1641 pp_cxx_left_paren (cxx_pp
);
1642 pp_cxx_left_paren (cxx_pp
);
1643 dump_type (TREE_TYPE (t
), flags
);
1644 pp_cxx_right_paren (cxx_pp
);
1645 pp_character (cxx_pp
, '0');
1646 pp_cxx_right_paren (cxx_pp
);
1649 else if (host_integerp (idx
, 0))
1652 unsigned HOST_WIDE_INT n
;
1654 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
1655 t
= TYPE_METHOD_BASETYPE (t
);
1656 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
1658 n
= tree_low_cst (idx
, 0);
1660 /* Map vtable index back one, to allow for the null pointer to
1664 while (n
> 0 && virtuals
)
1667 virtuals
= TREE_CHAIN (virtuals
);
1671 dump_expr (BV_FN (virtuals
),
1672 flags
| TFF_EXPR_IN_PARENS
);
1677 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
1679 dump_type (TREE_TYPE (t
), 0);
1680 pp_cxx_left_paren (cxx_pp
);
1681 pp_cxx_right_paren (cxx_pp
);
1685 pp_cxx_left_brace (cxx_pp
);
1686 dump_expr_init_vec (CONSTRUCTOR_ELTS (t
), flags
);
1687 pp_cxx_right_brace (cxx_pp
);
1694 tree ob
= TREE_OPERAND (t
, 0);
1695 if (is_dummy_object (ob
))
1697 t
= TREE_OPERAND (t
, 1);
1698 if (TREE_CODE (t
) == FUNCTION_DECL
)
1700 dump_expr (t
, flags
| TFF_EXPR_IN_PARENS
);
1701 else if (BASELINK_P (t
))
1702 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t
)),
1703 flags
| TFF_EXPR_IN_PARENS
);
1705 dump_decl (t
, flags
);
1709 if (TREE_CODE (ob
) == INDIRECT_REF
)
1711 dump_expr (TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
1712 pp_cxx_arrow (cxx_pp
);
1713 pp_cxx_star (cxx_pp
);
1717 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1718 pp_cxx_dot (cxx_pp
);
1719 pp_cxx_star (cxx_pp
);
1721 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1726 case TEMPLATE_PARM_INDEX
:
1727 dump_decl (TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
1731 pp_expression (cxx_pp
, t
);
1735 if (TREE_OPERAND (t
, 0) == NULL_TREE
1736 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
1738 dump_type (TREE_TYPE (t
), flags
);
1739 pp_cxx_left_paren (cxx_pp
);
1740 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
1741 pp_cxx_right_paren (cxx_pp
);
1745 pp_cxx_left_paren (cxx_pp
);
1746 dump_type (TREE_TYPE (t
), flags
);
1747 pp_cxx_right_paren (cxx_pp
);
1748 pp_cxx_left_paren (cxx_pp
);
1749 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
1750 pp_cxx_right_paren (cxx_pp
);
1754 case STATIC_CAST_EXPR
:
1755 pp_cxx_identifier (cxx_pp
, "static_cast");
1757 case REINTERPRET_CAST_EXPR
:
1758 pp_cxx_identifier (cxx_pp
, "reinterpret_cast");
1760 case CONST_CAST_EXPR
:
1761 pp_cxx_identifier (cxx_pp
, "const_cast");
1763 case DYNAMIC_CAST_EXPR
:
1764 pp_cxx_identifier (cxx_pp
, "dynamic_cast");
1766 pp_cxx_begin_template_argument_list (cxx_pp
);
1767 dump_type (TREE_TYPE (t
), flags
);
1768 pp_cxx_end_template_argument_list (cxx_pp
);
1769 pp_cxx_left_paren (cxx_pp
);
1770 dump_expr (TREE_OPERAND (t
, 0), flags
);
1771 pp_cxx_right_paren (cxx_pp
);
1775 dump_expr (TREE_OPERAND (t
, 0), flags
);
1776 pp_cxx_arrow (cxx_pp
);
1781 if (TREE_CODE (t
) == SIZEOF_EXPR
)
1782 pp_cxx_identifier (cxx_pp
, "sizeof");
1785 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
1786 pp_cxx_identifier (cxx_pp
, "__alignof__");
1788 pp_cxx_whitespace (cxx_pp
);
1789 pp_cxx_left_paren (cxx_pp
);
1790 if (TYPE_P (TREE_OPERAND (t
, 0)))
1791 dump_type (TREE_OPERAND (t
, 0), flags
);
1793 dump_expr (TREE_OPERAND (t
, 0), flags
);
1794 pp_cxx_right_paren (cxx_pp
);
1799 pp_cxx_identifier (cxx_pp
, operator_name_info
[TREE_CODE (t
)].name
);
1800 pp_cxx_whitespace (cxx_pp
);
1801 dump_expr (TREE_OPERAND (t
, 0), flags
);
1805 pp_identifier (cxx_pp
, "<unparsed>");
1808 case TRY_CATCH_EXPR
:
1809 case WITH_CLEANUP_EXPR
:
1810 case CLEANUP_POINT_EXPR
:
1811 dump_expr (TREE_OPERAND (t
, 0), flags
);
1814 case PSEUDO_DTOR_EXPR
:
1815 dump_expr (TREE_OPERAND (t
, 2), flags
);
1816 pp_cxx_dot (cxx_pp
);
1817 dump_type (TREE_OPERAND (t
, 0), flags
);
1818 pp_cxx_colon_colon (cxx_pp
);
1819 pp_cxx_complement (cxx_pp
);
1820 dump_type (TREE_OPERAND (t
, 1), flags
);
1823 case TEMPLATE_ID_EXPR
:
1824 dump_decl (t
, flags
);
1829 case STATEMENT_LIST
:
1830 /* We don't yet have a way of dumping statements in a
1831 human-readable format. */
1832 pp_string (cxx_pp
, "({...})");
1836 pp_string (cxx_pp
, "while (1) { ");
1837 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1838 pp_cxx_right_brace (cxx_pp
);
1842 pp_string (cxx_pp
, "if (");
1843 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1844 pp_string (cxx_pp
, ") break; ");
1848 dump_expr (get_first_fn (t
), flags
& ~TFF_EXPR_IN_PARENS
);
1851 case EMPTY_CLASS_EXPR
:
1852 dump_type (TREE_TYPE (t
), flags
);
1853 pp_cxx_left_paren (cxx_pp
);
1854 pp_cxx_right_paren (cxx_pp
);
1857 case NON_DEPENDENT_EXPR
:
1858 dump_expr (TREE_OPERAND (t
, 0), flags
);
1861 /* This list is incomplete, but should suffice for now.
1862 It is very important that `sorry' does not call
1863 `report_error_function'. That could cause an infinite loop. */
1865 pp_unsupported_tree (cxx_pp
, t
);
1866 /* fall through to ERROR_MARK... */
1868 pp_identifier (cxx_pp
, "<expression error>");
1874 dump_binary_op (const char *opstring
, tree t
, int flags
)
1876 pp_cxx_left_paren (cxx_pp
);
1877 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1878 pp_cxx_whitespace (cxx_pp
);
1880 pp_cxx_identifier (cxx_pp
, opstring
);
1882 pp_identifier (cxx_pp
, "<unknown operator>");
1883 pp_cxx_whitespace (cxx_pp
);
1884 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1885 pp_cxx_right_paren (cxx_pp
);
1889 dump_unary_op (const char *opstring
, tree t
, int flags
)
1891 if (flags
& TFF_EXPR_IN_PARENS
)
1892 pp_cxx_left_paren (cxx_pp
);
1893 pp_cxx_identifier (cxx_pp
, opstring
);
1894 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1895 if (flags
& TFF_EXPR_IN_PARENS
)
1896 pp_cxx_right_paren (cxx_pp
);
1900 reinit_cxx_pp (void)
1902 pp_clear_output_area (cxx_pp
);
1903 pp_base (cxx_pp
)->padding
= pp_none
;
1904 pp_indentation (cxx_pp
) = 0;
1905 pp_needs_newline (cxx_pp
) = false;
1906 cxx_pp
->enclosing_scope
= 0;
1910 /* Exported interface to stringifying types, exprs and decls under TFF_*
1914 type_as_string (tree typ
, int flags
)
1917 dump_type (typ
, flags
);
1918 return pp_formatted_text (cxx_pp
);
1922 expr_as_string (tree decl
, int flags
)
1925 dump_expr (decl
, flags
);
1926 return pp_formatted_text (cxx_pp
);
1930 decl_as_string (tree decl
, int flags
)
1933 dump_decl (decl
, flags
);
1934 return pp_formatted_text (cxx_pp
);
1937 /* Generate the three forms of printable names for cxx_printable_name. */
1940 lang_decl_name (tree decl
, int v
)
1943 return decl_as_string (decl
, TFF_DECL_SPECIFIERS
);
1946 if (v
== 1 && DECL_CLASS_SCOPE_P (decl
))
1948 dump_type (CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
1949 pp_cxx_colon_colon (cxx_pp
);
1952 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1953 dump_function_name (decl
, TFF_PLAIN_IDENTIFIER
);
1955 dump_decl (DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
1957 return pp_formatted_text (cxx_pp
);
1960 /* Return the location of a tree passed to %+ formats. */
1963 location_of (tree t
)
1965 if (TREE_CODE (t
) == PARM_DECL
&& DECL_CONTEXT (t
))
1966 t
= DECL_CONTEXT (t
);
1967 else if (TYPE_P (t
))
1968 t
= TYPE_MAIN_DECL (t
);
1969 else if (TREE_CODE (t
) == OVERLOAD
)
1970 t
= OVL_FUNCTION (t
);
1972 return DECL_SOURCE_LOCATION (t
);
1975 /* Now the interfaces from error et al to dump_type et al. Each takes an
1976 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
1980 decl_to_string (tree decl
, int verbose
)
1984 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
1985 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
1986 flags
= TFF_CLASS_KEY_OR_ENUM
;
1988 flags
|= TFF_DECL_SPECIFIERS
;
1989 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
1990 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
1991 flags
|= TFF_TEMPLATE_HEADER
;
1994 dump_decl (decl
, flags
);
1995 return pp_formatted_text (cxx_pp
);
1999 expr_to_string (tree decl
)
2002 dump_expr (decl
, 0);
2003 return pp_formatted_text (cxx_pp
);
2007 fndecl_to_string (tree fndecl
, int verbose
)
2011 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
;
2013 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
2015 dump_decl (fndecl
, flags
);
2016 return pp_formatted_text (cxx_pp
);
2021 code_to_string (enum tree_code c
)
2023 return tree_code_name
[c
];
2027 language_to_string (enum languages c
)
2034 case lang_cplusplus
:
2046 /* Return the proper printed version of a parameter to a C++ function. */
2049 parm_to_string (int p
)
2053 pp_string (cxx_pp
, "'this'");
2055 pp_decimal_int (cxx_pp
, p
+ 1);
2056 return pp_formatted_text (cxx_pp
);
2060 op_to_string (enum tree_code p
)
2062 tree id
= operator_name_info
[(int) p
].identifier
;
2063 return id
? IDENTIFIER_POINTER (id
) : "<unknown>";
2067 type_to_string (tree typ
, int verbose
)
2071 flags
|= TFF_CLASS_KEY_OR_ENUM
;
2072 flags
|= TFF_TEMPLATE_HEADER
;
2075 dump_type (typ
, flags
);
2076 return pp_formatted_text (cxx_pp
);
2080 assop_to_string (enum tree_code p
)
2082 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
2083 return id
? IDENTIFIER_POINTER (id
) : "{unknown}";
2087 args_to_string (tree p
, int verbose
)
2091 flags
|= TFF_CLASS_KEY_OR_ENUM
;
2096 if (TYPE_P (TREE_VALUE (p
)))
2097 return type_as_string (p
, flags
);
2100 for (; p
; p
= TREE_CHAIN (p
))
2102 if (TREE_VALUE (p
) == null_node
)
2103 pp_cxx_identifier (cxx_pp
, "NULL");
2105 dump_type (error_type (TREE_VALUE (p
)), flags
);
2107 pp_separate_with_comma (cxx_pp
);
2109 return pp_formatted_text (cxx_pp
);
2113 cv_to_string (tree p
, int v
)
2116 pp_base (cxx_pp
)->padding
= v
? pp_before
: pp_none
;
2117 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
2118 return pp_formatted_text (cxx_pp
);
2121 /* Langhook for print_error_function. */
2123 cxx_print_error_function (diagnostic_context
*context
, const char *file
)
2125 lhd_print_error_function (context
, file
);
2126 pp_base_set_prefix (context
->printer
, file
);
2127 maybe_print_instantiation_context (context
);
2131 cp_diagnostic_starter (diagnostic_context
*context
,
2132 diagnostic_info
*diagnostic
)
2134 diagnostic_report_current_module (context
);
2135 cp_print_error_function (context
, diagnostic
);
2136 maybe_print_instantiation_context (context
);
2137 pp_base_set_prefix (context
->printer
, diagnostic_build_prefix (diagnostic
));
2141 cp_diagnostic_finalizer (diagnostic_context
*context
,
2142 diagnostic_info
*diagnostic ATTRIBUTE_UNUSED
)
2144 pp_base_destroy_prefix (context
->printer
);
2147 /* Print current function onto BUFFER, in the process of reporting
2148 a diagnostic message. Called from cp_diagnostic_starter. */
2150 cp_print_error_function (diagnostic_context
*context
,
2151 diagnostic_info
*diagnostic
)
2153 if (diagnostic_last_function_changed (context
))
2155 const char *old_prefix
= context
->printer
->prefix
;
2156 const char *file
= LOCATION_FILE (diagnostic
->location
);
2157 char *new_prefix
= file
? file_name_as_prefix (file
) : NULL
;
2159 pp_base_set_prefix (context
->printer
, new_prefix
);
2161 if (current_function_decl
== NULL
)
2162 pp_base_string (context
->printer
, "At global scope:");
2164 pp_printf (context
->printer
, "In %s %qs:",
2165 function_category (current_function_decl
),
2166 cxx_printable_name (current_function_decl
, 2));
2167 pp_base_newline (context
->printer
);
2169 diagnostic_set_last_function (context
);
2170 pp_base_destroy_prefix (context
->printer
);
2171 context
->printer
->prefix
= old_prefix
;
2175 /* Returns a description of FUNCTION using standard terminology. */
2177 function_category (tree fn
)
2179 if (DECL_FUNCTION_MEMBER_P (fn
))
2181 if (DECL_STATIC_FUNCTION_P (fn
))
2182 return "static member function";
2183 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
2184 return "copy constructor";
2185 else if (DECL_CONSTRUCTOR_P (fn
))
2186 return "constructor";
2187 else if (DECL_DESTRUCTOR_P (fn
))
2188 return "destructor";
2190 return "member function";
2196 /* Report the full context of a current template instantiation,
2199 print_instantiation_full_context (diagnostic_context
*context
)
2201 tree p
= current_instantiation ();
2202 location_t location
= input_location
;
2206 if (current_function_decl
!= TINST_DECL (p
)
2207 && current_function_decl
!= NULL_TREE
)
2208 /* We can get here during the processing of some synthesized
2209 method. Then, TINST_DECL (p) will be the function that's causing
2214 if (current_function_decl
== TINST_DECL (p
))
2215 /* Avoid redundancy with the "In function" line. */;
2217 pp_verbatim (context
->printer
,
2218 "%s: In instantiation of %qs:\n",
2219 LOCATION_FILE (location
),
2220 decl_as_string (TINST_DECL (p
),
2221 TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
));
2223 location
= TINST_LOCATION (p
);
2228 print_instantiation_partial_context (context
, p
, location
);
2231 /* Same as above but less verbose. */
2233 print_instantiation_partial_context (diagnostic_context
*context
,
2234 tree t
, location_t loc
)
2236 expanded_location xloc
;
2237 for (; ; t
= TREE_CHAIN (t
))
2239 xloc
= expand_location (loc
);
2242 pp_verbatim (context
->printer
, "%s:%d: instantiated from %qs\n",
2243 xloc
.file
, xloc
.line
,
2244 decl_as_string (TINST_DECL (t
),
2245 TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
));
2246 loc
= TINST_LOCATION (t
);
2248 pp_verbatim (context
->printer
, "%s:%d: instantiated from here",
2249 xloc
.file
, xloc
.line
);
2250 pp_base_newline (context
->printer
);
2253 /* Called from cp_thing to print the template context for an error. */
2255 maybe_print_instantiation_context (diagnostic_context
*context
)
2257 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2260 record_last_problematic_instantiation ();
2261 print_instantiation_full_context (context
);
2264 /* Report the bare minimum context of a template instantiation. */
2266 print_instantiation_context (void)
2268 print_instantiation_partial_context
2269 (global_dc
, current_instantiation (), input_location
);
2270 diagnostic_flush_buffer (global_dc
);
2273 /* Called from output_format -- during diagnostic message processing --
2274 to handle C++ specific format specifier with the following meanings:
2275 %A function argument-list.
2279 %F function declaration.
2280 %L language as used in extern "lang".
2282 %P function parameter whose position is indicated by an integer.
2283 %Q assignment operator.
2287 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
2288 int precision
, bool wide
, bool set_locus
, bool verbose
)
2292 #define next_tree (t = va_arg (*text->args_ptr, tree))
2293 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2294 #define next_lang va_arg (*text->args_ptr, enum languages)
2295 #define next_int va_arg (*text->args_ptr, int)
2297 if (precision
!= 0 || wide
)
2300 if (text
->locus
== NULL
)
2305 case 'A': result
= args_to_string (next_tree
, verbose
); break;
2306 case 'C': result
= code_to_string (next_tcode
); break;
2307 case 'D': result
= decl_to_string (next_tree
, verbose
); break;
2308 case 'E': result
= expr_to_string (next_tree
); break;
2309 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
2310 case 'L': result
= language_to_string (next_lang
); break;
2311 case 'O': result
= op_to_string (next_tcode
); break;
2312 case 'P': result
= parm_to_string (next_int
); break;
2313 case 'Q': result
= assop_to_string (next_tcode
); break;
2314 case 'T': result
= type_to_string (next_tree
, verbose
); break;
2315 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
2321 pp_base_string (pp
, result
);
2322 if (set_locus
&& t
!= NULL
)
2323 *text
->locus
= location_of (t
);
2331 /* Callback from cpp_error for PFILE to print diagnostics arising from
2332 interpreting strings. The diagnostic is of type LEVEL; MSG is the
2333 translated message and AP the arguments. */
2336 cp_cpp_error (cpp_reader
*pfile ATTRIBUTE_UNUSED
, int level
,
2337 const char *msg
, va_list *ap
)
2339 diagnostic_info diagnostic
;
2340 diagnostic_t dlevel
;
2343 case CPP_DL_WARNING
:
2344 case CPP_DL_WARNING_SYSHDR
:
2345 dlevel
= DK_WARNING
;
2347 case CPP_DL_PEDWARN
:
2348 dlevel
= pedantic_error_kind ();
2359 diagnostic_set_info_translated (&diagnostic
, msg
, ap
,
2360 input_location
, dlevel
);
2361 report_diagnostic (&diagnostic
);