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, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, 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
*);
90 static tree
locate_error (const char *, va_list);
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
, "<unknown 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 && (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
)
441 || TREE_CODE (CLASSTYPE_TI_TEMPLATE (t
)) != TEMPLATE_DECL
442 || DECL_TEMPLATE_SPECIALIZATION (CLASSTYPE_TI_TEMPLATE (t
))
443 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)));
444 dump_scope (CP_DECL_CONTEXT (name
), flags
| TFF_SCOPE
);
447 /* Because the template names are mangled, we have to locate
448 the most general template, and use that name. */
449 tree tpl
= CLASSTYPE_TI_TEMPLATE (t
);
451 while (DECL_TEMPLATE_INFO (tpl
))
452 tpl
= DECL_TI_TEMPLATE (tpl
);
455 name
= DECL_NAME (name
);
458 if (name
== 0 || ANON_AGGRNAME_P (name
))
460 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
461 pp_identifier (cxx_pp
, "<anonymous>");
463 pp_printf (pp_base (cxx_pp
), "<anonymous %s>", variety
);
466 pp_cxx_tree_identifier (cxx_pp
, name
);
468 dump_template_parms (TYPE_TEMPLATE_INFO (t
),
469 !CLASSTYPE_USE_TEMPLATE (t
),
470 flags
& ~TFF_TEMPLATE_HEADER
);
473 /* Dump into the obstack the initial part of the output for a given type.
474 This is necessary when dealing with things like functions returning
477 return type of `int (* fee ())()': pointer -> function -> int. Both
478 pointer (and reference and offset) and function (and member) types must
479 deal with prefix and suffix.
481 Arrays must also do this for DECL nodes, like int a[], and for things like
485 dump_type_prefix (tree t
, int flags
)
487 if (TYPE_PTRMEMFUNC_P (t
))
489 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
493 switch (TREE_CODE (t
))
498 tree sub
= TREE_TYPE (t
);
500 dump_type_prefix (sub
, flags
);
501 if (TREE_CODE (sub
) == ARRAY_TYPE
)
503 pp_cxx_whitespace (cxx_pp
);
504 pp_cxx_left_paren (cxx_pp
);
506 pp_character (cxx_pp
, "&*"[TREE_CODE (t
) == POINTER_TYPE
]);
507 pp_base (cxx_pp
)->padding
= pp_before
;
508 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
514 dump_type_prefix (TREE_TYPE (t
), flags
);
515 if (TREE_CODE (t
) == OFFSET_TYPE
) /* pmfs deal with this in d_t_p */
517 pp_maybe_space (cxx_pp
);
518 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
519 pp_cxx_left_paren (cxx_pp
);
520 dump_type (TYPE_OFFSET_BASETYPE (t
), flags
);
521 pp_cxx_colon_colon (cxx_pp
);
523 pp_cxx_star (cxx_pp
);
524 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
525 pp_base (cxx_pp
)->padding
= pp_before
;
528 /* Can only be reached through function pointer -- this would not be
529 correct if FUNCTION_DECLs used it. */
531 dump_type_prefix (TREE_TYPE (t
), flags
);
532 pp_maybe_space (cxx_pp
);
533 pp_cxx_left_paren (cxx_pp
);
537 dump_type_prefix (TREE_TYPE (t
), flags
);
538 pp_maybe_space (cxx_pp
);
539 pp_cxx_left_paren (cxx_pp
);
540 dump_aggr_type (TYPE_METHOD_BASETYPE (t
), flags
);
541 pp_cxx_colon_colon (cxx_pp
);
545 dump_type_prefix (TREE_TYPE (t
), flags
);
549 case IDENTIFIER_NODE
:
554 case TEMPLATE_TYPE_PARM
:
555 case TEMPLATE_TEMPLATE_PARM
:
556 case BOUND_TEMPLATE_TEMPLATE_PARM
:
567 dump_type (t
, flags
);
568 pp_base (cxx_pp
)->padding
= pp_before
;
572 pp_unsupported_tree (cxx_pp
, t
);
575 pp_identifier (cxx_pp
, "<typeprefixerror>");
580 /* Dump the suffix of type T, under control of FLAGS. This is the part
581 which appears after the identifier (or function parms). */
584 dump_type_suffix (tree t
, int flags
)
586 if (TYPE_PTRMEMFUNC_P (t
))
587 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
589 switch (TREE_CODE (t
))
594 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
595 pp_cxx_right_paren (cxx_pp
);
596 dump_type_suffix (TREE_TYPE (t
), flags
);
599 /* Can only be reached through function pointer. */
604 pp_cxx_right_paren (cxx_pp
);
605 arg
= TYPE_ARG_TYPES (t
);
606 if (TREE_CODE (t
) == METHOD_TYPE
)
607 arg
= TREE_CHAIN (arg
);
609 /* Function pointers don't have default args. Not in standard C++,
610 anyway; they may in g++, but we'll just pretend otherwise. */
611 dump_parameters (arg
, flags
& ~TFF_FUNCTION_DEFAULT_ARGUMENTS
);
613 if (TREE_CODE (t
) == METHOD_TYPE
)
614 pp_cxx_cv_qualifier_seq
615 (cxx_pp
, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t
))));
617 pp_cxx_cv_qualifier_seq(cxx_pp
, t
);
618 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t
), flags
);
619 dump_type_suffix (TREE_TYPE (t
), flags
);
624 pp_maybe_space (cxx_pp
);
625 pp_cxx_left_bracket (cxx_pp
);
628 if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t
)), 0))
630 (cxx_pp
, tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t
)), 0) + 1);
631 else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t
))) == MINUS_EXPR
)
632 dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t
)), 0),
633 flags
& ~TFF_EXPR_IN_PARENS
);
635 dump_expr (fold (cp_build_binary_op
636 (PLUS_EXPR
, TYPE_MAX_VALUE (TYPE_DOMAIN (t
)),
638 flags
& ~TFF_EXPR_IN_PARENS
);
640 pp_cxx_right_bracket (cxx_pp
);
641 dump_type_suffix (TREE_TYPE (t
), flags
);
645 case IDENTIFIER_NODE
:
650 case TEMPLATE_TYPE_PARM
:
651 case TEMPLATE_TEMPLATE_PARM
:
652 case BOUND_TEMPLATE_TEMPLATE_PARM
:
666 pp_unsupported_tree (cxx_pp
, t
);
668 /* Don't mark it here, we should have already done in
675 dump_global_iord (tree t
)
677 const char *p
= NULL
;
679 if (DECL_GLOBAL_CTOR_P (t
))
681 else if (DECL_GLOBAL_DTOR_P (t
))
686 pp_printf (pp_base (cxx_pp
), "(static %s for %s)", p
, input_filename
);
690 dump_simple_decl (tree t
, tree type
, int flags
)
692 if (flags
& TFF_DECL_SPECIFIERS
)
694 dump_type_prefix (type
, flags
);
695 pp_maybe_space (cxx_pp
);
697 if (!DECL_INITIAL (t
) || TREE_CODE (DECL_INITIAL (t
)) != TEMPLATE_PARM_INDEX
)
698 dump_scope (CP_DECL_CONTEXT (t
), flags
);
700 dump_decl (DECL_NAME (t
), flags
);
702 pp_identifier (cxx_pp
, "<anonymous>");
703 if (flags
& TFF_DECL_SPECIFIERS
)
704 dump_type_suffix (type
, flags
);
707 /* Dump a human readable string for the decl T under control of FLAGS. */
710 dump_decl (tree t
, int flags
)
715 switch (TREE_CODE (t
))
718 /* Don't say 'typedef class A' */
719 if (DECL_ARTIFICIAL (t
))
721 if ((flags
& TFF_DECL_SPECIFIERS
)
722 && TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TYPE_PARM
)
723 /* Say `class T' not just `T'. */
724 pp_cxx_identifier (cxx_pp
, "class");
726 dump_type (TREE_TYPE (t
), flags
);
729 if (flags
& TFF_DECL_SPECIFIERS
)
730 pp_cxx_identifier (cxx_pp
, "typedef");
731 dump_simple_decl (t
, DECL_ORIGINAL_TYPE (t
)
732 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
),
737 if (DECL_NAME (t
) && VTABLE_NAME_P (DECL_NAME (t
)))
739 pp_string (cxx_pp
, "vtable for ");
740 gcc_assert (TYPE_P (DECL_CONTEXT (t
)));
741 dump_type (DECL_CONTEXT (t
), flags
);
744 /* Else fall through. */
748 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
752 pp_string (cxx_pp
, "<return value> ");
753 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
757 if (flags
& TFF_DECL_SPECIFIERS
)
758 pp_cxx_declaration (cxx_pp
, t
);
761 dump_scope (CP_DECL_CONTEXT (t
), flags
);
762 if (DECL_NAME (t
) == NULL_TREE
)
763 pp_identifier (cxx_pp
, "<unnamed>");
765 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (t
));
770 pp_expression (cxx_pp
, t
);
774 dump_decl (TREE_OPERAND (t
, 0), flags
);
775 pp_cxx_left_bracket (cxx_pp
);
776 dump_decl (TREE_OPERAND (t
, 1), flags
);
777 pp_cxx_right_bracket (cxx_pp
);
780 /* So that we can do dump_decl on an aggr type. */
784 dump_type (t
, flags
);
788 /* This is a pseudo destructor call which has not been folded into
789 a PSEUDO_DTOR_EXPR yet. */
790 pp_cxx_complement (cxx_pp
);
791 dump_type (TREE_OPERAND (t
, 0), flags
);
798 /* These special cases are duplicated here so that other functions
799 can feed identifiers to error and get them demangled properly. */
800 case IDENTIFIER_NODE
:
801 if (IDENTIFIER_TYPENAME_P (t
))
803 pp_cxx_identifier (cxx_pp
, "operator");
804 /* Not exactly IDENTIFIER_TYPE_VALUE. */
805 dump_type (TREE_TYPE (t
), flags
);
809 pp_cxx_tree_identifier (cxx_pp
, t
);
816 if (DECL_CLASS_SCOPE_P (t
))
818 dump_type (DECL_CONTEXT (t
), flags
);
819 pp_cxx_colon_colon (cxx_pp
);
821 else if (DECL_CONTEXT (t
))
823 dump_decl (DECL_CONTEXT (t
), flags
);
824 pp_cxx_colon_colon (cxx_pp
);
826 dump_decl (DECL_NAME (t
), flags
);
830 /* If there's only one function, just treat it like an ordinary
836 if (! DECL_LANG_SPECIFIC (t
))
837 pp_identifier (cxx_pp
, "<built-in>");
838 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
839 dump_global_iord (t
);
841 dump_function_decl (t
, flags
);
845 dump_template_decl (t
, flags
);
848 case TEMPLATE_ID_EXPR
:
850 tree name
= TREE_OPERAND (t
, 0);
852 if (is_overloaded_fn (name
))
853 name
= DECL_NAME (get_first_fn (name
));
854 dump_decl (name
, flags
);
855 pp_cxx_begin_template_argument_list (cxx_pp
);
856 if (TREE_OPERAND (t
, 1))
857 dump_template_argument_list (TREE_OPERAND (t
, 1), flags
);
858 pp_cxx_end_template_argument_list (cxx_pp
);
863 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (t
));
867 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
868 || (DECL_INITIAL (t
) &&
869 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
870 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
871 else if (DECL_NAME (t
))
872 dump_decl (DECL_NAME (t
), flags
);
873 else if (DECL_INITIAL (t
))
874 dump_expr (DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
876 pp_identifier (cxx_pp
, "<enumerator>");
880 pp_cxx_identifier (cxx_pp
, "using");
881 dump_type (DECL_INITIAL (t
), flags
);
882 pp_cxx_colon_colon (cxx_pp
);
883 dump_decl (DECL_NAME (t
), flags
);
887 dump_decl (BASELINK_FUNCTIONS (t
), flags
);
890 case NON_DEPENDENT_EXPR
:
891 dump_expr (t
, flags
);
894 case TEMPLATE_TYPE_PARM
:
895 if (flags
& TFF_DECL_SPECIFIERS
)
896 pp_cxx_declaration (cxx_pp
, t
);
898 pp_type_id (cxx_pp
, t
);
902 pp_unsupported_tree (cxx_pp
, t
);
903 /* Fall through to error. */
906 pp_identifier (cxx_pp
, "<declaration error>");
911 /* Dump a template declaration T under control of FLAGS. This means the
912 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
915 dump_template_decl (tree t
, int flags
)
917 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
921 if (flags
& TFF_TEMPLATE_HEADER
)
923 for (parms
= orig_parms
= nreverse (orig_parms
);
925 parms
= TREE_CHAIN (parms
))
927 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
928 int len
= TREE_VEC_LENGTH (inner_parms
);
930 pp_cxx_identifier (cxx_pp
, "template");
931 pp_cxx_begin_template_argument_list (cxx_pp
);
933 /* If we've shown the template prefix, we'd better show the
934 parameters' and decl's type too. */
935 flags
|= TFF_DECL_SPECIFIERS
;
937 for (i
= 0; i
< len
; i
++)
940 pp_separate_with_comma (cxx_pp
);
941 dump_template_parameter (TREE_VEC_ELT (inner_parms
, i
), flags
);
943 pp_cxx_end_template_argument_list (cxx_pp
);
944 pp_cxx_whitespace (cxx_pp
);
946 nreverse(orig_parms
);
948 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
949 /* Say `template<arg> class TT' not just `template<arg> TT'. */
950 pp_cxx_identifier (cxx_pp
, "class");
953 if (TREE_CODE (DECL_TEMPLATE_RESULT (t
)) == TYPE_DECL
)
954 dump_type (TREE_TYPE (t
),
955 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
956 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
957 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t
)) == VAR_DECL
)
958 dump_decl (DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
961 gcc_assert (TREE_TYPE (t
));
962 switch (NEXT_CODE (t
))
966 dump_function_decl (t
, flags
| TFF_TEMPLATE_NAME
);
969 /* This case can occur with some invalid code. */
970 dump_type (TREE_TYPE (t
),
971 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
972 | (flags
& TFF_DECL_SPECIFIERS
973 ? TFF_CLASS_KEY_OR_ENUM
: 0));
978 /* Pretty print a function decl. There are several ways we want to print a
979 function declaration. The TFF_ bits in FLAGS tells us how to behave.
980 As error can only apply the '#' flag once to give 0 and 1 for V, there
981 is %D which doesn't print the throw specs, and %F which does. */
984 dump_function_decl (tree t
, int flags
)
988 tree cname
= NULL_TREE
;
989 tree template_args
= NULL_TREE
;
990 tree template_parms
= NULL_TREE
;
991 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
993 if (TREE_CODE (t
) == TEMPLATE_DECL
)
994 t
= DECL_TEMPLATE_RESULT (t
);
996 /* Pretty print template instantiations only. */
997 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
))
1001 template_args
= DECL_TI_ARGS (t
);
1002 tmpl
= most_general_template (t
);
1003 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1005 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1010 fntype
= TREE_TYPE (t
);
1011 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1013 if (DECL_CLASS_SCOPE_P (t
))
1014 cname
= DECL_CONTEXT (t
);
1015 /* This is for partially instantiated template methods. */
1016 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1017 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1019 if (!(flags
& TFF_DECL_SPECIFIERS
))
1021 else if (DECL_STATIC_FUNCTION_P (t
))
1022 pp_cxx_identifier (cxx_pp
, "static");
1023 else if (DECL_VIRTUAL_P (t
))
1024 pp_cxx_identifier (cxx_pp
, "virtual");
1026 /* Print the return type? */
1028 show_return
= !DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1029 && !DECL_DESTRUCTOR_P (t
);
1031 dump_type_prefix (TREE_TYPE (fntype
), flags
);
1033 /* Print the function name. */
1036 dump_type (cname
, flags
);
1037 pp_cxx_colon_colon (cxx_pp
);
1040 dump_scope (CP_DECL_CONTEXT (t
), flags
);
1042 dump_function_name (t
, flags
);
1044 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1046 dump_parameters (parmtypes
, flags
);
1048 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1050 pp_base (cxx_pp
)->padding
= pp_before
;
1051 pp_cxx_cv_qualifier_seq
1052 (cxx_pp
, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype
))));
1055 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1057 pp_base (cxx_pp
)->padding
= pp_before
;
1058 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype
), flags
);
1062 dump_type_suffix (TREE_TYPE (fntype
), flags
);
1065 /* If T is a template instantiation, dump the parameter binding. */
1066 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
)
1068 pp_cxx_whitespace (cxx_pp
);
1069 pp_cxx_left_bracket (cxx_pp
);
1070 pp_cxx_identifier (cxx_pp
, "with");
1071 pp_cxx_whitespace (cxx_pp
);
1072 dump_template_bindings (template_parms
, template_args
);
1073 pp_cxx_right_bracket (cxx_pp
);
1077 /* Print a parameter list. If this is for a member function, the
1078 member object ptr (and any other hidden args) should have
1079 already been removed. */
1082 dump_parameters (tree parmtypes
, int flags
)
1086 pp_cxx_left_paren (cxx_pp
);
1088 for (first
= 1; parmtypes
!= void_list_node
;
1089 parmtypes
= TREE_CHAIN (parmtypes
))
1092 pp_separate_with_comma (cxx_pp
);
1096 pp_cxx_identifier (cxx_pp
, "...");
1099 dump_type (TREE_VALUE (parmtypes
), flags
);
1101 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1103 pp_cxx_whitespace (cxx_pp
);
1105 pp_cxx_whitespace (cxx_pp
);
1106 dump_expr (TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1110 pp_cxx_right_paren (cxx_pp
);
1113 /* Print an exception specification. T is the exception specification. */
1116 dump_exception_spec (tree t
, int flags
)
1120 pp_cxx_identifier (cxx_pp
, "throw");
1121 pp_cxx_whitespace (cxx_pp
);
1122 pp_cxx_left_paren (cxx_pp
);
1123 if (TREE_VALUE (t
) != NULL_TREE
)
1126 dump_type (TREE_VALUE (t
), flags
);
1130 pp_separate_with_comma (cxx_pp
);
1132 pp_cxx_right_paren (cxx_pp
);
1136 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1137 and destructors properly. */
1140 dump_function_name (tree t
, int flags
)
1142 tree name
= DECL_NAME (t
);
1144 /* We can get here with a decl that was synthesized by language-
1145 independent machinery (e.g. coverage.c) in which case it won't
1146 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1147 will crash. In this case it is safe just to print out the
1149 if (!DECL_LANG_SPECIFIC (t
))
1151 pp_cxx_tree_identifier (cxx_pp
, name
);
1155 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1156 t
= DECL_TEMPLATE_RESULT (t
);
1158 /* Don't let the user see __comp_ctor et al. */
1159 if (DECL_CONSTRUCTOR_P (t
)
1160 || DECL_DESTRUCTOR_P (t
))
1161 name
= constructor_name (DECL_CONTEXT (t
));
1163 if (DECL_DESTRUCTOR_P (t
))
1165 pp_cxx_complement (cxx_pp
);
1166 dump_decl (name
, TFF_PLAIN_IDENTIFIER
);
1168 else if (DECL_CONV_FN_P (t
))
1170 /* This cannot use the hack that the operator's return
1171 type is stashed off of its name because it may be
1172 used for error reporting. In the case of conflicting
1173 declarations, both will have the same name, yet
1174 the types will be different, hence the TREE_TYPE field
1175 of the first name will be clobbered by the second. */
1176 pp_cxx_identifier (cxx_pp
, "operator");
1177 dump_type (TREE_TYPE (TREE_TYPE (t
)), flags
);
1179 else if (IDENTIFIER_OPNAME_P (name
))
1180 pp_cxx_tree_identifier (cxx_pp
, name
);
1182 dump_decl (name
, flags
);
1184 if (DECL_TEMPLATE_INFO (t
)
1185 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1186 && (DECL_TEMPLATE_SPECIALIZATION (t
)
1187 || TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1188 || DECL_TEMPLATE_SPECIALIZATION (DECL_TI_TEMPLATE (t
))
1189 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1190 dump_template_parms (DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
), flags
);
1193 /* Dump the template parameters from the template info INFO under control of
1194 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1195 specialization (partial or complete). For partial specializations we show
1196 the specialized parameter values. For a primary template we show no
1200 dump_template_parms (tree info
, int primary
, int flags
)
1202 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1204 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1206 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1207 pp_cxx_begin_template_argument_list (cxx_pp
);
1209 /* Be careful only to print things when we have them, so as not
1210 to crash producing error messages. */
1211 if (args
&& !primary
)
1215 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
1216 args
= TREE_VEC_ELT (args
, TREE_VEC_LENGTH (args
) - 1);
1218 len
= TREE_VEC_LENGTH (args
);
1220 for (ix
= 0; ix
!= len
; ix
++)
1222 tree arg
= TREE_VEC_ELT (args
, ix
);
1225 pp_separate_with_comma (cxx_pp
);
1228 pp_identifier (cxx_pp
, "<template parameter error>");
1230 dump_template_argument (arg
, flags
);
1235 tree tpl
= TI_TEMPLATE (info
);
1236 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1239 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1240 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1242 for (ix
= 0; ix
!= len
; ix
++)
1244 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1247 pp_separate_with_comma (cxx_pp
);
1249 dump_decl (parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1252 pp_cxx_end_template_argument_list (cxx_pp
);
1255 /* Print out a list of initializers (subr of dump_expr). */
1258 dump_expr_list (tree l
, int flags
)
1262 dump_expr (TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1265 pp_separate_with_comma (cxx_pp
);
1269 /* Print out an expression E under control of FLAGS. */
1272 dump_expr (tree t
, int flags
)
1277 switch (TREE_CODE (t
))
1285 case NAMESPACE_DECL
:
1287 case IDENTIFIER_NODE
:
1288 dump_decl (t
, (flags
& ~TFF_DECL_SPECIFIERS
) | TFF_NO_FUNCTION_ARGUMENTS
);
1292 if (PAREN_STRING_LITERAL_P (t
))
1293 pp_cxx_left_paren (cxx_pp
);
1294 pp_c_constant (pp_c_base (cxx_pp
), t
);
1295 if (PAREN_STRING_LITERAL_P (t
))
1296 pp_cxx_right_paren (cxx_pp
);
1301 pp_c_constant (pp_c_base (cxx_pp
), t
);
1305 pp_cxx_identifier (cxx_pp
, "throw");
1306 dump_expr (TREE_OPERAND (t
, 0), flags
);
1310 pp_ampersand (cxx_pp
);
1311 dump_type (PTRMEM_CST_CLASS (t
), flags
);
1312 pp_cxx_colon_colon (cxx_pp
);
1313 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
1317 pp_cxx_left_paren (cxx_pp
);
1318 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1319 pp_separate_with_comma (cxx_pp
);
1320 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1321 pp_cxx_right_paren (cxx_pp
);
1325 pp_cxx_left_paren (cxx_pp
);
1326 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1327 pp_string (cxx_pp
, " ? ");
1328 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1329 pp_string (cxx_pp
, " : ");
1330 dump_expr (TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
1331 pp_cxx_right_paren (cxx_pp
);
1335 if (TREE_HAS_CONSTRUCTOR (t
))
1337 pp_cxx_identifier (cxx_pp
, "new");
1338 pp_cxx_whitespace (cxx_pp
);
1339 dump_type (TREE_TYPE (TREE_TYPE (t
)), flags
);
1342 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1345 case AGGR_INIT_EXPR
:
1347 tree fn
= NULL_TREE
;
1349 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
)
1350 fn
= TREE_OPERAND (TREE_OPERAND (t
, 0), 0);
1352 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
1354 if (DECL_CONSTRUCTOR_P (fn
))
1355 dump_type (DECL_CONTEXT (fn
), flags
);
1360 dump_expr (TREE_OPERAND (t
, 0), 0);
1362 pp_cxx_left_paren (cxx_pp
);
1363 if (TREE_OPERAND (t
, 1))
1364 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t
, 1)), flags
);
1365 pp_cxx_right_paren (cxx_pp
);
1370 tree fn
= TREE_OPERAND (t
, 0);
1371 tree args
= TREE_OPERAND (t
, 1);
1373 if (TREE_CODE (fn
) == ADDR_EXPR
)
1374 fn
= TREE_OPERAND (fn
, 0);
1376 if (TREE_TYPE (fn
) != NULL_TREE
&& NEXT_CODE (fn
) == METHOD_TYPE
)
1378 tree ob
= TREE_VALUE (args
);
1379 if (TREE_CODE (ob
) == ADDR_EXPR
)
1381 dump_expr (TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
1384 else if (TREE_CODE (ob
) != PARM_DECL
1385 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
1387 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1390 args
= TREE_CHAIN (args
);
1392 dump_expr (fn
, flags
| TFF_EXPR_IN_PARENS
);
1393 pp_cxx_left_paren (cxx_pp
);
1394 dump_expr_list (args
, flags
);
1395 pp_cxx_right_paren (cxx_pp
);
1401 tree type
= TREE_OPERAND (t
, 1);
1402 tree init
= TREE_OPERAND (t
, 2);
1403 if (NEW_EXPR_USE_GLOBAL (t
))
1404 pp_cxx_colon_colon (cxx_pp
);
1405 pp_cxx_identifier (cxx_pp
, "new");
1406 if (TREE_OPERAND (t
, 0))
1408 pp_cxx_left_paren (cxx_pp
);
1409 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
1410 pp_cxx_right_paren (cxx_pp
);
1411 pp_cxx_whitespace (cxx_pp
);
1413 if (TREE_CODE (type
) == ARRAY_REF
)
1414 type
= build_cplus_array_type
1415 (TREE_OPERAND (type
, 0),
1416 build_index_type (fold_build2 (MINUS_EXPR
, integer_type_node
,
1417 TREE_OPERAND (type
, 1),
1418 integer_one_node
)));
1419 dump_type (type
, flags
);
1422 pp_cxx_left_paren (cxx_pp
);
1423 if (TREE_CODE (init
) == TREE_LIST
)
1424 dump_expr_list (init
, flags
);
1425 else if (init
== void_zero_node
)
1426 /* This representation indicates an empty initializer,
1427 e.g.: "new int()". */
1430 dump_expr (init
, flags
);
1431 pp_cxx_right_paren (cxx_pp
);
1437 /* Note that this only works for G++ target exprs. If somebody
1438 builds a general TARGET_EXPR, there's no way to represent that
1439 it initializes anything other that the parameter slot for the
1440 default argument. Note we may have cleared out the first
1441 operand in expand_expr, so don't go killing ourselves. */
1442 if (TREE_OPERAND (t
, 1))
1443 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1451 case TRUNC_DIV_EXPR
:
1452 case TRUNC_MOD_EXPR
:
1460 case TRUTH_ANDIF_EXPR
:
1461 case TRUTH_ORIF_EXPR
:
1468 case EXACT_DIV_EXPR
:
1469 dump_binary_op (operator_name_info
[(int) TREE_CODE (t
)].name
, t
, flags
);
1473 case FLOOR_DIV_EXPR
:
1474 case ROUND_DIV_EXPR
:
1476 dump_binary_op ("/", t
, flags
);
1480 case FLOOR_MOD_EXPR
:
1481 case ROUND_MOD_EXPR
:
1482 dump_binary_op ("%", t
, flags
);
1487 tree ob
= TREE_OPERAND (t
, 0);
1488 if (TREE_CODE (ob
) == INDIRECT_REF
)
1490 ob
= TREE_OPERAND (ob
, 0);
1491 if (TREE_CODE (ob
) != PARM_DECL
1492 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
1494 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1495 pp_cxx_arrow (cxx_pp
);
1500 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1501 pp_cxx_dot (cxx_pp
);
1503 dump_expr (TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
1508 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1509 pp_cxx_left_bracket (cxx_pp
);
1510 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1511 pp_cxx_right_bracket (cxx_pp
);
1515 if (TREE_TYPE (t
) && VOID_TYPE_P (TREE_TYPE (t
)))
1517 pp_cxx_left_paren (cxx_pp
);
1518 dump_type (TREE_TYPE (t
), flags
);
1519 pp_cxx_right_paren (cxx_pp
);
1520 dump_expr (TREE_OPERAND (t
, 0), flags
);
1523 dump_unary_op ("+", t
, flags
);
1527 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
1528 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
1529 /* An ADDR_EXPR can have reference type. In that case, we
1530 shouldn't print the `&' doing so indicates to the user
1531 that the expression has pointer type. */
1533 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
1534 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1536 dump_unary_op ("&", t
, flags
);
1540 if (TREE_HAS_CONSTRUCTOR (t
))
1542 t
= TREE_OPERAND (t
, 0);
1543 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
1544 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1545 pp_cxx_left_paren (cxx_pp
);
1546 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t
, 1)), flags
);
1547 pp_cxx_right_paren (cxx_pp
);
1551 if (TREE_OPERAND (t
,0) != NULL_TREE
1552 && TREE_TYPE (TREE_OPERAND (t
, 0))
1553 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
1554 dump_expr (TREE_OPERAND (t
, 0), flags
);
1556 dump_unary_op ("*", t
, flags
);
1562 case TRUTH_NOT_EXPR
:
1563 case PREDECREMENT_EXPR
:
1564 case PREINCREMENT_EXPR
:
1565 dump_unary_op (operator_name_info
[(int)TREE_CODE (t
)].name
, t
, flags
);
1568 case POSTDECREMENT_EXPR
:
1569 case POSTINCREMENT_EXPR
:
1570 pp_cxx_left_paren (cxx_pp
);
1571 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1572 pp_cxx_identifier (cxx_pp
, operator_name_info
[(int)TREE_CODE (t
)].name
);
1573 pp_cxx_right_paren (cxx_pp
);
1576 case NON_LVALUE_EXPR
:
1577 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1578 should be another level of INDIRECT_REF so that I don't have to do
1580 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
1582 tree next
= TREE_TYPE (TREE_TYPE (t
));
1584 while (TREE_CODE (next
) == POINTER_TYPE
)
1585 next
= TREE_TYPE (next
);
1587 if (TREE_CODE (next
) == FUNCTION_TYPE
)
1589 if (flags
& TFF_EXPR_IN_PARENS
)
1590 pp_cxx_left_paren (cxx_pp
);
1591 pp_cxx_star (cxx_pp
);
1592 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1593 if (flags
& TFF_EXPR_IN_PARENS
)
1594 pp_cxx_right_paren (cxx_pp
);
1597 /* Else fall through. */
1599 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1604 tree op
= TREE_OPERAND (t
, 0);
1606 if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
1608 /* It is a cast, but we cannot tell whether it is a
1609 reinterpret or static cast. Use the C style notation. */
1610 if (flags
& TFF_EXPR_IN_PARENS
)
1611 pp_cxx_left_paren (cxx_pp
);
1612 pp_cxx_left_paren (cxx_pp
);
1613 dump_type (TREE_TYPE (t
), flags
);
1614 pp_cxx_right_paren (cxx_pp
);
1615 dump_expr (op
, flags
| TFF_EXPR_IN_PARENS
);
1616 if (flags
& TFF_EXPR_IN_PARENS
)
1617 pp_cxx_right_paren (cxx_pp
);
1620 dump_expr (op
, flags
);
1625 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
1627 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
1629 if (integer_zerop (idx
))
1631 /* A NULL pointer-to-member constant. */
1632 pp_cxx_left_paren (cxx_pp
);
1633 pp_cxx_left_paren (cxx_pp
);
1634 dump_type (TREE_TYPE (t
), flags
);
1635 pp_cxx_right_paren (cxx_pp
);
1636 pp_character (cxx_pp
, '0');
1637 pp_cxx_right_paren (cxx_pp
);
1640 else if (host_integerp (idx
, 0))
1643 unsigned HOST_WIDE_INT n
;
1645 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
1646 t
= TYPE_METHOD_BASETYPE (t
);
1647 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
1649 n
= tree_low_cst (idx
, 0);
1651 /* Map vtable index back one, to allow for the null pointer to
1655 while (n
> 0 && virtuals
)
1658 virtuals
= TREE_CHAIN (virtuals
);
1662 dump_expr (BV_FN (virtuals
),
1663 flags
| TFF_EXPR_IN_PARENS
);
1668 if (TREE_TYPE (t
) && !CONSTRUCTOR_ELTS (t
))
1670 dump_type (TREE_TYPE (t
), 0);
1671 pp_cxx_left_paren (cxx_pp
);
1672 pp_cxx_right_paren (cxx_pp
);
1676 pp_cxx_left_brace (cxx_pp
);
1677 dump_expr_list (CONSTRUCTOR_ELTS (t
), flags
);
1678 pp_cxx_right_brace (cxx_pp
);
1685 tree ob
= TREE_OPERAND (t
, 0);
1686 if (is_dummy_object (ob
))
1688 t
= TREE_OPERAND (t
, 1);
1689 if (TREE_CODE (t
) == FUNCTION_DECL
)
1691 dump_expr (t
, flags
| TFF_EXPR_IN_PARENS
);
1692 else if (BASELINK_P (t
))
1693 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t
)),
1694 flags
| TFF_EXPR_IN_PARENS
);
1696 dump_decl (t
, flags
);
1700 if (TREE_CODE (ob
) == INDIRECT_REF
)
1702 dump_expr (TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
1703 pp_cxx_arrow (cxx_pp
);
1704 pp_cxx_star (cxx_pp
);
1708 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1709 pp_cxx_dot (cxx_pp
);
1710 pp_cxx_star (cxx_pp
);
1712 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1717 case TEMPLATE_PARM_INDEX
:
1718 dump_decl (TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
1722 pp_expression (cxx_pp
, t
);
1726 if (TREE_OPERAND (t
, 0) == NULL_TREE
1727 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
1729 dump_type (TREE_TYPE (t
), flags
);
1730 pp_cxx_left_paren (cxx_pp
);
1731 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
1732 pp_cxx_right_paren (cxx_pp
);
1736 pp_cxx_left_paren (cxx_pp
);
1737 dump_type (TREE_TYPE (t
), flags
);
1738 pp_cxx_right_paren (cxx_pp
);
1739 pp_cxx_left_paren (cxx_pp
);
1740 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
1741 pp_cxx_right_paren (cxx_pp
);
1745 case STATIC_CAST_EXPR
:
1746 pp_cxx_identifier (cxx_pp
, "static_cast");
1748 case REINTERPRET_CAST_EXPR
:
1749 pp_cxx_identifier (cxx_pp
, "reinterpret_cast");
1751 case CONST_CAST_EXPR
:
1752 pp_cxx_identifier (cxx_pp
, "const_cast");
1754 case DYNAMIC_CAST_EXPR
:
1755 pp_cxx_identifier (cxx_pp
, "dynamic_cast");
1757 pp_cxx_begin_template_argument_list (cxx_pp
);
1758 dump_type (TREE_TYPE (t
), flags
);
1759 pp_cxx_end_template_argument_list (cxx_pp
);
1760 pp_cxx_left_paren (cxx_pp
);
1761 dump_expr (TREE_OPERAND (t
, 0), flags
);
1762 pp_cxx_right_paren (cxx_pp
);
1766 dump_expr (TREE_OPERAND (t
, 0), flags
);
1767 pp_cxx_arrow (cxx_pp
);
1772 if (TREE_CODE (t
) == SIZEOF_EXPR
)
1773 pp_cxx_identifier (cxx_pp
, "sizeof");
1776 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
1777 pp_cxx_identifier (cxx_pp
, "__alignof__");
1779 pp_cxx_whitespace (cxx_pp
);
1780 pp_cxx_left_paren (cxx_pp
);
1781 if (TYPE_P (TREE_OPERAND (t
, 0)))
1782 dump_type (TREE_OPERAND (t
, 0), flags
);
1784 dump_expr (TREE_OPERAND (t
, 0), flags
);
1785 pp_cxx_right_paren (cxx_pp
);
1790 pp_cxx_identifier (cxx_pp
, operator_name_info
[TREE_CODE (t
)].name
);
1791 pp_cxx_whitespace (cxx_pp
);
1792 dump_expr (TREE_OPERAND (t
, 0), flags
);
1796 pp_identifier (cxx_pp
, "<unparsed>");
1799 case TRY_CATCH_EXPR
:
1800 case WITH_CLEANUP_EXPR
:
1801 case CLEANUP_POINT_EXPR
:
1802 dump_expr (TREE_OPERAND (t
, 0), flags
);
1805 case PSEUDO_DTOR_EXPR
:
1806 dump_expr (TREE_OPERAND (t
, 2), flags
);
1807 pp_cxx_dot (cxx_pp
);
1808 dump_type (TREE_OPERAND (t
, 0), flags
);
1809 pp_cxx_colon_colon (cxx_pp
);
1810 pp_cxx_complement (cxx_pp
);
1811 dump_type (TREE_OPERAND (t
, 1), flags
);
1814 case TEMPLATE_ID_EXPR
:
1815 dump_decl (t
, flags
);
1820 case STATEMENT_LIST
:
1821 /* We don't yet have a way of dumping statements in a
1822 human-readable format. */
1823 pp_string (cxx_pp
, "({...})");
1827 pp_string (cxx_pp
, "while (1) { ");
1828 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1829 pp_cxx_right_brace (cxx_pp
);
1833 pp_string (cxx_pp
, "if (");
1834 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1835 pp_string (cxx_pp
, ") break; ");
1839 dump_expr (get_first_fn (t
), flags
& ~TFF_EXPR_IN_PARENS
);
1842 case EMPTY_CLASS_EXPR
:
1843 dump_type (TREE_TYPE (t
), flags
);
1844 pp_cxx_left_paren (cxx_pp
);
1845 pp_cxx_right_paren (cxx_pp
);
1848 case NON_DEPENDENT_EXPR
:
1849 dump_expr (TREE_OPERAND (t
, 0), flags
);
1852 /* This list is incomplete, but should suffice for now.
1853 It is very important that `sorry' does not call
1854 `report_error_function'. That could cause an infinite loop. */
1856 pp_unsupported_tree (cxx_pp
, t
);
1857 /* fall through to ERROR_MARK... */
1859 pp_identifier (cxx_pp
, "<expression error>");
1865 dump_binary_op (const char *opstring
, tree t
, int flags
)
1867 pp_cxx_left_paren (cxx_pp
);
1868 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1869 pp_cxx_whitespace (cxx_pp
);
1871 pp_cxx_identifier (cxx_pp
, opstring
);
1873 pp_identifier (cxx_pp
, "<unknown operator>");
1874 pp_cxx_whitespace (cxx_pp
);
1875 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1876 pp_cxx_right_paren (cxx_pp
);
1880 dump_unary_op (const char *opstring
, tree t
, int flags
)
1882 if (flags
& TFF_EXPR_IN_PARENS
)
1883 pp_cxx_left_paren (cxx_pp
);
1884 pp_cxx_identifier (cxx_pp
, opstring
);
1885 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1886 if (flags
& TFF_EXPR_IN_PARENS
)
1887 pp_cxx_right_paren (cxx_pp
);
1891 reinit_cxx_pp (void)
1893 pp_clear_output_area (cxx_pp
);
1894 pp_base (cxx_pp
)->padding
= pp_none
;
1895 pp_indentation (cxx_pp
) = 0;
1896 pp_needs_newline (cxx_pp
) = false;
1897 cxx_pp
->enclosing_scope
= 0;
1901 /* Exported interface to stringifying types, exprs and decls under TFF_*
1905 type_as_string (tree typ
, int flags
)
1908 dump_type (typ
, flags
);
1909 return pp_formatted_text (cxx_pp
);
1913 expr_as_string (tree decl
, int flags
)
1916 dump_expr (decl
, flags
);
1917 return pp_formatted_text (cxx_pp
);
1921 decl_as_string (tree decl
, int flags
)
1924 dump_decl (decl
, flags
);
1925 return pp_formatted_text (cxx_pp
);
1928 /* Generate the three forms of printable names for cxx_printable_name. */
1931 lang_decl_name (tree decl
, int v
)
1934 return decl_as_string (decl
, TFF_DECL_SPECIFIERS
);
1937 if (v
== 1 && DECL_CLASS_SCOPE_P (decl
))
1939 dump_type (CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
1940 pp_cxx_colon_colon (cxx_pp
);
1943 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1944 dump_function_name (decl
, TFF_PLAIN_IDENTIFIER
);
1946 dump_decl (DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
1948 return pp_formatted_text (cxx_pp
);
1952 location_of (tree t
)
1954 if (TREE_CODE (t
) == PARM_DECL
&& DECL_CONTEXT (t
))
1955 t
= DECL_CONTEXT (t
);
1956 else if (TYPE_P (t
))
1957 t
= TYPE_MAIN_DECL (t
);
1958 else if (TREE_CODE (t
) == OVERLOAD
)
1959 t
= OVL_FUNCTION (t
);
1961 return DECL_SOURCE_LOCATION (t
);
1964 /* Now the interfaces from error et al to dump_type et al. Each takes an
1965 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
1969 decl_to_string (tree decl
, int verbose
)
1973 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
1974 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
1975 flags
= TFF_CLASS_KEY_OR_ENUM
;
1977 flags
|= TFF_DECL_SPECIFIERS
;
1978 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
1979 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
1980 flags
|= TFF_TEMPLATE_HEADER
;
1983 dump_decl (decl
, flags
);
1984 return pp_formatted_text (cxx_pp
);
1988 expr_to_string (tree decl
)
1991 dump_expr (decl
, 0);
1992 return pp_formatted_text (cxx_pp
);
1996 fndecl_to_string (tree fndecl
, int verbose
)
2000 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
;
2002 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
2004 dump_decl (fndecl
, flags
);
2005 return pp_formatted_text (cxx_pp
);
2010 code_to_string (enum tree_code c
)
2012 return tree_code_name
[c
];
2016 language_to_string (enum languages c
)
2023 case lang_cplusplus
:
2035 /* Return the proper printed version of a parameter to a C++ function. */
2038 parm_to_string (int p
)
2042 pp_string (cxx_pp
, "'this'");
2044 pp_decimal_int (cxx_pp
, p
+ 1);
2045 return pp_formatted_text (cxx_pp
);
2049 op_to_string (enum tree_code p
)
2051 tree id
= operator_name_info
[(int) p
].identifier
;
2052 return id
? IDENTIFIER_POINTER (id
) : "<unknown>";
2056 type_to_string (tree typ
, int verbose
)
2060 flags
|= TFF_CLASS_KEY_OR_ENUM
;
2061 flags
|= TFF_TEMPLATE_HEADER
;
2064 dump_type (typ
, flags
);
2065 return pp_formatted_text (cxx_pp
);
2069 assop_to_string (enum tree_code p
)
2071 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
2072 return id
? IDENTIFIER_POINTER (id
) : "{unknown}";
2076 args_to_string (tree p
, int verbose
)
2080 flags
|= TFF_CLASS_KEY_OR_ENUM
;
2085 if (TYPE_P (TREE_VALUE (p
)))
2086 return type_as_string (p
, flags
);
2089 for (; p
; p
= TREE_CHAIN (p
))
2091 if (TREE_VALUE (p
) == null_node
)
2092 pp_cxx_identifier (cxx_pp
, "NULL");
2094 dump_type (error_type (TREE_VALUE (p
)), flags
);
2096 pp_separate_with_comma (cxx_pp
);
2098 return pp_formatted_text (cxx_pp
);
2102 cv_to_string (tree p
, int v
)
2105 pp_base (cxx_pp
)->padding
= v
? pp_before
: pp_none
;
2106 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
2107 return pp_formatted_text (cxx_pp
);
2110 /* Langhook for print_error_function. */
2112 cxx_print_error_function (diagnostic_context
*context
, const char *file
)
2114 lhd_print_error_function (context
, file
);
2115 pp_base_set_prefix (context
->printer
, file
);
2116 maybe_print_instantiation_context (context
);
2120 cp_diagnostic_starter (diagnostic_context
*context
,
2121 diagnostic_info
*diagnostic
)
2123 diagnostic_report_current_module (context
);
2124 cp_print_error_function (context
, diagnostic
);
2125 maybe_print_instantiation_context (context
);
2126 pp_base_set_prefix (context
->printer
, diagnostic_build_prefix (diagnostic
));
2130 cp_diagnostic_finalizer (diagnostic_context
*context
,
2131 diagnostic_info
*diagnostic ATTRIBUTE_UNUSED
)
2133 pp_base_destroy_prefix (context
->printer
);
2136 /* Print current function onto BUFFER, in the process of reporting
2137 a diagnostic message. Called from cp_diagnostic_starter. */
2139 cp_print_error_function (diagnostic_context
*context
,
2140 diagnostic_info
*diagnostic
)
2142 if (diagnostic_last_function_changed (context
))
2144 const char *old_prefix
= context
->printer
->prefix
;
2145 const char *file
= LOCATION_FILE (diagnostic
->location
);
2146 char *new_prefix
= file
? file_name_as_prefix (file
) : NULL
;
2148 pp_base_set_prefix (context
->printer
, new_prefix
);
2150 if (current_function_decl
== NULL
)
2151 pp_base_string (context
->printer
, "At global scope:");
2153 pp_printf (context
->printer
, "In %s %qs:",
2154 function_category (current_function_decl
),
2155 cxx_printable_name (current_function_decl
, 2));
2156 pp_base_newline (context
->printer
);
2158 diagnostic_set_last_function (context
);
2159 pp_base_destroy_prefix (context
->printer
);
2160 context
->printer
->prefix
= old_prefix
;
2164 /* Returns a description of FUNCTION using standard terminology. */
2166 function_category (tree fn
)
2168 if (DECL_FUNCTION_MEMBER_P (fn
))
2170 if (DECL_STATIC_FUNCTION_P (fn
))
2171 return "static member function";
2172 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
2173 return "copy constructor";
2174 else if (DECL_CONSTRUCTOR_P (fn
))
2175 return "constructor";
2176 else if (DECL_DESTRUCTOR_P (fn
))
2177 return "destructor";
2179 return "member function";
2185 /* Report the full context of a current template instantiation,
2188 print_instantiation_full_context (diagnostic_context
*context
)
2190 tree p
= current_instantiation ();
2191 location_t location
= input_location
;
2195 if (current_function_decl
!= TINST_DECL (p
)
2196 && current_function_decl
!= NULL_TREE
)
2197 /* We can get here during the processing of some synthesized
2198 method. Then, TINST_DECL (p) will be the function that's causing
2203 if (current_function_decl
== TINST_DECL (p
))
2204 /* Avoid redundancy with the "In function" line. */;
2206 pp_verbatim (context
->printer
,
2207 "%s: In instantiation of %qs:\n",
2208 LOCATION_FILE (location
),
2209 decl_as_string (TINST_DECL (p
),
2210 TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
));
2212 location
= TINST_LOCATION (p
);
2217 print_instantiation_partial_context (context
, p
, location
);
2220 /* Same as above but less verbose. */
2222 print_instantiation_partial_context (diagnostic_context
*context
,
2223 tree t
, location_t loc
)
2225 expanded_location xloc
;
2226 for (; ; t
= TREE_CHAIN (t
))
2228 xloc
= expand_location (loc
);
2231 pp_verbatim (context
->printer
, "%s:%d: instantiated from %qs\n",
2232 xloc
.file
, xloc
.line
,
2233 decl_as_string (TINST_DECL (t
),
2234 TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
));
2235 loc
= TINST_LOCATION (t
);
2237 pp_verbatim (context
->printer
, "%s:%d: instantiated from here\n",
2238 xloc
.file
, xloc
.line
);
2241 /* Called from cp_thing to print the template context for an error. */
2243 maybe_print_instantiation_context (diagnostic_context
*context
)
2245 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2248 record_last_problematic_instantiation ();
2249 print_instantiation_full_context (context
);
2252 /* Report the bare minimum context of a template instantiation. */
2254 print_instantiation_context (void)
2256 print_instantiation_partial_context
2257 (global_dc
, current_instantiation (), input_location
);
2258 diagnostic_flush_buffer (global_dc
);
2261 /* Called from output_format -- during diagnostic message processing --
2262 to handle C++ specific format specifier with the following meanings:
2263 %A function argument-list.
2267 %F function declaration.
2268 %L language as used in extern "lang".
2270 %P function parameter whose position is indicated by an integer.
2271 %Q assignment operator.
2275 cp_printer (pretty_printer
*pp
, text_info
*text
)
2279 #define next_tree va_arg (*text->args_ptr, tree)
2280 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2281 #define next_lang va_arg (*text->args_ptr, enum languages)
2282 #define next_int va_arg (*text->args_ptr, int)
2284 if (*text
->format_spec
== '+')
2285 ++text
->format_spec
;
2286 if (*text
->format_spec
== '#')
2289 ++text
->format_spec
;
2292 switch (*text
->format_spec
)
2294 case 'A': result
= args_to_string (next_tree
, verbose
); break;
2295 case 'C': result
= code_to_string (next_tcode
); break;
2296 case 'D': result
= decl_to_string (next_tree
, verbose
); break;
2297 case 'E': result
= expr_to_string (next_tree
); break;
2298 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
2299 case 'L': result
= language_to_string (next_lang
); break;
2300 case 'O': result
= op_to_string (next_tcode
); break;
2301 case 'P': result
= parm_to_string (next_int
); break;
2302 case 'Q': result
= assop_to_string (next_tcode
); break;
2303 case 'T': result
= type_to_string (next_tree
, verbose
); break;
2304 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
2310 pp_base_string (pp
, result
);
2318 /* These are temporary wrapper functions which handle the historic
2319 behavior of cp_*_at. */
2322 locate_error (const char *msgid
, va_list ap
)
2328 for (f
= msgid
; *f
; f
++)
2334 ++f
; /* ignore quoting flag. */
2346 /* Just ignore these possibilities. */
2349 case 'd': (void) va_arg (ap
, int); break;
2350 case 's': (void) va_arg (ap
, char *); break;
2351 case 'L': (void) va_arg (ap
, enum languages
); break;
2354 case 'Q': (void) va_arg (ap
, enum tree_code
); break;
2356 /* These take a tree, which may be where the error is
2364 t
= va_arg (ap
, tree
);
2370 errorcount
= 0; /* damn ICE suppression */
2371 internal_error ("unexpected letter %qc in locate_error\n", *f
);
2377 here
= va_arg (ap
, tree
);
2384 cp_error_at (const char *msgid
, ...)
2387 diagnostic_info diagnostic
;
2390 va_start (ap
, msgid
);
2391 here
= locate_error (msgid
, ap
);
2394 va_start (ap
, msgid
);
2395 diagnostic_set_info (&diagnostic
, msgid
, &ap
,
2396 input_location
, DK_ERROR
);
2397 cp_diagnostic_starter (global_dc
, &diagnostic
);
2398 diagnostic_set_info (&diagnostic
, msgid
, &ap
,
2399 location_of (here
), DK_ERROR
);
2400 report_diagnostic (&diagnostic
);
2405 cp_warning_at (const char *msgid
, ...)
2408 diagnostic_info diagnostic
;
2411 va_start (ap
, msgid
);
2412 here
= locate_error (msgid
, ap
);
2415 va_start (ap
, msgid
);
2416 diagnostic_set_info (&diagnostic
, msgid
, &ap
,
2417 location_of (here
), DK_WARNING
);
2418 report_diagnostic (&diagnostic
);
2423 cp_pedwarn_at (const char *msgid
, ...)
2426 diagnostic_info diagnostic
;
2429 va_start (ap
, msgid
);
2430 here
= locate_error (msgid
, ap
);
2433 va_start (ap
, msgid
);
2434 diagnostic_set_info (&diagnostic
, msgid
, &ap
,
2435 location_of (here
), pedantic_error_kind());
2436 report_diagnostic (&diagnostic
);