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
)
172 if (parm
== error_mark_node
)
175 p
= TREE_VALUE (parm
);
176 a
= TREE_PURPOSE (parm
);
178 if (TREE_CODE (p
) == TYPE_DECL
)
180 if (flags
& TFF_DECL_SPECIFIERS
)
182 pp_cxx_identifier (cxx_pp
, "class");
184 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (p
));
186 else if (DECL_NAME (p
))
187 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (p
));
189 pp_cxx_canonical_template_parameter (cxx_pp
, TREE_TYPE (p
));
192 dump_decl (p
, flags
| TFF_DECL_SPECIFIERS
);
194 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && a
!= NULL_TREE
)
196 pp_cxx_whitespace (cxx_pp
);
198 pp_cxx_whitespace (cxx_pp
);
199 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
200 dump_type (a
, flags
& ~TFF_CHASE_TYPEDEF
);
202 dump_expr (a
, flags
| TFF_EXPR_IN_PARENS
);
206 /* Dump, under control of FLAGS, a template-parameter-list binding.
207 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
211 dump_template_bindings (tree parms
, tree args
)
217 tree p
= TREE_VALUE (parms
);
218 int lvl
= TMPL_PARMS_DEPTH (parms
);
222 for (i
= 0; i
< TREE_VEC_LENGTH (p
); ++i
)
224 tree arg
= NULL_TREE
;
226 /* Don't crash if we had an invalid argument list. */
227 if (TMPL_ARGS_DEPTH (args
) >= lvl
)
229 tree lvl_args
= TMPL_ARGS_LEVEL (args
, lvl
);
230 if (NUM_TMPL_ARGS (lvl_args
) > arg_idx
)
231 arg
= TREE_VEC_ELT (lvl_args
, arg_idx
);
235 pp_separate_with_comma (cxx_pp
);
236 dump_template_parameter (TREE_VEC_ELT (p
, i
), TFF_PLAIN_IDENTIFIER
);
237 pp_cxx_whitespace (cxx_pp
);
239 pp_cxx_whitespace (cxx_pp
);
241 dump_template_argument (arg
, TFF_PLAIN_IDENTIFIER
);
243 pp_identifier (cxx_pp
, "<missing>");
249 parms
= TREE_CHAIN (parms
);
253 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
257 dump_type (tree t
, int flags
)
262 if (TYPE_PTRMEMFUNC_P (t
))
265 switch (TREE_CODE (t
))
268 pp_identifier (cxx_pp
, "<unresolved overloaded function type>");
272 /* A list of function parms. */
273 dump_parameters (t
, flags
);
276 case IDENTIFIER_NODE
:
277 pp_cxx_tree_identifier (cxx_pp
, t
);
281 dump_type (BINFO_TYPE (t
), flags
);
287 dump_aggr_type (t
, flags
);
291 if (flags
& TFF_CHASE_TYPEDEF
)
293 dump_type (DECL_ORIGINAL_TYPE (t
)
294 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
), flags
);
297 /* Else fall through. */
301 dump_decl (t
, flags
& ~TFF_DECL_SPECIFIERS
);
310 pp_type_specifier_seq (cxx_pp
, t
);
313 case TEMPLATE_TEMPLATE_PARM
:
314 /* For parameters inside template signature. */
315 if (TYPE_IDENTIFIER (t
))
316 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (t
));
318 pp_cxx_canonical_template_parameter (cxx_pp
, t
);
321 case BOUND_TEMPLATE_TEMPLATE_PARM
:
323 tree args
= TYPE_TI_ARGS (t
);
324 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
325 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (t
));
326 pp_cxx_begin_template_argument_list (cxx_pp
);
327 dump_template_argument_list (args
, flags
);
328 pp_cxx_end_template_argument_list (cxx_pp
);
332 case TEMPLATE_TYPE_PARM
:
333 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
334 if (TYPE_IDENTIFIER (t
))
335 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (t
));
337 pp_cxx_canonical_template_parameter
338 (cxx_pp
, TEMPLATE_TYPE_PARM_INDEX (t
));
341 /* This is not always necessary for pointers and such, but doing this
342 reduces code size. */
351 dump_type_prefix (t
, flags
);
352 dump_type_suffix (t
, flags
);
356 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
357 pp_cxx_identifier (cxx_pp
,
358 TYPENAME_IS_ENUM_P (t
) ? "enum"
359 : TYPENAME_IS_CLASS_P (t
) ? "class"
361 dump_typename (t
, flags
);
364 case UNBOUND_CLASS_TEMPLATE
:
365 dump_type (TYPE_CONTEXT (t
), flags
);
366 pp_cxx_colon_colon (cxx_pp
);
367 pp_cxx_identifier (cxx_pp
, "template");
368 dump_type (DECL_NAME (TYPE_NAME (t
)), flags
);
372 pp_cxx_identifier (cxx_pp
, "__typeof__");
373 pp_cxx_whitespace (cxx_pp
);
374 pp_cxx_left_paren (cxx_pp
);
375 dump_expr (TYPEOF_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
376 pp_cxx_right_paren (cxx_pp
);
380 pp_unsupported_tree (cxx_pp
, t
);
381 /* Fall through to error. */
384 pp_identifier (cxx_pp
, "<type error>");
389 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
393 dump_typename (tree t
, int flags
)
395 tree ctx
= TYPE_CONTEXT (t
);
397 if (TREE_CODE (ctx
) == TYPENAME_TYPE
)
398 dump_typename (ctx
, flags
);
400 dump_type (ctx
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
401 pp_cxx_colon_colon (cxx_pp
);
402 dump_decl (TYPENAME_TYPE_FULLNAME (t
), flags
);
405 /* Return the name of the supplied aggregate, or enumeral type. */
408 class_key_or_enum_as_string (tree t
)
410 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
412 else if (TREE_CODE (t
) == UNION_TYPE
)
414 else if (TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_DECLARED_CLASS (t
))
420 /* Print out a class declaration T under the control of FLAGS,
421 in the form `class foo'. */
424 dump_aggr_type (tree t
, int flags
)
427 const char *variety
= class_key_or_enum_as_string (t
);
431 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
433 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
434 pp_cxx_identifier (cxx_pp
, variety
);
436 if (flags
& TFF_CHASE_TYPEDEF
)
437 t
= TYPE_MAIN_VARIANT (t
);
439 name
= TYPE_NAME (t
);
443 typdef
= !DECL_ARTIFICIAL (name
);
444 tmplate
= !typdef
&& TREE_CODE (t
) != ENUMERAL_TYPE
445 && TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_TEMPLATE_INFO (t
)
446 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t
)) != TEMPLATE_DECL
447 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)));
448 dump_scope (CP_DECL_CONTEXT (name
), flags
| TFF_SCOPE
);
451 /* Because the template names are mangled, we have to locate
452 the most general template, and use that name. */
453 tree tpl
= CLASSTYPE_TI_TEMPLATE (t
);
455 while (DECL_TEMPLATE_INFO (tpl
))
456 tpl
= DECL_TI_TEMPLATE (tpl
);
459 name
= DECL_NAME (name
);
462 if (name
== 0 || ANON_AGGRNAME_P (name
))
464 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
465 pp_identifier (cxx_pp
, "<anonymous>");
467 pp_printf (pp_base (cxx_pp
), "<anonymous %s>", variety
);
470 pp_cxx_tree_identifier (cxx_pp
, name
);
472 dump_template_parms (TYPE_TEMPLATE_INFO (t
),
473 !CLASSTYPE_USE_TEMPLATE (t
),
474 flags
& ~TFF_TEMPLATE_HEADER
);
477 /* Dump into the obstack the initial part of the output for a given type.
478 This is necessary when dealing with things like functions returning
481 return type of `int (* fee ())()': pointer -> function -> int. Both
482 pointer (and reference and offset) and function (and member) types must
483 deal with prefix and suffix.
485 Arrays must also do this for DECL nodes, like int a[], and for things like
489 dump_type_prefix (tree t
, int flags
)
491 if (TYPE_PTRMEMFUNC_P (t
))
493 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
497 switch (TREE_CODE (t
))
502 tree sub
= TREE_TYPE (t
);
504 dump_type_prefix (sub
, flags
);
505 if (TREE_CODE (sub
) == ARRAY_TYPE
)
507 pp_cxx_whitespace (cxx_pp
);
508 pp_cxx_left_paren (cxx_pp
);
510 pp_character (cxx_pp
, "&*"[TREE_CODE (t
) == POINTER_TYPE
]);
511 pp_base (cxx_pp
)->padding
= pp_before
;
512 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
518 dump_type_prefix (TREE_TYPE (t
), flags
);
519 if (TREE_CODE (t
) == OFFSET_TYPE
) /* pmfs deal with this in d_t_p */
521 pp_maybe_space (cxx_pp
);
522 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
523 pp_cxx_left_paren (cxx_pp
);
524 dump_type (TYPE_OFFSET_BASETYPE (t
), flags
);
525 pp_cxx_colon_colon (cxx_pp
);
527 pp_cxx_star (cxx_pp
);
528 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
529 pp_base (cxx_pp
)->padding
= pp_before
;
532 /* Can only be reached through function pointer -- this would not be
533 correct if FUNCTION_DECLs used it. */
535 dump_type_prefix (TREE_TYPE (t
), flags
);
536 pp_maybe_space (cxx_pp
);
537 pp_cxx_left_paren (cxx_pp
);
541 dump_type_prefix (TREE_TYPE (t
), flags
);
542 pp_maybe_space (cxx_pp
);
543 pp_cxx_left_paren (cxx_pp
);
544 dump_aggr_type (TYPE_METHOD_BASETYPE (t
), flags
);
545 pp_cxx_colon_colon (cxx_pp
);
549 dump_type_prefix (TREE_TYPE (t
), flags
);
553 case IDENTIFIER_NODE
:
558 case TEMPLATE_TYPE_PARM
:
559 case TEMPLATE_TEMPLATE_PARM
:
560 case BOUND_TEMPLATE_TEMPLATE_PARM
:
571 dump_type (t
, flags
);
572 pp_base (cxx_pp
)->padding
= pp_before
;
576 pp_unsupported_tree (cxx_pp
, t
);
579 pp_identifier (cxx_pp
, "<typeprefixerror>");
584 /* Dump the suffix of type T, under control of FLAGS. This is the part
585 which appears after the identifier (or function parms). */
588 dump_type_suffix (tree t
, int flags
)
590 if (TYPE_PTRMEMFUNC_P (t
))
591 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
593 switch (TREE_CODE (t
))
598 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
599 pp_cxx_right_paren (cxx_pp
);
600 dump_type_suffix (TREE_TYPE (t
), flags
);
603 /* Can only be reached through function pointer. */
608 pp_cxx_right_paren (cxx_pp
);
609 arg
= TYPE_ARG_TYPES (t
);
610 if (TREE_CODE (t
) == METHOD_TYPE
)
611 arg
= TREE_CHAIN (arg
);
613 /* Function pointers don't have default args. Not in standard C++,
614 anyway; they may in g++, but we'll just pretend otherwise. */
615 dump_parameters (arg
, flags
& ~TFF_FUNCTION_DEFAULT_ARGUMENTS
);
617 if (TREE_CODE (t
) == METHOD_TYPE
)
618 pp_cxx_cv_qualifier_seq
619 (cxx_pp
, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t
))));
621 pp_cxx_cv_qualifier_seq(cxx_pp
, t
);
622 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t
), flags
);
623 dump_type_suffix (TREE_TYPE (t
), flags
);
628 pp_maybe_space (cxx_pp
);
629 pp_cxx_left_bracket (cxx_pp
);
632 if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t
)), 0))
634 (cxx_pp
, tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t
)), 0) + 1);
635 else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t
))) == MINUS_EXPR
)
636 dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t
)), 0),
637 flags
& ~TFF_EXPR_IN_PARENS
);
639 dump_expr (fold (cp_build_binary_op
640 (PLUS_EXPR
, TYPE_MAX_VALUE (TYPE_DOMAIN (t
)),
642 flags
& ~TFF_EXPR_IN_PARENS
);
644 pp_cxx_right_bracket (cxx_pp
);
645 dump_type_suffix (TREE_TYPE (t
), flags
);
649 case IDENTIFIER_NODE
:
654 case TEMPLATE_TYPE_PARM
:
655 case TEMPLATE_TEMPLATE_PARM
:
656 case BOUND_TEMPLATE_TEMPLATE_PARM
:
670 pp_unsupported_tree (cxx_pp
, t
);
672 /* Don't mark it here, we should have already done in
679 dump_global_iord (tree t
)
681 const char *p
= NULL
;
683 if (DECL_GLOBAL_CTOR_P (t
))
685 else if (DECL_GLOBAL_DTOR_P (t
))
690 pp_printf (pp_base (cxx_pp
), "(static %s for %s)", p
, input_filename
);
694 dump_simple_decl (tree t
, tree type
, int flags
)
696 if (flags
& TFF_DECL_SPECIFIERS
)
698 dump_type_prefix (type
, flags
);
699 pp_maybe_space (cxx_pp
);
701 if (!DECL_INITIAL (t
) || TREE_CODE (DECL_INITIAL (t
)) != TEMPLATE_PARM_INDEX
)
702 dump_scope (CP_DECL_CONTEXT (t
), flags
);
704 dump_decl (DECL_NAME (t
), flags
);
706 pp_identifier (cxx_pp
, "<anonymous>");
707 if (flags
& TFF_DECL_SPECIFIERS
)
708 dump_type_suffix (type
, flags
);
711 /* Dump a human readable string for the decl T under control of FLAGS. */
714 dump_decl (tree t
, int flags
)
719 switch (TREE_CODE (t
))
722 /* Don't say 'typedef class A' */
723 if (DECL_ARTIFICIAL (t
))
725 if ((flags
& TFF_DECL_SPECIFIERS
)
726 && TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TYPE_PARM
)
727 /* Say `class T' not just `T'. */
728 pp_cxx_identifier (cxx_pp
, "class");
730 dump_type (TREE_TYPE (t
), flags
);
733 if (flags
& TFF_DECL_SPECIFIERS
)
734 pp_cxx_identifier (cxx_pp
, "typedef");
735 dump_simple_decl (t
, DECL_ORIGINAL_TYPE (t
)
736 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
),
741 if (DECL_NAME (t
) && VTABLE_NAME_P (DECL_NAME (t
)))
743 pp_string (cxx_pp
, "vtable for ");
744 gcc_assert (TYPE_P (DECL_CONTEXT (t
)));
745 dump_type (DECL_CONTEXT (t
), flags
);
748 /* Else fall through. */
751 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
755 pp_string (cxx_pp
, "<return value> ");
756 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
760 if (flags
& TFF_DECL_SPECIFIERS
)
761 pp_cxx_declaration (cxx_pp
, t
);
764 dump_scope (CP_DECL_CONTEXT (t
), flags
);
765 if (DECL_NAME (t
) == NULL_TREE
)
766 pp_identifier (cxx_pp
, "<unnamed>");
768 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (t
));
773 pp_expression (cxx_pp
, t
);
777 dump_decl (TREE_OPERAND (t
, 0), flags
);
778 pp_cxx_left_bracket (cxx_pp
);
779 dump_decl (TREE_OPERAND (t
, 1), flags
);
780 pp_cxx_right_bracket (cxx_pp
);
783 /* So that we can do dump_decl on an aggr type. */
787 dump_type (t
, flags
);
791 /* This is a pseudo destructor call which has not been folded into
792 a PSEUDO_DTOR_EXPR yet. */
793 pp_cxx_complement (cxx_pp
);
794 dump_type (TREE_OPERAND (t
, 0), flags
);
801 /* These special cases are duplicated here so that other functions
802 can feed identifiers to error and get them demangled properly. */
803 case IDENTIFIER_NODE
:
804 if (IDENTIFIER_TYPENAME_P (t
))
806 pp_cxx_identifier (cxx_pp
, "operator");
807 /* Not exactly IDENTIFIER_TYPE_VALUE. */
808 dump_type (TREE_TYPE (t
), flags
);
812 pp_cxx_tree_identifier (cxx_pp
, t
);
819 if (DECL_CLASS_SCOPE_P (t
))
821 dump_type (DECL_CONTEXT (t
), flags
);
822 pp_cxx_colon_colon (cxx_pp
);
824 else if (DECL_CONTEXT (t
))
826 dump_decl (DECL_CONTEXT (t
), flags
);
827 pp_cxx_colon_colon (cxx_pp
);
829 dump_decl (DECL_NAME (t
), flags
);
833 /* If there's only one function, just treat it like an ordinary
839 if (! DECL_LANG_SPECIFIC (t
))
840 pp_identifier (cxx_pp
, "<built-in>");
841 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
842 dump_global_iord (t
);
844 dump_function_decl (t
, flags
);
848 dump_template_decl (t
, flags
);
851 case TEMPLATE_ID_EXPR
:
853 tree name
= TREE_OPERAND (t
, 0);
855 if (is_overloaded_fn (name
))
856 name
= DECL_NAME (get_first_fn (name
));
857 dump_decl (name
, flags
);
858 pp_cxx_begin_template_argument_list (cxx_pp
);
859 if (TREE_OPERAND (t
, 1))
860 dump_template_argument_list (TREE_OPERAND (t
, 1), flags
);
861 pp_cxx_end_template_argument_list (cxx_pp
);
866 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (t
));
870 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
871 || (DECL_INITIAL (t
) &&
872 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
873 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
874 else if (DECL_NAME (t
))
875 dump_decl (DECL_NAME (t
), flags
);
876 else if (DECL_INITIAL (t
))
877 dump_expr (DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
879 pp_identifier (cxx_pp
, "<enumerator>");
883 pp_cxx_identifier (cxx_pp
, "using");
884 dump_type (USING_DECL_SCOPE (t
), flags
);
885 pp_cxx_colon_colon (cxx_pp
);
886 dump_decl (DECL_NAME (t
), flags
);
890 pp_cxx_declaration (cxx_pp
, t
);
894 dump_decl (BASELINK_FUNCTIONS (t
), flags
);
897 case NON_DEPENDENT_EXPR
:
898 dump_expr (t
, flags
);
901 case TEMPLATE_TYPE_PARM
:
902 if (flags
& TFF_DECL_SPECIFIERS
)
903 pp_cxx_declaration (cxx_pp
, t
);
905 pp_type_id (cxx_pp
, t
);
909 pp_unsupported_tree (cxx_pp
, t
);
910 /* Fall through to error. */
913 pp_identifier (cxx_pp
, "<declaration error>");
918 /* Dump a template declaration T under control of FLAGS. This means the
919 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
922 dump_template_decl (tree t
, int flags
)
924 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
928 if (flags
& TFF_TEMPLATE_HEADER
)
930 for (parms
= orig_parms
= nreverse (orig_parms
);
932 parms
= TREE_CHAIN (parms
))
934 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
935 int len
= TREE_VEC_LENGTH (inner_parms
);
937 pp_cxx_identifier (cxx_pp
, "template");
938 pp_cxx_begin_template_argument_list (cxx_pp
);
940 /* If we've shown the template prefix, we'd better show the
941 parameters' and decl's type too. */
942 flags
|= TFF_DECL_SPECIFIERS
;
944 for (i
= 0; i
< len
; i
++)
947 pp_separate_with_comma (cxx_pp
);
948 dump_template_parameter (TREE_VEC_ELT (inner_parms
, i
), flags
);
950 pp_cxx_end_template_argument_list (cxx_pp
);
951 pp_cxx_whitespace (cxx_pp
);
953 nreverse(orig_parms
);
955 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
956 /* Say `template<arg> class TT' not just `template<arg> TT'. */
957 pp_cxx_identifier (cxx_pp
, "class");
960 if (TREE_CODE (DECL_TEMPLATE_RESULT (t
)) == TYPE_DECL
)
961 dump_type (TREE_TYPE (t
),
962 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
963 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
964 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t
)) == VAR_DECL
)
965 dump_decl (DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
968 gcc_assert (TREE_TYPE (t
));
969 switch (NEXT_CODE (t
))
973 dump_function_decl (t
, flags
| TFF_TEMPLATE_NAME
);
976 /* This case can occur with some invalid code. */
977 dump_type (TREE_TYPE (t
),
978 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
979 | (flags
& TFF_DECL_SPECIFIERS
980 ? TFF_CLASS_KEY_OR_ENUM
: 0));
985 /* Pretty print a function decl. There are several ways we want to print a
986 function declaration. The TFF_ bits in FLAGS tells us how to behave.
987 As error can only apply the '#' flag once to give 0 and 1 for V, there
988 is %D which doesn't print the throw specs, and %F which does. */
991 dump_function_decl (tree t
, int flags
)
995 tree cname
= NULL_TREE
;
996 tree template_args
= NULL_TREE
;
997 tree template_parms
= NULL_TREE
;
998 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
1000 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1001 t
= DECL_TEMPLATE_RESULT (t
);
1003 /* Pretty print template instantiations only. */
1004 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
))
1008 template_args
= DECL_TI_ARGS (t
);
1009 tmpl
= most_general_template (t
);
1010 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1012 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1017 fntype
= TREE_TYPE (t
);
1018 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1020 if (DECL_CLASS_SCOPE_P (t
))
1021 cname
= DECL_CONTEXT (t
);
1022 /* This is for partially instantiated template methods. */
1023 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1024 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1026 if (!(flags
& TFF_DECL_SPECIFIERS
))
1028 else if (DECL_STATIC_FUNCTION_P (t
))
1029 pp_cxx_identifier (cxx_pp
, "static");
1030 else if (DECL_VIRTUAL_P (t
))
1031 pp_cxx_identifier (cxx_pp
, "virtual");
1033 /* Print the return type? */
1035 show_return
= !DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1036 && !DECL_DESTRUCTOR_P (t
);
1038 dump_type_prefix (TREE_TYPE (fntype
), flags
);
1040 /* Print the function name. */
1043 dump_type (cname
, flags
);
1044 pp_cxx_colon_colon (cxx_pp
);
1047 dump_scope (CP_DECL_CONTEXT (t
), flags
);
1049 dump_function_name (t
, flags
);
1051 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1053 dump_parameters (parmtypes
, flags
);
1055 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1057 pp_base (cxx_pp
)->padding
= pp_before
;
1058 pp_cxx_cv_qualifier_seq
1059 (cxx_pp
, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype
))));
1062 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1064 pp_base (cxx_pp
)->padding
= pp_before
;
1065 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype
), flags
);
1069 dump_type_suffix (TREE_TYPE (fntype
), flags
);
1072 /* If T is a template instantiation, dump the parameter binding. */
1073 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
)
1075 pp_cxx_whitespace (cxx_pp
);
1076 pp_cxx_left_bracket (cxx_pp
);
1077 pp_cxx_identifier (cxx_pp
, "with");
1078 pp_cxx_whitespace (cxx_pp
);
1079 dump_template_bindings (template_parms
, template_args
);
1080 pp_cxx_right_bracket (cxx_pp
);
1084 /* Print a parameter list. If this is for a member function, the
1085 member object ptr (and any other hidden args) should have
1086 already been removed. */
1089 dump_parameters (tree parmtypes
, int flags
)
1093 pp_cxx_left_paren (cxx_pp
);
1095 for (first
= 1; parmtypes
!= void_list_node
;
1096 parmtypes
= TREE_CHAIN (parmtypes
))
1099 pp_separate_with_comma (cxx_pp
);
1103 pp_cxx_identifier (cxx_pp
, "...");
1106 dump_type (TREE_VALUE (parmtypes
), flags
);
1108 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1110 pp_cxx_whitespace (cxx_pp
);
1112 pp_cxx_whitespace (cxx_pp
);
1113 dump_expr (TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1117 pp_cxx_right_paren (cxx_pp
);
1120 /* Print an exception specification. T is the exception specification. */
1123 dump_exception_spec (tree t
, int flags
)
1127 pp_cxx_identifier (cxx_pp
, "throw");
1128 pp_cxx_whitespace (cxx_pp
);
1129 pp_cxx_left_paren (cxx_pp
);
1130 if (TREE_VALUE (t
) != NULL_TREE
)
1133 dump_type (TREE_VALUE (t
), flags
);
1137 pp_separate_with_comma (cxx_pp
);
1139 pp_cxx_right_paren (cxx_pp
);
1143 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1144 and destructors properly. */
1147 dump_function_name (tree t
, int flags
)
1149 tree name
= DECL_NAME (t
);
1151 /* We can get here with a decl that was synthesized by language-
1152 independent machinery (e.g. coverage.c) in which case it won't
1153 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1154 will crash. In this case it is safe just to print out the
1156 if (!DECL_LANG_SPECIFIC (t
))
1158 pp_cxx_tree_identifier (cxx_pp
, name
);
1162 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1163 t
= DECL_TEMPLATE_RESULT (t
);
1165 /* Don't let the user see __comp_ctor et al. */
1166 if (DECL_CONSTRUCTOR_P (t
)
1167 || DECL_DESTRUCTOR_P (t
))
1168 name
= constructor_name (DECL_CONTEXT (t
));
1170 if (DECL_DESTRUCTOR_P (t
))
1172 pp_cxx_complement (cxx_pp
);
1173 dump_decl (name
, TFF_PLAIN_IDENTIFIER
);
1175 else if (DECL_CONV_FN_P (t
))
1177 /* This cannot use the hack that the operator's return
1178 type is stashed off of its name because it may be
1179 used for error reporting. In the case of conflicting
1180 declarations, both will have the same name, yet
1181 the types will be different, hence the TREE_TYPE field
1182 of the first name will be clobbered by the second. */
1183 pp_cxx_identifier (cxx_pp
, "operator");
1184 dump_type (TREE_TYPE (TREE_TYPE (t
)), flags
);
1186 else if (IDENTIFIER_OPNAME_P (name
))
1187 pp_cxx_tree_identifier (cxx_pp
, name
);
1189 dump_decl (name
, flags
);
1191 if (DECL_TEMPLATE_INFO (t
)
1192 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1193 && (TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1194 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1195 dump_template_parms (DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
), flags
);
1198 /* Dump the template parameters from the template info INFO under control of
1199 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1200 specialization (partial or complete). For partial specializations we show
1201 the specialized parameter values. For a primary template we show no
1205 dump_template_parms (tree info
, int primary
, int flags
)
1207 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1209 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1211 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1212 pp_cxx_begin_template_argument_list (cxx_pp
);
1214 /* Be careful only to print things when we have them, so as not
1215 to crash producing error messages. */
1216 if (args
&& !primary
)
1220 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
1221 args
= TREE_VEC_ELT (args
, TREE_VEC_LENGTH (args
) - 1);
1223 len
= TREE_VEC_LENGTH (args
);
1225 for (ix
= 0; ix
!= len
; ix
++)
1227 tree arg
= TREE_VEC_ELT (args
, ix
);
1230 pp_separate_with_comma (cxx_pp
);
1233 pp_identifier (cxx_pp
, "<template parameter error>");
1235 dump_template_argument (arg
, flags
);
1240 tree tpl
= TI_TEMPLATE (info
);
1241 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1244 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1245 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1247 for (ix
= 0; ix
!= len
; ix
++)
1251 if (TREE_VEC_ELT (parms
, ix
) == error_mark_node
)
1253 pp_identifier (cxx_pp
, "<template parameter error>");
1257 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1260 pp_separate_with_comma (cxx_pp
);
1262 dump_decl (parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1265 pp_cxx_end_template_argument_list (cxx_pp
);
1268 /* Print out a list of initializers (subr of dump_expr). */
1271 dump_expr_list (tree l
, int flags
)
1275 dump_expr (TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1278 pp_separate_with_comma (cxx_pp
);
1282 /* Print out a vector of initializers (subr of dump_expr). */
1285 dump_expr_init_vec (VEC(constructor_elt
,gc
) *v
, int flags
)
1287 unsigned HOST_WIDE_INT idx
;
1290 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1292 dump_expr (value
, flags
| TFF_EXPR_IN_PARENS
);
1293 if (idx
!= VEC_length (constructor_elt
, v
) - 1)
1294 pp_separate_with_comma (cxx_pp
);
1299 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1300 function. Resolve it to a close relative -- in the sense of static
1301 type -- variant being overridden. That is close to what was written in
1302 the source code. Subroutine of dump_expr. */
1305 resolve_virtual_fun_from_obj_type_ref (tree ref
)
1307 tree obj_type
= TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref
));
1308 int index
= tree_low_cst (OBJ_TYPE_REF_TOKEN (ref
), 1);
1309 tree fun
= BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type
)));
1311 fun
= TREE_CHAIN (fun
);
1316 /* Print out an expression E under control of FLAGS. */
1319 dump_expr (tree t
, int flags
)
1324 switch (TREE_CODE (t
))
1332 case NAMESPACE_DECL
:
1335 case IDENTIFIER_NODE
:
1336 dump_decl (t
, (flags
& ~TFF_DECL_SPECIFIERS
) | TFF_NO_FUNCTION_ARGUMENTS
);
1342 pp_constant (cxx_pp
, t
);
1346 pp_cxx_identifier (cxx_pp
, "throw");
1347 dump_expr (TREE_OPERAND (t
, 0), flags
);
1351 pp_ampersand (cxx_pp
);
1352 dump_type (PTRMEM_CST_CLASS (t
), flags
);
1353 pp_cxx_colon_colon (cxx_pp
);
1354 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
1358 pp_cxx_left_paren (cxx_pp
);
1359 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1360 pp_separate_with_comma (cxx_pp
);
1361 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1362 pp_cxx_right_paren (cxx_pp
);
1366 pp_cxx_left_paren (cxx_pp
);
1367 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1368 pp_string (cxx_pp
, " ? ");
1369 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1370 pp_string (cxx_pp
, " : ");
1371 dump_expr (TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
1372 pp_cxx_right_paren (cxx_pp
);
1376 if (TREE_HAS_CONSTRUCTOR (t
))
1378 pp_cxx_identifier (cxx_pp
, "new");
1379 pp_cxx_whitespace (cxx_pp
);
1380 dump_type (TREE_TYPE (TREE_TYPE (t
)), flags
);
1383 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1386 case AGGR_INIT_EXPR
:
1388 tree fn
= NULL_TREE
;
1390 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
)
1391 fn
= TREE_OPERAND (TREE_OPERAND (t
, 0), 0);
1393 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
1395 if (DECL_CONSTRUCTOR_P (fn
))
1396 dump_type (DECL_CONTEXT (fn
), flags
);
1401 dump_expr (TREE_OPERAND (t
, 0), 0);
1403 pp_cxx_left_paren (cxx_pp
);
1404 if (TREE_OPERAND (t
, 1))
1405 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t
, 1)), flags
);
1406 pp_cxx_right_paren (cxx_pp
);
1411 tree fn
= TREE_OPERAND (t
, 0);
1412 tree args
= TREE_OPERAND (t
, 1);
1414 if (TREE_CODE (fn
) == ADDR_EXPR
)
1415 fn
= TREE_OPERAND (fn
, 0);
1417 /* Nobody is interested in seeing the guts of vcalls. */
1418 if (TREE_CODE (fn
) == OBJ_TYPE_REF
)
1419 fn
= resolve_virtual_fun_from_obj_type_ref (fn
);
1421 if (TREE_TYPE (fn
) != NULL_TREE
&& NEXT_CODE (fn
) == METHOD_TYPE
)
1423 tree ob
= TREE_VALUE (args
);
1424 if (TREE_CODE (ob
) == ADDR_EXPR
)
1426 dump_expr (TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
1429 else if (TREE_CODE (ob
) != PARM_DECL
1430 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
1432 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1435 args
= TREE_CHAIN (args
);
1437 dump_expr (fn
, flags
| TFF_EXPR_IN_PARENS
);
1438 pp_cxx_left_paren (cxx_pp
);
1439 dump_expr_list (args
, flags
);
1440 pp_cxx_right_paren (cxx_pp
);
1446 tree type
= TREE_OPERAND (t
, 1);
1447 tree init
= TREE_OPERAND (t
, 2);
1448 if (NEW_EXPR_USE_GLOBAL (t
))
1449 pp_cxx_colon_colon (cxx_pp
);
1450 pp_cxx_identifier (cxx_pp
, "new");
1451 if (TREE_OPERAND (t
, 0))
1453 pp_cxx_left_paren (cxx_pp
);
1454 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
1455 pp_cxx_right_paren (cxx_pp
);
1456 pp_cxx_whitespace (cxx_pp
);
1458 if (TREE_CODE (type
) == ARRAY_REF
)
1459 type
= build_cplus_array_type
1460 (TREE_OPERAND (type
, 0),
1461 build_index_type (fold_build2 (MINUS_EXPR
, integer_type_node
,
1462 TREE_OPERAND (type
, 1),
1463 integer_one_node
)));
1464 dump_type (type
, flags
);
1467 pp_cxx_left_paren (cxx_pp
);
1468 if (TREE_CODE (init
) == TREE_LIST
)
1469 dump_expr_list (init
, flags
);
1470 else if (init
== void_zero_node
)
1471 /* This representation indicates an empty initializer,
1472 e.g.: "new int()". */
1475 dump_expr (init
, flags
);
1476 pp_cxx_right_paren (cxx_pp
);
1482 /* Note that this only works for G++ target exprs. If somebody
1483 builds a general TARGET_EXPR, there's no way to represent that
1484 it initializes anything other that the parameter slot for the
1485 default argument. Note we may have cleared out the first
1486 operand in expand_expr, so don't go killing ourselves. */
1487 if (TREE_OPERAND (t
, 1))
1488 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1496 case TRUNC_DIV_EXPR
:
1497 case TRUNC_MOD_EXPR
:
1505 case TRUTH_ANDIF_EXPR
:
1506 case TRUTH_ORIF_EXPR
:
1513 case EXACT_DIV_EXPR
:
1514 dump_binary_op (operator_name_info
[(int) TREE_CODE (t
)].name
, t
, flags
);
1518 case FLOOR_DIV_EXPR
:
1519 case ROUND_DIV_EXPR
:
1521 dump_binary_op ("/", t
, flags
);
1525 case FLOOR_MOD_EXPR
:
1526 case ROUND_MOD_EXPR
:
1527 dump_binary_op ("%", t
, flags
);
1532 tree ob
= TREE_OPERAND (t
, 0);
1533 if (TREE_CODE (ob
) == INDIRECT_REF
)
1535 ob
= TREE_OPERAND (ob
, 0);
1536 if (TREE_CODE (ob
) != PARM_DECL
1538 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this")))
1540 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1541 pp_cxx_arrow (cxx_pp
);
1546 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1547 pp_cxx_dot (cxx_pp
);
1549 dump_expr (TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
1554 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1555 pp_cxx_left_bracket (cxx_pp
);
1556 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1557 pp_cxx_right_bracket (cxx_pp
);
1560 case UNARY_PLUS_EXPR
:
1561 dump_unary_op ("+", t
, flags
);
1565 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
1566 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
1567 /* An ADDR_EXPR can have reference type. In that case, we
1568 shouldn't print the `&' doing so indicates to the user
1569 that the expression has pointer type. */
1571 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
1572 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1573 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
1574 dump_unary_op ("&&", t
, flags
);
1576 dump_unary_op ("&", t
, flags
);
1580 if (TREE_HAS_CONSTRUCTOR (t
))
1582 t
= TREE_OPERAND (t
, 0);
1583 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
1584 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1585 pp_cxx_left_paren (cxx_pp
);
1586 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t
, 1)), flags
);
1587 pp_cxx_right_paren (cxx_pp
);
1591 if (TREE_OPERAND (t
,0) != NULL_TREE
1592 && TREE_TYPE (TREE_OPERAND (t
, 0))
1593 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
1594 dump_expr (TREE_OPERAND (t
, 0), flags
);
1596 dump_unary_op ("*", t
, flags
);
1602 case TRUTH_NOT_EXPR
:
1603 case PREDECREMENT_EXPR
:
1604 case PREINCREMENT_EXPR
:
1605 dump_unary_op (operator_name_info
[(int)TREE_CODE (t
)].name
, t
, flags
);
1608 case POSTDECREMENT_EXPR
:
1609 case POSTINCREMENT_EXPR
:
1610 pp_cxx_left_paren (cxx_pp
);
1611 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1612 pp_cxx_identifier (cxx_pp
, operator_name_info
[(int)TREE_CODE (t
)].name
);
1613 pp_cxx_right_paren (cxx_pp
);
1616 case NON_LVALUE_EXPR
:
1617 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1618 should be another level of INDIRECT_REF so that I don't have to do
1620 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
1622 tree next
= TREE_TYPE (TREE_TYPE (t
));
1624 while (TREE_CODE (next
) == POINTER_TYPE
)
1625 next
= TREE_TYPE (next
);
1627 if (TREE_CODE (next
) == FUNCTION_TYPE
)
1629 if (flags
& TFF_EXPR_IN_PARENS
)
1630 pp_cxx_left_paren (cxx_pp
);
1631 pp_cxx_star (cxx_pp
);
1632 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1633 if (flags
& TFF_EXPR_IN_PARENS
)
1634 pp_cxx_right_paren (cxx_pp
);
1637 /* Else fall through. */
1639 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1645 tree op
= TREE_OPERAND (t
, 0);
1647 if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
1649 /* It is a cast, but we cannot tell whether it is a
1650 reinterpret or static cast. Use the C style notation. */
1651 if (flags
& TFF_EXPR_IN_PARENS
)
1652 pp_cxx_left_paren (cxx_pp
);
1653 pp_cxx_left_paren (cxx_pp
);
1654 dump_type (TREE_TYPE (t
), flags
);
1655 pp_cxx_right_paren (cxx_pp
);
1656 dump_expr (op
, flags
| TFF_EXPR_IN_PARENS
);
1657 if (flags
& TFF_EXPR_IN_PARENS
)
1658 pp_cxx_right_paren (cxx_pp
);
1661 dump_expr (op
, flags
);
1666 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
1668 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
1670 if (integer_zerop (idx
))
1672 /* A NULL pointer-to-member constant. */
1673 pp_cxx_left_paren (cxx_pp
);
1674 pp_cxx_left_paren (cxx_pp
);
1675 dump_type (TREE_TYPE (t
), flags
);
1676 pp_cxx_right_paren (cxx_pp
);
1677 pp_character (cxx_pp
, '0');
1678 pp_cxx_right_paren (cxx_pp
);
1681 else if (host_integerp (idx
, 0))
1684 unsigned HOST_WIDE_INT n
;
1686 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
1687 t
= TYPE_METHOD_BASETYPE (t
);
1688 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
1690 n
= tree_low_cst (idx
, 0);
1692 /* Map vtable index back one, to allow for the null pointer to
1696 while (n
> 0 && virtuals
)
1699 virtuals
= TREE_CHAIN (virtuals
);
1703 dump_expr (BV_FN (virtuals
),
1704 flags
| TFF_EXPR_IN_PARENS
);
1709 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
1711 dump_type (TREE_TYPE (t
), 0);
1712 pp_cxx_left_paren (cxx_pp
);
1713 pp_cxx_right_paren (cxx_pp
);
1717 pp_cxx_left_brace (cxx_pp
);
1718 dump_expr_init_vec (CONSTRUCTOR_ELTS (t
), flags
);
1719 pp_cxx_right_brace (cxx_pp
);
1726 tree ob
= TREE_OPERAND (t
, 0);
1727 if (is_dummy_object (ob
))
1729 t
= TREE_OPERAND (t
, 1);
1730 if (TREE_CODE (t
) == FUNCTION_DECL
)
1732 dump_expr (t
, flags
| TFF_EXPR_IN_PARENS
);
1733 else if (BASELINK_P (t
))
1734 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t
)),
1735 flags
| TFF_EXPR_IN_PARENS
);
1737 dump_decl (t
, flags
);
1741 if (TREE_CODE (ob
) == INDIRECT_REF
)
1743 dump_expr (TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
1744 pp_cxx_arrow (cxx_pp
);
1745 pp_cxx_star (cxx_pp
);
1749 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1750 pp_cxx_dot (cxx_pp
);
1751 pp_cxx_star (cxx_pp
);
1753 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1758 case TEMPLATE_PARM_INDEX
:
1759 dump_decl (TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
1763 pp_expression (cxx_pp
, t
);
1767 if (TREE_OPERAND (t
, 0) == NULL_TREE
1768 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
1770 dump_type (TREE_TYPE (t
), flags
);
1771 pp_cxx_left_paren (cxx_pp
);
1772 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
1773 pp_cxx_right_paren (cxx_pp
);
1777 pp_cxx_left_paren (cxx_pp
);
1778 dump_type (TREE_TYPE (t
), flags
);
1779 pp_cxx_right_paren (cxx_pp
);
1780 pp_cxx_left_paren (cxx_pp
);
1781 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
1782 pp_cxx_right_paren (cxx_pp
);
1786 case STATIC_CAST_EXPR
:
1787 pp_cxx_identifier (cxx_pp
, "static_cast");
1789 case REINTERPRET_CAST_EXPR
:
1790 pp_cxx_identifier (cxx_pp
, "reinterpret_cast");
1792 case CONST_CAST_EXPR
:
1793 pp_cxx_identifier (cxx_pp
, "const_cast");
1795 case DYNAMIC_CAST_EXPR
:
1796 pp_cxx_identifier (cxx_pp
, "dynamic_cast");
1798 pp_cxx_begin_template_argument_list (cxx_pp
);
1799 dump_type (TREE_TYPE (t
), flags
);
1800 pp_cxx_end_template_argument_list (cxx_pp
);
1801 pp_cxx_left_paren (cxx_pp
);
1802 dump_expr (TREE_OPERAND (t
, 0), flags
);
1803 pp_cxx_right_paren (cxx_pp
);
1807 dump_expr (TREE_OPERAND (t
, 0), flags
);
1808 pp_cxx_arrow (cxx_pp
);
1813 if (TREE_CODE (t
) == SIZEOF_EXPR
)
1814 pp_cxx_identifier (cxx_pp
, "sizeof");
1817 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
1818 pp_cxx_identifier (cxx_pp
, "__alignof__");
1820 pp_cxx_whitespace (cxx_pp
);
1821 pp_cxx_left_paren (cxx_pp
);
1822 if (TYPE_P (TREE_OPERAND (t
, 0)))
1823 dump_type (TREE_OPERAND (t
, 0), flags
);
1825 dump_expr (TREE_OPERAND (t
, 0), flags
);
1826 pp_cxx_right_paren (cxx_pp
);
1831 pp_cxx_identifier (cxx_pp
, operator_name_info
[TREE_CODE (t
)].name
);
1832 pp_cxx_whitespace (cxx_pp
);
1833 dump_expr (TREE_OPERAND (t
, 0), flags
);
1837 pp_identifier (cxx_pp
, "<unparsed>");
1840 case TRY_CATCH_EXPR
:
1841 case WITH_CLEANUP_EXPR
:
1842 case CLEANUP_POINT_EXPR
:
1843 dump_expr (TREE_OPERAND (t
, 0), flags
);
1846 case PSEUDO_DTOR_EXPR
:
1847 dump_expr (TREE_OPERAND (t
, 2), flags
);
1848 pp_cxx_dot (cxx_pp
);
1849 dump_type (TREE_OPERAND (t
, 0), flags
);
1850 pp_cxx_colon_colon (cxx_pp
);
1851 pp_cxx_complement (cxx_pp
);
1852 dump_type (TREE_OPERAND (t
, 1), flags
);
1855 case TEMPLATE_ID_EXPR
:
1856 dump_decl (t
, flags
);
1861 case STATEMENT_LIST
:
1862 /* We don't yet have a way of dumping statements in a
1863 human-readable format. */
1864 pp_string (cxx_pp
, "({...})");
1868 pp_string (cxx_pp
, "while (1) { ");
1869 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1870 pp_cxx_right_brace (cxx_pp
);
1874 pp_string (cxx_pp
, "if (");
1875 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1876 pp_string (cxx_pp
, ") break; ");
1880 dump_expr (get_first_fn (t
), flags
& ~TFF_EXPR_IN_PARENS
);
1883 case EMPTY_CLASS_EXPR
:
1884 dump_type (TREE_TYPE (t
), flags
);
1885 pp_cxx_left_paren (cxx_pp
);
1886 pp_cxx_right_paren (cxx_pp
);
1889 case NON_DEPENDENT_EXPR
:
1890 dump_expr (TREE_OPERAND (t
, 0), flags
);
1893 /* This list is incomplete, but should suffice for now.
1894 It is very important that `sorry' does not call
1895 `report_error_function'. That could cause an infinite loop. */
1897 pp_unsupported_tree (cxx_pp
, t
);
1898 /* fall through to ERROR_MARK... */
1900 pp_identifier (cxx_pp
, "<expression error>");
1906 dump_binary_op (const char *opstring
, tree t
, int flags
)
1908 pp_cxx_left_paren (cxx_pp
);
1909 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1910 pp_cxx_whitespace (cxx_pp
);
1912 pp_cxx_identifier (cxx_pp
, opstring
);
1914 pp_identifier (cxx_pp
, "<unknown operator>");
1915 pp_cxx_whitespace (cxx_pp
);
1916 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1917 pp_cxx_right_paren (cxx_pp
);
1921 dump_unary_op (const char *opstring
, tree t
, int flags
)
1923 if (flags
& TFF_EXPR_IN_PARENS
)
1924 pp_cxx_left_paren (cxx_pp
);
1925 pp_cxx_identifier (cxx_pp
, opstring
);
1926 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1927 if (flags
& TFF_EXPR_IN_PARENS
)
1928 pp_cxx_right_paren (cxx_pp
);
1932 reinit_cxx_pp (void)
1934 pp_clear_output_area (cxx_pp
);
1935 pp_base (cxx_pp
)->padding
= pp_none
;
1936 pp_indentation (cxx_pp
) = 0;
1937 pp_needs_newline (cxx_pp
) = false;
1938 cxx_pp
->enclosing_scope
= 0;
1942 /* Exported interface to stringifying types, exprs and decls under TFF_*
1946 type_as_string (tree typ
, int flags
)
1949 dump_type (typ
, flags
);
1950 return pp_formatted_text (cxx_pp
);
1954 expr_as_string (tree decl
, int flags
)
1957 dump_expr (decl
, flags
);
1958 return pp_formatted_text (cxx_pp
);
1962 decl_as_string (tree decl
, int flags
)
1965 dump_decl (decl
, flags
);
1966 return pp_formatted_text (cxx_pp
);
1969 /* Generate the three forms of printable names for cxx_printable_name. */
1972 lang_decl_name (tree decl
, int v
)
1975 return decl_as_string (decl
, TFF_DECL_SPECIFIERS
);
1978 if (v
== 1 && DECL_CLASS_SCOPE_P (decl
))
1980 dump_type (CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
1981 pp_cxx_colon_colon (cxx_pp
);
1984 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1985 dump_function_name (decl
, TFF_PLAIN_IDENTIFIER
);
1987 dump_decl (DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
1989 return pp_formatted_text (cxx_pp
);
1992 /* Return the location of a tree passed to %+ formats. */
1995 location_of (tree t
)
1997 if (TREE_CODE (t
) == PARM_DECL
&& DECL_CONTEXT (t
))
1998 t
= DECL_CONTEXT (t
);
1999 else if (TYPE_P (t
))
2000 t
= TYPE_MAIN_DECL (t
);
2001 else if (TREE_CODE (t
) == OVERLOAD
)
2002 t
= OVL_FUNCTION (t
);
2004 return DECL_SOURCE_LOCATION (t
);
2007 /* Now the interfaces from error et al to dump_type et al. Each takes an
2008 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2012 decl_to_string (tree decl
, int verbose
)
2016 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
2017 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
2018 flags
= TFF_CLASS_KEY_OR_ENUM
;
2020 flags
|= TFF_DECL_SPECIFIERS
;
2021 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
2022 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
2023 flags
|= TFF_TEMPLATE_HEADER
;
2026 dump_decl (decl
, flags
);
2027 return pp_formatted_text (cxx_pp
);
2031 expr_to_string (tree decl
)
2034 dump_expr (decl
, 0);
2035 return pp_formatted_text (cxx_pp
);
2039 fndecl_to_string (tree fndecl
, int verbose
)
2043 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
2044 | TFF_TEMPLATE_HEADER
;
2046 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
2048 dump_decl (fndecl
, flags
);
2049 return pp_formatted_text (cxx_pp
);
2054 code_to_string (enum tree_code c
)
2056 return tree_code_name
[c
];
2060 language_to_string (enum languages c
)
2067 case lang_cplusplus
:
2079 /* Return the proper printed version of a parameter to a C++ function. */
2082 parm_to_string (int p
)
2086 pp_string (cxx_pp
, "'this'");
2088 pp_decimal_int (cxx_pp
, p
+ 1);
2089 return pp_formatted_text (cxx_pp
);
2093 op_to_string (enum tree_code p
)
2095 tree id
= operator_name_info
[(int) p
].identifier
;
2096 return id
? IDENTIFIER_POINTER (id
) : "<unknown>";
2100 type_to_string (tree typ
, int verbose
)
2104 flags
|= TFF_CLASS_KEY_OR_ENUM
;
2105 flags
|= TFF_TEMPLATE_HEADER
;
2108 dump_type (typ
, flags
);
2109 return pp_formatted_text (cxx_pp
);
2113 assop_to_string (enum tree_code p
)
2115 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
2116 return id
? IDENTIFIER_POINTER (id
) : "{unknown}";
2120 args_to_string (tree p
, int verbose
)
2124 flags
|= TFF_CLASS_KEY_OR_ENUM
;
2129 if (TYPE_P (TREE_VALUE (p
)))
2130 return type_as_string (p
, flags
);
2133 for (; p
; p
= TREE_CHAIN (p
))
2135 if (TREE_VALUE (p
) == null_node
)
2136 pp_cxx_identifier (cxx_pp
, "NULL");
2138 dump_type (error_type (TREE_VALUE (p
)), flags
);
2140 pp_separate_with_comma (cxx_pp
);
2142 return pp_formatted_text (cxx_pp
);
2146 cv_to_string (tree p
, int v
)
2149 pp_base (cxx_pp
)->padding
= v
? pp_before
: pp_none
;
2150 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
2151 return pp_formatted_text (cxx_pp
);
2154 /* Langhook for print_error_function. */
2156 cxx_print_error_function (diagnostic_context
*context
, const char *file
)
2158 lhd_print_error_function (context
, file
);
2159 pp_base_set_prefix (context
->printer
, file
);
2160 maybe_print_instantiation_context (context
);
2164 cp_diagnostic_starter (diagnostic_context
*context
,
2165 diagnostic_info
*diagnostic
)
2167 diagnostic_report_current_module (context
);
2168 cp_print_error_function (context
, diagnostic
);
2169 maybe_print_instantiation_context (context
);
2170 pp_base_set_prefix (context
->printer
, diagnostic_build_prefix (diagnostic
));
2174 cp_diagnostic_finalizer (diagnostic_context
*context
,
2175 diagnostic_info
*diagnostic ATTRIBUTE_UNUSED
)
2177 pp_base_destroy_prefix (context
->printer
);
2180 /* Print current function onto BUFFER, in the process of reporting
2181 a diagnostic message. Called from cp_diagnostic_starter. */
2183 cp_print_error_function (diagnostic_context
*context
,
2184 diagnostic_info
*diagnostic
)
2186 if (diagnostic_last_function_changed (context
))
2188 const char *old_prefix
= context
->printer
->prefix
;
2189 const char *file
= LOCATION_FILE (diagnostic
->location
);
2190 char *new_prefix
= file
? file_name_as_prefix (file
) : NULL
;
2192 pp_base_set_prefix (context
->printer
, new_prefix
);
2194 if (current_function_decl
== NULL
)
2195 pp_base_string (context
->printer
, "At global scope:");
2197 pp_printf (context
->printer
, "In %s %qs:",
2198 function_category (current_function_decl
),
2199 cxx_printable_name (current_function_decl
, 2));
2200 pp_base_newline (context
->printer
);
2202 diagnostic_set_last_function (context
);
2203 pp_base_destroy_prefix (context
->printer
);
2204 context
->printer
->prefix
= old_prefix
;
2208 /* Returns a description of FUNCTION using standard terminology. */
2210 function_category (tree fn
)
2212 if (DECL_FUNCTION_MEMBER_P (fn
))
2214 if (DECL_STATIC_FUNCTION_P (fn
))
2215 return "static member function";
2216 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
2217 return "copy constructor";
2218 else if (DECL_CONSTRUCTOR_P (fn
))
2219 return "constructor";
2220 else if (DECL_DESTRUCTOR_P (fn
))
2221 return "destructor";
2223 return "member function";
2229 /* Report the full context of a current template instantiation,
2232 print_instantiation_full_context (diagnostic_context
*context
)
2234 tree p
= current_instantiation ();
2235 location_t location
= input_location
;
2239 if (current_function_decl
!= TINST_DECL (p
)
2240 && current_function_decl
!= NULL_TREE
)
2241 /* We can get here during the processing of some synthesized
2242 method. Then, TINST_DECL (p) will be the function that's causing
2247 if (current_function_decl
== TINST_DECL (p
))
2248 /* Avoid redundancy with the "In function" line. */;
2250 pp_verbatim (context
->printer
,
2251 "%s: In instantiation of %qs:\n",
2252 LOCATION_FILE (location
),
2253 decl_as_string (TINST_DECL (p
),
2254 TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
));
2256 location
= TINST_LOCATION (p
);
2261 print_instantiation_partial_context (context
, p
, location
);
2264 /* Same as above but less verbose. */
2266 print_instantiation_partial_context (diagnostic_context
*context
,
2267 tree t
, location_t loc
)
2269 expanded_location xloc
;
2270 for (; ; t
= TREE_CHAIN (t
))
2272 xloc
= expand_location (loc
);
2275 pp_verbatim (context
->printer
, "%s:%d: instantiated from %qs\n",
2276 xloc
.file
, xloc
.line
,
2277 decl_as_string (TINST_DECL (t
),
2278 TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
));
2279 loc
= TINST_LOCATION (t
);
2281 pp_verbatim (context
->printer
, "%s:%d: instantiated from here",
2282 xloc
.file
, xloc
.line
);
2283 pp_base_newline (context
->printer
);
2286 /* Called from cp_thing to print the template context for an error. */
2288 maybe_print_instantiation_context (diagnostic_context
*context
)
2290 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2293 record_last_problematic_instantiation ();
2294 print_instantiation_full_context (context
);
2297 /* Report the bare minimum context of a template instantiation. */
2299 print_instantiation_context (void)
2301 print_instantiation_partial_context
2302 (global_dc
, current_instantiation (), input_location
);
2303 diagnostic_flush_buffer (global_dc
);
2306 /* Called from output_format -- during diagnostic message processing --
2307 to handle C++ specific format specifier with the following meanings:
2308 %A function argument-list.
2312 %F function declaration.
2313 %L language as used in extern "lang".
2315 %P function parameter whose position is indicated by an integer.
2316 %Q assignment operator.
2320 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
2321 int precision
, bool wide
, bool set_locus
, bool verbose
)
2325 #define next_tree (t = va_arg (*text->args_ptr, tree))
2326 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2327 #define next_lang va_arg (*text->args_ptr, enum languages)
2328 #define next_int va_arg (*text->args_ptr, int)
2330 if (precision
!= 0 || wide
)
2333 if (text
->locus
== NULL
)
2338 case 'A': result
= args_to_string (next_tree
, verbose
); break;
2339 case 'C': result
= code_to_string (next_tcode
); break;
2340 case 'D': result
= decl_to_string (next_tree
, verbose
); break;
2341 case 'E': result
= expr_to_string (next_tree
); break;
2342 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
2343 case 'L': result
= language_to_string (next_lang
); break;
2344 case 'O': result
= op_to_string (next_tcode
); break;
2345 case 'P': result
= parm_to_string (next_int
); break;
2346 case 'Q': result
= assop_to_string (next_tcode
); break;
2347 case 'T': result
= type_to_string (next_tree
, verbose
); break;
2348 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
2354 pp_base_string (pp
, result
);
2355 if (set_locus
&& t
!= NULL
)
2356 *text
->locus
= location_of (t
);
2364 /* Callback from cpp_error for PFILE to print diagnostics arising from
2365 interpreting strings. The diagnostic is of type LEVEL; MSG is the
2366 translated message and AP the arguments. */
2369 cp_cpp_error (cpp_reader
*pfile ATTRIBUTE_UNUSED
, int level
,
2370 const char *msg
, va_list *ap
)
2372 diagnostic_info diagnostic
;
2373 diagnostic_t dlevel
;
2376 case CPP_DL_WARNING
:
2377 case CPP_DL_WARNING_SYSHDR
:
2378 dlevel
= DK_WARNING
;
2380 case CPP_DL_PEDWARN
:
2381 dlevel
= pedantic_error_kind ();
2392 diagnostic_set_info_translated (&diagnostic
, msg
, ap
,
2393 input_location
, dlevel
);
2394 report_diagnostic (&diagnostic
);