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 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 const char *class_key_or_enum (tree
);
74 static void dump_template_argument (tree
, int);
75 static void dump_template_argument_list (tree
, int);
76 static void dump_template_parameter (tree
, int);
77 static void dump_template_bindings (tree
, tree
);
78 static void dump_scope (tree
, int);
79 static void dump_template_parms (tree
, int, int);
81 static const char *function_category (tree
);
82 static void maybe_print_instantiation_context (diagnostic_context
*);
83 static void print_instantiation_full_context (diagnostic_context
*);
84 static void print_instantiation_partial_context (diagnostic_context
*,
86 static void cp_diagnostic_starter (diagnostic_context
*, diagnostic_info
*);
87 static void cp_diagnostic_finalizer (diagnostic_context
*, diagnostic_info
*);
88 static void cp_print_error_function (diagnostic_context
*, diagnostic_info
*);
90 static bool cp_printer (pretty_printer
*, text_info
*);
91 static tree
locate_error (const char *, va_list);
92 static location_t
location_of (tree
);
97 diagnostic_starter (global_dc
) = cp_diagnostic_starter
;
98 diagnostic_finalizer (global_dc
) = cp_diagnostic_finalizer
;
99 diagnostic_format_decoder (global_dc
) = cp_printer
;
101 pp_construct (pp_base (cxx_pp
), NULL
, 0);
102 pp_cxx_pretty_printer_init (cxx_pp
);
105 /* Dump a scope, if deemed necessary. */
108 dump_scope (tree scope
, int flags
)
110 int f
= ~TFF_RETURN_TYPE
& (flags
& (TFF_SCOPE
| TFF_CHASE_TYPEDEF
));
112 if (scope
== NULL_TREE
)
115 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
117 if (scope
!= global_namespace
)
119 dump_decl (scope
, f
);
120 pp_cxx_colon_colon (cxx_pp
);
123 else if (AGGREGATE_TYPE_P (scope
))
125 dump_type (scope
, f
);
126 pp_cxx_colon_colon (cxx_pp
);
128 else if ((flags
& TFF_SCOPE
) && TREE_CODE (scope
) == FUNCTION_DECL
)
130 dump_function_decl (scope
, f
);
131 pp_cxx_colon_colon (cxx_pp
);
135 /* Dump the template ARGument under control of FLAGS. */
138 dump_template_argument (tree arg
, int flags
)
140 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
141 dump_type (arg
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
143 dump_expr (arg
, (flags
| TFF_EXPR_IN_PARENS
) & ~TFF_CLASS_KEY_OR_ENUM
);
146 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
150 dump_template_argument_list (tree args
, int flags
)
152 int n
= TREE_VEC_LENGTH (args
);
156 for (i
= 0; i
< n
; ++i
)
159 pp_separate_with_comma (cxx_pp
);
160 dump_template_argument (TREE_VEC_ELT (args
, i
), flags
);
165 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
168 dump_template_parameter (tree parm
, int flags
)
170 tree p
= TREE_VALUE (parm
);
171 tree a
= TREE_PURPOSE (parm
);
173 if (TREE_CODE (p
) == TYPE_DECL
)
175 if (flags
& TFF_DECL_SPECIFIERS
)
177 pp_cxx_identifier (cxx_pp
, "class");
179 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (p
));
181 else if (DECL_NAME (p
))
182 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (p
));
184 pp_cxx_canonical_template_parameter (cxx_pp
, TREE_TYPE (p
));
187 dump_decl (p
, flags
| TFF_DECL_SPECIFIERS
);
189 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && a
!= NULL_TREE
)
191 pp_cxx_whitespace (cxx_pp
);
193 pp_cxx_whitespace (cxx_pp
);
194 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
195 dump_type (a
, flags
& ~TFF_CHASE_TYPEDEF
);
197 dump_expr (a
, flags
| TFF_EXPR_IN_PARENS
);
201 /* Dump, under control of FLAGS, a template-parameter-list binding.
202 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
206 dump_template_bindings (tree parms
, tree args
)
212 tree p
= TREE_VALUE (parms
);
213 int lvl
= TMPL_PARMS_DEPTH (parms
);
217 for (i
= 0; i
< TREE_VEC_LENGTH (p
); ++i
)
219 tree arg
= NULL_TREE
;
221 /* Don't crash if we had an invalid argument list. */
222 if (TMPL_ARGS_DEPTH (args
) >= lvl
)
224 tree lvl_args
= TMPL_ARGS_LEVEL (args
, lvl
);
225 if (NUM_TMPL_ARGS (lvl_args
) > arg_idx
)
226 arg
= TREE_VEC_ELT (lvl_args
, arg_idx
);
230 pp_separate_with_comma (cxx_pp
);
231 dump_template_parameter (TREE_VEC_ELT (p
, i
), TFF_PLAIN_IDENTIFIER
);
232 pp_cxx_whitespace (cxx_pp
);
234 pp_cxx_whitespace (cxx_pp
);
236 dump_template_argument (arg
, TFF_PLAIN_IDENTIFIER
);
238 pp_identifier (cxx_pp
, "<missing>");
244 parms
= TREE_CHAIN (parms
);
248 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
252 dump_type (tree t
, int flags
)
257 if (TYPE_PTRMEMFUNC_P (t
))
260 switch (TREE_CODE (t
))
263 pp_identifier (cxx_pp
, "<unknown type>");
267 /* A list of function parms. */
268 dump_parameters (t
, flags
);
271 case IDENTIFIER_NODE
:
272 pp_cxx_tree_identifier (cxx_pp
, t
);
276 dump_type (BINFO_TYPE (t
), flags
);
282 dump_aggr_type (t
, flags
);
286 if (flags
& TFF_CHASE_TYPEDEF
)
288 dump_type (DECL_ORIGINAL_TYPE (t
)
289 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
), flags
);
292 /* Else fall through. */
296 dump_decl (t
, flags
& ~TFF_DECL_SPECIFIERS
);
305 pp_type_specifier_seq (cxx_pp
, t
);
308 case TEMPLATE_TEMPLATE_PARM
:
309 /* For parameters inside template signature. */
310 if (TYPE_IDENTIFIER (t
))
311 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (t
));
313 pp_cxx_canonical_template_parameter (cxx_pp
, t
);
316 case BOUND_TEMPLATE_TEMPLATE_PARM
:
318 tree args
= TYPE_TI_ARGS (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
, "typename");
352 dump_typename (t
, flags
);
355 case UNBOUND_CLASS_TEMPLATE
:
356 dump_type (TYPE_CONTEXT (t
), flags
);
357 pp_cxx_colon_colon (cxx_pp
);
358 pp_cxx_identifier (cxx_pp
, "template");
359 dump_type (DECL_NAME (TYPE_NAME (t
)), flags
);
363 pp_cxx_identifier (cxx_pp
, "__typeof__");
364 pp_cxx_whitespace (cxx_pp
);
365 pp_cxx_left_paren (cxx_pp
);
366 dump_expr (TYPEOF_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
367 pp_cxx_right_paren (cxx_pp
);
371 pp_unsupported_tree (cxx_pp
, t
);
372 /* Fall through to error. */
375 pp_identifier (cxx_pp
, "<type error>");
380 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
384 dump_typename (tree t
, int flags
)
386 tree ctx
= TYPE_CONTEXT (t
);
388 if (TREE_CODE (ctx
) == TYPENAME_TYPE
)
389 dump_typename (ctx
, flags
);
391 dump_type (ctx
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
392 pp_cxx_colon_colon (cxx_pp
);
393 dump_decl (TYPENAME_TYPE_FULLNAME (t
), flags
);
396 /* Return the name of the supplied aggregate, or enumeral type. */
399 class_key_or_enum (tree t
)
401 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
403 else if (TREE_CODE (t
) == UNION_TYPE
)
405 else if (TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_DECLARED_CLASS (t
))
411 /* Print out a class declaration T under the control of FLAGS,
412 in the form `class foo'. */
415 dump_aggr_type (tree t
, int flags
)
418 const char *variety
= class_key_or_enum (t
);
422 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
424 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
425 pp_cxx_identifier (cxx_pp
, variety
);
427 if (flags
& TFF_CHASE_TYPEDEF
)
428 t
= TYPE_MAIN_VARIANT (t
);
430 name
= TYPE_NAME (t
);
434 typdef
= !DECL_ARTIFICIAL (name
);
435 tmplate
= !typdef
&& TREE_CODE (t
) != ENUMERAL_TYPE
436 && TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_TEMPLATE_INFO (t
)
437 && (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
)
438 || TREE_CODE (CLASSTYPE_TI_TEMPLATE (t
)) != TEMPLATE_DECL
439 || DECL_TEMPLATE_SPECIALIZATION (CLASSTYPE_TI_TEMPLATE (t
))
440 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)));
441 dump_scope (CP_DECL_CONTEXT (name
), flags
| TFF_SCOPE
);
444 /* Because the template names are mangled, we have to locate
445 the most general template, and use that name. */
446 tree tpl
= CLASSTYPE_TI_TEMPLATE (t
);
448 while (DECL_TEMPLATE_INFO (tpl
))
449 tpl
= DECL_TI_TEMPLATE (tpl
);
452 name
= DECL_NAME (name
);
455 if (name
== 0 || ANON_AGGRNAME_P (name
))
457 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
458 pp_identifier (cxx_pp
, "<anonymous>");
460 pp_printf (pp_base (cxx_pp
), "<anonymous %s>", variety
);
463 pp_cxx_tree_identifier (cxx_pp
, name
);
465 dump_template_parms (TYPE_TEMPLATE_INFO (t
),
466 !CLASSTYPE_USE_TEMPLATE (t
),
467 flags
& ~TFF_TEMPLATE_HEADER
);
470 /* Dump into the obstack the initial part of the output for a given type.
471 This is necessary when dealing with things like functions returning
474 return type of `int (* fee ())()': pointer -> function -> int. Both
475 pointer (and reference and offset) and function (and member) types must
476 deal with prefix and suffix.
478 Arrays must also do this for DECL nodes, like int a[], and for things like
482 dump_type_prefix (tree t
, int flags
)
484 if (TYPE_PTRMEMFUNC_P (t
))
486 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
490 switch (TREE_CODE (t
))
495 tree sub
= TREE_TYPE (t
);
497 dump_type_prefix (sub
, flags
);
498 if (TREE_CODE (sub
) == ARRAY_TYPE
)
500 pp_cxx_whitespace (cxx_pp
);
501 pp_cxx_left_paren (cxx_pp
);
503 pp_character (cxx_pp
, "&*"[TREE_CODE (t
) == POINTER_TYPE
]);
504 pp_base (cxx_pp
)->padding
= pp_before
;
505 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
511 dump_type_prefix (TREE_TYPE (t
), flags
);
512 if (TREE_CODE (t
) == OFFSET_TYPE
) /* pmfs deal with this in d_t_p */
514 pp_maybe_space (cxx_pp
);
515 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
516 pp_cxx_left_paren (cxx_pp
);
517 dump_type (TYPE_OFFSET_BASETYPE (t
), flags
);
518 pp_cxx_colon_colon (cxx_pp
);
520 pp_cxx_star (cxx_pp
);
521 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
522 pp_base (cxx_pp
)->padding
= pp_before
;
525 /* Can only be reached through function pointer -- this would not be
526 correct if FUNCTION_DECLs used it. */
528 dump_type_prefix (TREE_TYPE (t
), flags
);
529 pp_maybe_space (cxx_pp
);
530 pp_cxx_left_paren (cxx_pp
);
534 dump_type_prefix (TREE_TYPE (t
), flags
);
535 pp_maybe_space (cxx_pp
);
536 pp_cxx_left_paren (cxx_pp
);
537 dump_aggr_type (TYPE_METHOD_BASETYPE (t
), flags
);
538 pp_cxx_colon_colon (cxx_pp
);
542 dump_type_prefix (TREE_TYPE (t
), flags
);
546 case IDENTIFIER_NODE
:
551 case TEMPLATE_TYPE_PARM
:
552 case TEMPLATE_TEMPLATE_PARM
:
553 case BOUND_TEMPLATE_TEMPLATE_PARM
:
564 dump_type (t
, flags
);
565 pp_base (cxx_pp
)->padding
= pp_before
;
569 pp_unsupported_tree (cxx_pp
, t
);
572 pp_identifier (cxx_pp
, "<typeprefixerror>");
577 /* Dump the suffix of type T, under control of FLAGS. This is the part
578 which appears after the identifier (or function parms). */
581 dump_type_suffix (tree t
, int flags
)
583 if (TYPE_PTRMEMFUNC_P (t
))
584 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
586 switch (TREE_CODE (t
))
591 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
592 pp_cxx_right_paren (cxx_pp
);
593 dump_type_suffix (TREE_TYPE (t
), flags
);
596 /* Can only be reached through function pointer. */
601 pp_cxx_right_paren (cxx_pp
);
602 arg
= TYPE_ARG_TYPES (t
);
603 if (TREE_CODE (t
) == METHOD_TYPE
)
604 arg
= TREE_CHAIN (arg
);
606 /* Function pointers don't have default args. Not in standard C++,
607 anyway; they may in g++, but we'll just pretend otherwise. */
608 dump_parameters (arg
, flags
& ~TFF_FUNCTION_DEFAULT_ARGUMENTS
);
610 if (TREE_CODE (t
) == METHOD_TYPE
)
611 pp_cxx_cv_qualifier_seq
612 (cxx_pp
, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t
))));
613 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t
), flags
);
614 dump_type_suffix (TREE_TYPE (t
), flags
);
619 pp_maybe_space (cxx_pp
);
620 pp_cxx_left_bracket (cxx_pp
);
623 if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t
)), 0))
625 (cxx_pp
, tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t
)), 0) + 1);
626 else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t
))) == MINUS_EXPR
)
627 dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t
)), 0),
628 flags
& ~TFF_EXPR_IN_PARENS
);
630 dump_expr (fold (cp_build_binary_op
631 (PLUS_EXPR
, TYPE_MAX_VALUE (TYPE_DOMAIN (t
)),
633 flags
& ~TFF_EXPR_IN_PARENS
);
635 pp_cxx_right_bracket (cxx_pp
);
636 dump_type_suffix (TREE_TYPE (t
), flags
);
640 case IDENTIFIER_NODE
:
645 case TEMPLATE_TYPE_PARM
:
646 case TEMPLATE_TEMPLATE_PARM
:
647 case BOUND_TEMPLATE_TEMPLATE_PARM
:
661 pp_unsupported_tree (cxx_pp
, t
);
663 /* Don't mark it here, we should have already done in
670 dump_global_iord (tree t
)
672 const char *p
= NULL
;
674 if (DECL_GLOBAL_CTOR_P (t
))
676 else if (DECL_GLOBAL_DTOR_P (t
))
681 pp_printf (pp_base (cxx_pp
), "(static %s for %s)", p
, input_filename
);
685 dump_simple_decl (tree t
, tree type
, int flags
)
687 if (flags
& TFF_DECL_SPECIFIERS
)
689 dump_type_prefix (type
, flags
);
690 pp_maybe_space (cxx_pp
);
692 if (!DECL_INITIAL (t
) || TREE_CODE (DECL_INITIAL (t
)) != TEMPLATE_PARM_INDEX
)
693 dump_scope (CP_DECL_CONTEXT (t
), flags
);
695 dump_decl (DECL_NAME (t
), flags
);
697 pp_identifier (cxx_pp
, "<anonymous>");
698 if (flags
& TFF_DECL_SPECIFIERS
)
699 dump_type_suffix (type
, flags
);
702 /* Dump a human readable string for the decl T under control of FLAGS. */
705 dump_decl (tree t
, int flags
)
710 switch (TREE_CODE (t
))
714 /* Don't say 'typedef class A' */
715 if (DECL_ARTIFICIAL (t
))
717 if ((flags
& TFF_DECL_SPECIFIERS
)
718 && TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TYPE_PARM
)
719 /* Say `class T' not just `T'. */
720 pp_cxx_identifier (cxx_pp
, "class");
722 dump_type (TREE_TYPE (t
), flags
);
726 if (flags
& TFF_DECL_SPECIFIERS
)
727 pp_cxx_identifier (cxx_pp
, "typedef");
728 dump_simple_decl (t
, DECL_ORIGINAL_TYPE (t
)
729 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
),
734 if (DECL_NAME (t
) && VTABLE_NAME_P (DECL_NAME (t
)))
736 pp_string (cxx_pp
, "vtable for ");
737 my_friendly_assert (TYPE_P (DECL_CONTEXT (t
)), 20010720);
738 dump_type (DECL_CONTEXT (t
), flags
);
741 /* Else fall through. */
745 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
749 pp_string (cxx_pp
, "<return value> ");
750 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
754 if (flags
& TFF_DECL_SPECIFIERS
)
755 pp_cxx_declaration (cxx_pp
, t
);
758 dump_scope (CP_DECL_CONTEXT (t
), flags
);
759 if (DECL_NAME (t
) == NULL_TREE
)
760 pp_identifier (cxx_pp
, "<unnamed>");
762 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (t
));
767 pp_expression (cxx_pp
, t
);
771 dump_decl (TREE_OPERAND (t
, 0), flags
);
772 pp_cxx_left_bracket (cxx_pp
);
773 dump_decl (TREE_OPERAND (t
, 1), flags
);
774 pp_cxx_right_bracket (cxx_pp
);
777 /* So that we can do dump_decl on an aggr type. */
781 dump_type (t
, flags
);
785 /* This is a pseudo destructor call which has not been folded into
786 a PSEUDO_DTOR_EXPR yet. */
787 pp_cxx_complement (cxx_pp
);
788 dump_type (TREE_OPERAND (t
, 0), flags
);
795 /* These special cases are duplicated here so that other functions
796 can feed identifiers to error and get them demangled properly. */
797 case IDENTIFIER_NODE
:
798 if (IDENTIFIER_TYPENAME_P (t
))
800 pp_cxx_identifier (cxx_pp
, "operator");
801 /* Not exactly IDENTIFIER_TYPE_VALUE. */
802 dump_type (TREE_TYPE (t
), flags
);
806 pp_cxx_tree_identifier (cxx_pp
, t
);
813 if (DECL_CLASS_SCOPE_P (t
))
815 dump_type (DECL_CONTEXT (t
), flags
);
816 pp_cxx_colon_colon (cxx_pp
);
818 else if (DECL_CONTEXT (t
))
820 dump_decl (DECL_CONTEXT (t
), flags
);
821 pp_cxx_colon_colon (cxx_pp
);
823 dump_decl (DECL_NAME (t
), flags
);
827 /* If there's only one function, just treat it like an ordinary
833 if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
834 dump_global_iord (t
);
835 else if (! DECL_LANG_SPECIFIC (t
))
836 pp_identifier (cxx_pp
, "<built-in>");
838 dump_function_decl (t
, flags
);
842 dump_template_decl (t
, flags
);
845 case TEMPLATE_ID_EXPR
:
847 tree name
= TREE_OPERAND (t
, 0);
849 if (is_overloaded_fn (name
))
850 name
= DECL_NAME (get_first_fn (name
));
851 dump_decl (name
, flags
);
852 pp_cxx_begin_template_argument_list (cxx_pp
);
853 if (TREE_OPERAND (t
, 1))
854 dump_template_argument_list (TREE_OPERAND (t
, 1), flags
);
855 pp_cxx_end_template_argument_list (cxx_pp
);
860 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (t
));
864 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
865 || (DECL_INITIAL (t
) &&
866 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
867 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
868 else if (DECL_NAME (t
))
869 dump_decl (DECL_NAME (t
), flags
);
870 else if (DECL_INITIAL (t
))
871 dump_expr (DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
873 pp_identifier (cxx_pp
, "<enumerator>");
877 pp_cxx_identifier (cxx_pp
, "using");
878 dump_type (DECL_INITIAL (t
), flags
);
879 pp_cxx_colon_colon (cxx_pp
);
880 dump_decl (DECL_NAME (t
), flags
);
884 dump_decl (BASELINK_FUNCTIONS (t
), flags
);
887 case NON_DEPENDENT_EXPR
:
888 dump_expr (t
, flags
);
891 case TEMPLATE_TYPE_PARM
:
892 if (flags
& TFF_DECL_SPECIFIERS
)
893 pp_cxx_declaration (cxx_pp
, t
);
895 pp_type_id (cxx_pp
, t
);
899 pp_unsupported_tree (cxx_pp
, t
);
900 /* Fall through to error. */
903 pp_identifier (cxx_pp
, "<declaration error>");
908 /* Dump a template declaration T under control of FLAGS. This means the
909 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
912 dump_template_decl (tree t
, int flags
)
914 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
918 if (flags
& TFF_TEMPLATE_HEADER
)
920 for (parms
= orig_parms
= nreverse (orig_parms
);
922 parms
= TREE_CHAIN (parms
))
924 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
925 int len
= TREE_VEC_LENGTH (inner_parms
);
927 pp_cxx_identifier (cxx_pp
, "template");
928 pp_cxx_begin_template_argument_list (cxx_pp
);
930 /* If we've shown the template prefix, we'd better show the
931 parameters' and decl's type too. */
932 flags
|= TFF_DECL_SPECIFIERS
;
934 for (i
= 0; i
< len
; i
++)
937 pp_separate_with_comma (cxx_pp
);
938 dump_template_parameter (TREE_VEC_ELT (inner_parms
, i
), flags
);
940 pp_cxx_end_template_argument_list (cxx_pp
);
941 pp_cxx_whitespace (cxx_pp
);
943 nreverse(orig_parms
);
945 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
946 /* Say `template<arg> class TT' not just `template<arg> TT'. */
947 pp_cxx_identifier (cxx_pp
, "class");
950 if (TREE_CODE (DECL_TEMPLATE_RESULT (t
)) == TYPE_DECL
)
951 dump_type (TREE_TYPE (t
),
952 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
953 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
954 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t
)) == VAR_DECL
)
955 dump_decl (DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
956 else if (TREE_TYPE (t
) == NULL_TREE
)
959 switch (NEXT_CODE (t
))
963 dump_function_decl (t
, flags
| TFF_TEMPLATE_NAME
);
966 /* This case can occur with some invalid code. */
967 dump_type (TREE_TYPE (t
),
968 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
969 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0));
973 /* Pretty print a function decl. There are several ways we want to print a
974 function declaration. The TFF_ bits in FLAGS tells us how to behave.
975 As error can only apply the '#' flag once to give 0 and 1 for V, there
976 is %D which doesn't print the throw specs, and %F which does. */
979 dump_function_decl (tree t
, int flags
)
983 tree cname
= NULL_TREE
;
984 tree template_args
= NULL_TREE
;
985 tree template_parms
= NULL_TREE
;
986 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
988 if (TREE_CODE (t
) == TEMPLATE_DECL
)
989 t
= DECL_TEMPLATE_RESULT (t
);
991 /* Pretty print template instantiations only. */
992 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
))
996 template_args
= DECL_TI_ARGS (t
);
997 tmpl
= most_general_template (t
);
998 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1000 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1005 fntype
= TREE_TYPE (t
);
1006 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1008 if (DECL_CLASS_SCOPE_P (t
))
1009 cname
= DECL_CONTEXT (t
);
1010 /* This is for partially instantiated template methods. */
1011 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1012 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1014 if (!(flags
& TFF_DECL_SPECIFIERS
))
1016 else if (DECL_STATIC_FUNCTION_P (t
))
1017 pp_cxx_identifier (cxx_pp
, "static");
1018 else if (DECL_VIRTUAL_P (t
))
1019 pp_cxx_identifier (cxx_pp
, "virtual");
1021 /* Print the return type? */
1023 show_return
= !DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1024 && !DECL_DESTRUCTOR_P (t
);
1026 dump_type_prefix (TREE_TYPE (fntype
), flags
);
1028 /* Print the function name. */
1031 dump_type (cname
, flags
);
1032 pp_cxx_colon_colon (cxx_pp
);
1035 dump_scope (CP_DECL_CONTEXT (t
), flags
);
1037 dump_function_name (t
, flags
);
1039 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1041 dump_parameters (parmtypes
, flags
);
1043 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1045 pp_base (cxx_pp
)->padding
= pp_before
;
1046 pp_cxx_cv_qualifier_seq
1047 (cxx_pp
, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype
))));
1050 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1052 pp_base (cxx_pp
)->padding
= pp_before
;
1053 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype
), flags
);
1057 dump_type_suffix (TREE_TYPE (fntype
), flags
);
1060 /* If T is a template instantiation, dump the parameter binding. */
1061 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
)
1063 pp_cxx_whitespace (cxx_pp
);
1064 pp_cxx_left_bracket (cxx_pp
);
1065 pp_cxx_identifier (cxx_pp
, "with");
1066 pp_cxx_whitespace (cxx_pp
);
1067 dump_template_bindings (template_parms
, template_args
);
1068 pp_cxx_right_bracket (cxx_pp
);
1072 /* Print a parameter list. If this is for a member function, the
1073 member object ptr (and any other hidden args) should have
1074 already been removed. */
1077 dump_parameters (tree parmtypes
, int flags
)
1081 pp_cxx_left_paren (cxx_pp
);
1083 for (first
= 1; parmtypes
!= void_list_node
;
1084 parmtypes
= TREE_CHAIN (parmtypes
))
1087 pp_separate_with_comma (cxx_pp
);
1091 pp_cxx_identifier (cxx_pp
, "...");
1094 dump_type (TREE_VALUE (parmtypes
), flags
);
1096 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1098 pp_cxx_whitespace (cxx_pp
);
1100 pp_cxx_whitespace (cxx_pp
);
1101 dump_expr (TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1105 pp_cxx_right_paren (cxx_pp
);
1108 /* Print an exception specification. T is the exception specification. */
1111 dump_exception_spec (tree t
, int flags
)
1115 pp_cxx_identifier (cxx_pp
, "throw");
1116 pp_cxx_whitespace (cxx_pp
);
1117 pp_cxx_left_paren (cxx_pp
);
1118 if (TREE_VALUE (t
) != NULL_TREE
)
1121 dump_type (TREE_VALUE (t
), flags
);
1125 pp_separate_with_comma (cxx_pp
);
1127 pp_cxx_right_paren (cxx_pp
);
1131 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1132 and destructors properly. */
1135 dump_function_name (tree t
, int flags
)
1137 tree name
= DECL_NAME (t
);
1139 /* We can get here with a decl that was synthesized by language-
1140 independent machinery (e.g. coverage.c) in which case it won't
1141 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1142 will crash. In this case it is safe just to print out the
1144 if (!DECL_LANG_SPECIFIC (t
))
1146 pp_cxx_tree_identifier (cxx_pp
, name
);
1150 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1151 t
= DECL_TEMPLATE_RESULT (t
);
1153 /* Don't let the user see __comp_ctor et al. */
1154 if (DECL_CONSTRUCTOR_P (t
)
1155 || DECL_DESTRUCTOR_P (t
))
1156 name
= constructor_name (DECL_CONTEXT (t
));
1158 if (DECL_DESTRUCTOR_P (t
))
1160 pp_cxx_complement (cxx_pp
);
1161 dump_decl (name
, TFF_PLAIN_IDENTIFIER
);
1163 else if (DECL_CONV_FN_P (t
))
1165 /* This cannot use the hack that the operator's return
1166 type is stashed off of its name because it may be
1167 used for error reporting. In the case of conflicting
1168 declarations, both will have the same name, yet
1169 the types will be different, hence the TREE_TYPE field
1170 of the first name will be clobbered by the second. */
1171 pp_cxx_identifier (cxx_pp
, "operator");
1172 dump_type (TREE_TYPE (TREE_TYPE (t
)), flags
);
1174 else if (IDENTIFIER_OPNAME_P (name
))
1175 pp_cxx_tree_identifier (cxx_pp
, name
);
1177 dump_decl (name
, flags
);
1179 if (DECL_TEMPLATE_INFO (t
)
1180 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1181 && (DECL_TEMPLATE_SPECIALIZATION (t
)
1182 || TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1183 || DECL_TEMPLATE_SPECIALIZATION (DECL_TI_TEMPLATE (t
))
1184 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1185 dump_template_parms (DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
), flags
);
1188 /* Dump the template parameters from the template info INFO under control of
1189 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1190 specialization (partial or complete). For partial specializations we show
1191 the specialized parameter values. For a primary template we show no
1195 dump_template_parms (tree info
, int primary
, int flags
)
1197 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1199 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1201 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1202 pp_cxx_begin_template_argument_list (cxx_pp
);
1204 /* Be careful only to print things when we have them, so as not
1205 to crash producing error messages. */
1206 if (args
&& !primary
)
1210 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
1211 args
= TREE_VEC_ELT (args
, TREE_VEC_LENGTH (args
) - 1);
1213 len
= TREE_VEC_LENGTH (args
);
1215 for (ix
= 0; ix
!= len
; ix
++)
1217 tree arg
= TREE_VEC_ELT (args
, ix
);
1220 pp_separate_with_comma (cxx_pp
);
1223 pp_identifier (cxx_pp
, "<template parameter error>");
1225 dump_template_argument (arg
, flags
);
1230 tree tpl
= TI_TEMPLATE (info
);
1231 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1234 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1235 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1237 for (ix
= 0; ix
!= len
; ix
++)
1239 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1242 pp_separate_with_comma (cxx_pp
);
1244 dump_decl (parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1247 pp_cxx_end_template_argument_list (cxx_pp
);
1250 /* Print out a list of initializers (subr of dump_expr). */
1253 dump_expr_list (tree l
, int flags
)
1257 dump_expr (TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1260 pp_separate_with_comma (cxx_pp
);
1264 /* Print out an expression E under control of FLAGS. */
1267 dump_expr (tree t
, int flags
)
1272 switch (TREE_CODE (t
))
1280 case NAMESPACE_DECL
:
1282 case IDENTIFIER_NODE
:
1283 dump_decl (t
, (flags
& ~TFF_DECL_SPECIFIERS
) | TFF_NO_FUNCTION_ARGUMENTS
);
1289 pp_c_constant (pp_c_base (cxx_pp
), t
);
1293 pp_cxx_identifier (cxx_pp
, "throw");
1294 dump_expr (TREE_OPERAND (t
, 0), flags
);
1298 pp_ampersand (cxx_pp
);
1299 dump_type (PTRMEM_CST_CLASS (t
), flags
);
1300 pp_cxx_colon_colon (cxx_pp
);
1301 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
1305 pp_cxx_left_paren (cxx_pp
);
1306 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1307 pp_separate_with_comma (cxx_pp
);
1308 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1309 pp_cxx_right_paren (cxx_pp
);
1313 pp_cxx_left_paren (cxx_pp
);
1314 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1315 pp_string (cxx_pp
, " ? ");
1316 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1317 pp_string (cxx_pp
, " : ");
1318 dump_expr (TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
1319 pp_cxx_right_paren (cxx_pp
);
1323 if (TREE_HAS_CONSTRUCTOR (t
))
1325 pp_cxx_identifier (cxx_pp
, "new");
1326 pp_cxx_whitespace (cxx_pp
);
1327 dump_type (TREE_TYPE (TREE_TYPE (t
)), flags
);
1330 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1333 case AGGR_INIT_EXPR
:
1335 tree fn
= NULL_TREE
;
1337 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
)
1338 fn
= TREE_OPERAND (TREE_OPERAND (t
, 0), 0);
1340 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
1342 if (DECL_CONSTRUCTOR_P (fn
))
1343 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (TREE_TYPE (t
)));
1348 dump_expr (TREE_OPERAND (t
, 0), 0);
1350 pp_cxx_left_paren (cxx_pp
);
1351 if (TREE_OPERAND (t
, 1))
1352 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t
, 1)), flags
);
1353 pp_cxx_right_paren (cxx_pp
);
1358 tree fn
= TREE_OPERAND (t
, 0);
1359 tree args
= TREE_OPERAND (t
, 1);
1361 if (TREE_CODE (fn
) == ADDR_EXPR
)
1362 fn
= TREE_OPERAND (fn
, 0);
1364 if (TREE_TYPE (fn
) != NULL_TREE
&& NEXT_CODE (fn
) == METHOD_TYPE
)
1366 tree ob
= TREE_VALUE (args
);
1367 if (TREE_CODE (ob
) == ADDR_EXPR
)
1369 dump_expr (TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
1372 else if (TREE_CODE (ob
) != PARM_DECL
1373 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
1375 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1378 args
= TREE_CHAIN (args
);
1380 dump_expr (fn
, flags
| TFF_EXPR_IN_PARENS
);
1381 pp_cxx_left_paren (cxx_pp
);
1382 dump_expr_list (args
, flags
);
1383 pp_cxx_right_paren (cxx_pp
);
1389 tree type
= TREE_OPERAND (t
, 1);
1390 tree init
= TREE_OPERAND (t
, 2);
1391 if (NEW_EXPR_USE_GLOBAL (t
))
1392 pp_cxx_colon_colon (cxx_pp
);
1393 pp_cxx_identifier (cxx_pp
, "new");
1394 if (TREE_OPERAND (t
, 0))
1396 pp_cxx_left_paren (cxx_pp
);
1397 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
1398 pp_cxx_right_paren (cxx_pp
);
1399 pp_cxx_whitespace (cxx_pp
);
1401 if (TREE_CODE (type
) == ARRAY_REF
)
1402 type
= build_cplus_array_type
1403 (TREE_OPERAND (type
, 0),
1404 build_index_type (fold (build (MINUS_EXPR
, integer_type_node
,
1405 TREE_OPERAND (type
, 1),
1406 integer_one_node
))));
1407 dump_type (type
, flags
);
1410 pp_cxx_left_paren (cxx_pp
);
1411 if (TREE_CODE (init
) == TREE_LIST
)
1412 dump_expr_list (init
, flags
);
1413 else if (init
== void_zero_node
)
1414 /* This representation indicates an empty initializer,
1415 e.g.: "new int()". */
1418 dump_expr (init
, flags
);
1419 pp_cxx_right_paren (cxx_pp
);
1425 /* Note that this only works for G++ target exprs. If somebody
1426 builds a general TARGET_EXPR, there's no way to represent that
1427 it initializes anything other that the parameter slot for the
1428 default argument. Note we may have cleared out the first
1429 operand in expand_expr, so don't go killing ourselves. */
1430 if (TREE_OPERAND (t
, 1))
1431 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1439 case TRUNC_DIV_EXPR
:
1440 case TRUNC_MOD_EXPR
:
1448 case TRUTH_ANDIF_EXPR
:
1449 case TRUTH_ORIF_EXPR
:
1456 case EXACT_DIV_EXPR
:
1457 dump_binary_op (operator_name_info
[(int) TREE_CODE (t
)].name
, t
, flags
);
1461 case FLOOR_DIV_EXPR
:
1462 case ROUND_DIV_EXPR
:
1463 dump_binary_op ("/", t
, flags
);
1467 case FLOOR_MOD_EXPR
:
1468 case ROUND_MOD_EXPR
:
1469 dump_binary_op ("%", t
, flags
);
1474 tree ob
= TREE_OPERAND (t
, 0);
1475 if (TREE_CODE (ob
) == INDIRECT_REF
)
1477 ob
= TREE_OPERAND (ob
, 0);
1478 if (TREE_CODE (ob
) != PARM_DECL
1479 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
1481 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1482 pp_cxx_arrow (cxx_pp
);
1487 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1488 pp_cxx_dot (cxx_pp
);
1490 dump_expr (TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
1495 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1496 pp_cxx_left_bracket (cxx_pp
);
1497 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1498 pp_cxx_right_bracket (cxx_pp
);
1502 if (TREE_TYPE (t
) && VOID_TYPE_P (TREE_TYPE (t
)))
1504 pp_cxx_left_paren (cxx_pp
);
1505 dump_type (TREE_TYPE (t
), flags
);
1506 pp_cxx_right_paren (cxx_pp
);
1507 dump_expr (TREE_OPERAND (t
, 0), flags
);
1510 dump_unary_op ("+", t
, flags
);
1514 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
1515 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
1516 /* An ADDR_EXPR can have reference type. In that case, we
1517 shouldn't print the `&' doing so indicates to the user
1518 that the expression has pointer type. */
1520 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
1521 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1523 dump_unary_op ("&", t
, flags
);
1527 if (TREE_HAS_CONSTRUCTOR (t
))
1529 t
= TREE_OPERAND (t
, 0);
1530 my_friendly_assert (TREE_CODE (t
) == CALL_EXPR
, 237);
1531 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1532 pp_cxx_left_paren (cxx_pp
);
1533 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t
, 1)), flags
);
1534 pp_cxx_right_paren (cxx_pp
);
1538 if (TREE_OPERAND (t
,0) != NULL_TREE
1539 && TREE_TYPE (TREE_OPERAND (t
, 0))
1540 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
1541 dump_expr (TREE_OPERAND (t
, 0), flags
);
1543 dump_unary_op ("*", t
, flags
);
1549 case TRUTH_NOT_EXPR
:
1550 case PREDECREMENT_EXPR
:
1551 case PREINCREMENT_EXPR
:
1552 dump_unary_op (operator_name_info
[(int)TREE_CODE (t
)].name
, t
, flags
);
1555 case POSTDECREMENT_EXPR
:
1556 case POSTINCREMENT_EXPR
:
1557 pp_cxx_left_paren (cxx_pp
);
1558 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1559 pp_cxx_identifier (cxx_pp
, operator_name_info
[(int)TREE_CODE (t
)].name
);
1560 pp_cxx_right_paren (cxx_pp
);
1563 case NON_LVALUE_EXPR
:
1564 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1565 should be another level of INDIRECT_REF so that I don't have to do
1567 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
1569 tree next
= TREE_TYPE (TREE_TYPE (t
));
1571 while (TREE_CODE (next
) == POINTER_TYPE
)
1572 next
= TREE_TYPE (next
);
1574 if (TREE_CODE (next
) == FUNCTION_TYPE
)
1576 if (flags
& TFF_EXPR_IN_PARENS
)
1577 pp_cxx_left_paren (cxx_pp
);
1578 pp_cxx_star (cxx_pp
);
1579 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1580 if (flags
& TFF_EXPR_IN_PARENS
)
1581 pp_cxx_right_paren (cxx_pp
);
1584 /* Else fall through. */
1586 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1591 tree op
= TREE_OPERAND (t
, 0);
1593 if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
1595 /* It is a cast, but we cannot tell whether it is a
1596 reinterpret or static cast. Use the C style notation. */
1597 if (flags
& TFF_EXPR_IN_PARENS
)
1598 pp_cxx_left_paren (cxx_pp
);
1599 pp_cxx_left_paren (cxx_pp
);
1600 dump_type (TREE_TYPE (t
), flags
);
1601 pp_cxx_right_paren (cxx_pp
);
1602 dump_expr (op
, flags
| TFF_EXPR_IN_PARENS
);
1603 if (flags
& TFF_EXPR_IN_PARENS
)
1604 pp_cxx_right_paren (cxx_pp
);
1607 dump_expr (op
, flags
);
1612 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
1614 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
1616 if (integer_zerop (idx
))
1618 /* A NULL pointer-to-member constant. */
1619 pp_cxx_left_paren (cxx_pp
);
1620 pp_cxx_left_paren (cxx_pp
);
1621 dump_type (TREE_TYPE (t
), flags
);
1622 pp_cxx_right_paren (cxx_pp
);
1623 pp_character (cxx_pp
, '0');
1624 pp_cxx_right_paren (cxx_pp
);
1627 else if (host_integerp (idx
, 0))
1630 unsigned HOST_WIDE_INT n
;
1632 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
1633 t
= TYPE_METHOD_BASETYPE (t
);
1634 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
1636 n
= tree_low_cst (idx
, 0);
1638 /* Map vtable index back one, to allow for the null pointer to
1642 while (n
> 0 && virtuals
)
1645 virtuals
= TREE_CHAIN (virtuals
);
1649 dump_expr (BV_FN (virtuals
),
1650 flags
| TFF_EXPR_IN_PARENS
);
1655 if (TREE_TYPE (t
) && !CONSTRUCTOR_ELTS (t
))
1657 dump_type (TREE_TYPE (t
), 0);
1658 pp_cxx_left_paren (cxx_pp
);
1659 pp_cxx_right_paren (cxx_pp
);
1663 pp_cxx_left_brace (cxx_pp
);
1664 dump_expr_list (CONSTRUCTOR_ELTS (t
), flags
);
1665 pp_cxx_right_brace (cxx_pp
);
1672 tree ob
= TREE_OPERAND (t
, 0);
1673 if (is_dummy_object (ob
))
1675 t
= TREE_OPERAND (t
, 1);
1676 if (TREE_CODE (t
) == FUNCTION_DECL
)
1678 dump_expr (t
, flags
| TFF_EXPR_IN_PARENS
);
1679 else if (BASELINK_P (t
))
1680 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t
)),
1681 flags
| TFF_EXPR_IN_PARENS
);
1683 dump_decl (t
, flags
);
1687 if (TREE_CODE (ob
) == INDIRECT_REF
)
1689 dump_expr (TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
1690 pp_cxx_arrow (cxx_pp
);
1691 pp_cxx_star (cxx_pp
);
1695 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1696 pp_cxx_dot (cxx_pp
);
1697 pp_cxx_star (cxx_pp
);
1699 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1704 case TEMPLATE_PARM_INDEX
:
1705 dump_decl (TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
1709 pp_expression (cxx_pp
, t
);
1713 if (TREE_OPERAND (t
, 0) == NULL_TREE
1714 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
1716 dump_type (TREE_TYPE (t
), flags
);
1717 pp_cxx_left_paren (cxx_pp
);
1718 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
1719 pp_cxx_right_paren (cxx_pp
);
1723 pp_cxx_left_paren (cxx_pp
);
1724 dump_type (TREE_TYPE (t
), flags
);
1725 pp_cxx_right_paren (cxx_pp
);
1726 pp_cxx_left_paren (cxx_pp
);
1727 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
1728 pp_cxx_right_paren (cxx_pp
);
1732 case STATIC_CAST_EXPR
:
1733 pp_cxx_identifier (cxx_pp
, "static_cast");
1735 case REINTERPRET_CAST_EXPR
:
1736 pp_cxx_identifier (cxx_pp
, "reinterpret_cast");
1738 case CONST_CAST_EXPR
:
1739 pp_cxx_identifier (cxx_pp
, "const_cast");
1741 case DYNAMIC_CAST_EXPR
:
1742 pp_cxx_identifier (cxx_pp
, "dynamic_cast");
1744 pp_cxx_begin_template_argument_list (cxx_pp
);
1745 dump_type (TREE_TYPE (t
), flags
);
1746 pp_cxx_end_template_argument_list (cxx_pp
);
1747 pp_cxx_left_paren (cxx_pp
);
1748 dump_expr (TREE_OPERAND (t
, 0), flags
);
1749 pp_cxx_right_paren (cxx_pp
);
1753 dump_expr (TREE_OPERAND (t
, 0), flags
);
1754 pp_cxx_arrow (cxx_pp
);
1759 if (TREE_CODE (t
) == SIZEOF_EXPR
)
1760 pp_cxx_identifier (cxx_pp
, "sizeof");
1763 my_friendly_assert (TREE_CODE (t
) == ALIGNOF_EXPR
, 0);
1764 pp_cxx_identifier (cxx_pp
, "__alignof__");
1766 pp_cxx_whitespace (cxx_pp
);
1767 pp_cxx_left_paren (cxx_pp
);
1768 if (TYPE_P (TREE_OPERAND (t
, 0)))
1769 dump_type (TREE_OPERAND (t
, 0), flags
);
1771 dump_expr (TREE_OPERAND (t
, 0), flags
);
1772 pp_cxx_right_paren (cxx_pp
);
1777 pp_cxx_identifier (cxx_pp
, operator_name_info
[TREE_CODE (t
)].name
);
1778 pp_cxx_whitespace (cxx_pp
);
1779 dump_expr (TREE_OPERAND (t
, 0), flags
);
1783 pp_identifier (cxx_pp
, "<unparsed>");
1786 case TRY_CATCH_EXPR
:
1787 case WITH_CLEANUP_EXPR
:
1788 case CLEANUP_POINT_EXPR
:
1789 dump_expr (TREE_OPERAND (t
, 0), flags
);
1792 case PSEUDO_DTOR_EXPR
:
1793 dump_expr (TREE_OPERAND (t
, 2), flags
);
1794 pp_cxx_dot (cxx_pp
);
1795 dump_type (TREE_OPERAND (t
, 0), flags
);
1796 pp_cxx_colon_colon (cxx_pp
);
1797 pp_cxx_complement (cxx_pp
);
1798 dump_type (TREE_OPERAND (t
, 1), flags
);
1801 case TEMPLATE_ID_EXPR
:
1802 dump_decl (t
, flags
);
1806 /* We don't yet have a way of dumping statements in a
1807 human-readable format. */
1808 pp_string (cxx_pp
, "({...})");
1812 pp_cxx_left_brace (cxx_pp
);
1813 dump_expr (TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
1814 pp_cxx_right_brace (cxx_pp
);
1818 pp_string (cxx_pp
, "while (1) { ");
1819 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1820 pp_cxx_right_brace (cxx_pp
);
1824 pp_string (cxx_pp
, "if (");
1825 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1826 pp_string (cxx_pp
, ") break; ");
1830 dump_expr (get_first_fn (t
), flags
& ~TFF_EXPR_IN_PARENS
);
1833 case EMPTY_CLASS_EXPR
:
1834 dump_type (TREE_TYPE (t
), flags
);
1835 pp_cxx_left_paren (cxx_pp
);
1836 pp_cxx_right_paren (cxx_pp
);
1839 case NON_DEPENDENT_EXPR
:
1840 dump_expr (TREE_OPERAND (t
, 0), flags
);
1843 /* This list is incomplete, but should suffice for now.
1844 It is very important that `sorry' does not call
1845 `report_error_function'. That could cause an infinite loop. */
1847 pp_unsupported_tree (cxx_pp
, t
);
1848 /* fall through to ERROR_MARK... */
1850 pp_identifier (cxx_pp
, "<expression error>");
1856 dump_binary_op (const char *opstring
, tree t
, int flags
)
1858 pp_cxx_left_paren (cxx_pp
);
1859 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1860 pp_cxx_whitespace (cxx_pp
);
1862 pp_cxx_identifier (cxx_pp
, opstring
);
1864 pp_identifier (cxx_pp
, "<unknown operator>");
1865 pp_cxx_whitespace (cxx_pp
);
1866 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1867 pp_cxx_right_paren (cxx_pp
);
1871 dump_unary_op (const char *opstring
, tree t
, int flags
)
1873 if (flags
& TFF_EXPR_IN_PARENS
)
1874 pp_cxx_left_paren (cxx_pp
);
1875 pp_cxx_identifier (cxx_pp
, opstring
);
1876 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1877 if (flags
& TFF_EXPR_IN_PARENS
)
1878 pp_cxx_right_paren (cxx_pp
);
1882 reinit_cxx_pp (void)
1884 pp_clear_output_area (cxx_pp
);
1885 pp_base (cxx_pp
)->padding
= pp_none
;
1886 pp_indentation (cxx_pp
) = 0;
1887 pp_needs_newline (cxx_pp
) = false;
1888 cxx_pp
->enclosing_scope
= 0;
1892 /* Exported interface to stringifying types, exprs and decls under TFF_*
1896 type_as_string (tree typ
, int flags
)
1899 dump_type (typ
, flags
);
1900 return pp_formatted_text (cxx_pp
);
1904 expr_as_string (tree decl
, int flags
)
1907 dump_expr (decl
, flags
);
1908 return pp_formatted_text (cxx_pp
);
1912 decl_as_string (tree decl
, int flags
)
1915 dump_decl (decl
, flags
);
1916 return pp_formatted_text (cxx_pp
);
1920 context_as_string (tree context
, int flags
)
1923 dump_scope (context
, flags
);
1924 return pp_formatted_text (cxx_pp
);
1927 /* Generate the three forms of printable names for cxx_printable_name. */
1930 lang_decl_name (tree decl
, int v
)
1933 return decl_as_string (decl
, TFF_DECL_SPECIFIERS
);
1936 if (v
== 1 && DECL_CLASS_SCOPE_P (decl
))
1938 dump_type (CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
1939 pp_cxx_colon_colon (cxx_pp
);
1942 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1943 dump_function_name (decl
, TFF_PLAIN_IDENTIFIER
);
1945 dump_decl (DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
1947 return pp_formatted_text (cxx_pp
);
1951 location_of (tree t
)
1953 if (TREE_CODE (t
) == PARM_DECL
&& DECL_CONTEXT (t
))
1954 t
= DECL_CONTEXT (t
);
1955 else if (TYPE_P (t
))
1956 t
= TYPE_MAIN_DECL (t
);
1957 else if (TREE_CODE (t
) == OVERLOAD
)
1958 t
= OVL_FUNCTION (t
);
1960 return DECL_SOURCE_LOCATION (t
);
1963 /* Now the interfaces from error et al to dump_type et al. Each takes an
1964 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
1968 decl_to_string (tree decl
, int verbose
)
1972 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
1973 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
1974 flags
= TFF_CLASS_KEY_OR_ENUM
;
1976 flags
|= TFF_DECL_SPECIFIERS
;
1977 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
1978 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
1979 flags
|= TFF_TEMPLATE_HEADER
;
1982 dump_decl (decl
, flags
);
1983 return pp_formatted_text (cxx_pp
);
1987 expr_to_string (tree decl
)
1990 dump_expr (decl
, 0);
1991 return pp_formatted_text (cxx_pp
);
1995 fndecl_to_string (tree fndecl
, int verbose
)
1999 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
;
2001 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
2003 dump_decl (fndecl
, flags
);
2004 return pp_formatted_text (cxx_pp
);
2009 code_to_string (enum tree_code c
)
2011 return tree_code_name
[c
];
2015 language_to_string (enum languages c
)
2022 case lang_cplusplus
:
2034 /* Return the proper printed version of a parameter to a C++ function. */
2037 parm_to_string (int p
)
2041 pp_string (cxx_pp
, "'this'");
2043 pp_decimal_int (cxx_pp
, p
+ 1);
2044 return pp_formatted_text (cxx_pp
);
2048 op_to_string (enum tree_code p
)
2050 tree id
= operator_name_info
[(int) p
].identifier
;
2051 return id
? IDENTIFIER_POINTER (id
) : "<unknown>";
2055 type_to_string (tree typ
, int verbose
)
2059 flags
|= TFF_CLASS_KEY_OR_ENUM
;
2060 flags
|= TFF_TEMPLATE_HEADER
;
2063 dump_type (typ
, flags
);
2064 return pp_formatted_text (cxx_pp
);
2068 assop_to_string (enum tree_code p
)
2070 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
2071 return id
? IDENTIFIER_POINTER (id
) : "{unknown}";
2075 args_to_string (tree p
, int verbose
)
2079 flags
|= TFF_CLASS_KEY_OR_ENUM
;
2084 if (TYPE_P (TREE_VALUE (p
)))
2085 return type_as_string (p
, flags
);
2088 for (; p
; p
= TREE_CHAIN (p
))
2090 if (TREE_VALUE (p
) == null_node
)
2091 pp_cxx_identifier (cxx_pp
, "NULL");
2093 dump_type (error_type (TREE_VALUE (p
)), flags
);
2095 pp_separate_with_comma (cxx_pp
);
2097 return pp_formatted_text (cxx_pp
);
2101 cv_to_string (tree p
, int v
)
2104 pp_base (cxx_pp
)->padding
= v
? pp_before
: pp_none
;
2105 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
2106 return pp_formatted_text (cxx_pp
);
2109 /* Langhook for print_error_function. */
2111 cxx_print_error_function (diagnostic_context
*context
, const char *file
)
2113 lhd_print_error_function (context
, file
);
2114 pp_base_set_prefix (context
->printer
, file
);
2115 maybe_print_instantiation_context (context
);
2119 cp_diagnostic_starter (diagnostic_context
*context
,
2120 diagnostic_info
*diagnostic
)
2122 diagnostic_report_current_module (context
);
2123 cp_print_error_function (context
, diagnostic
);
2124 maybe_print_instantiation_context (context
);
2125 pp_base_set_prefix (context
->printer
, diagnostic_build_prefix (diagnostic
));
2129 cp_diagnostic_finalizer (diagnostic_context
*context
,
2130 diagnostic_info
*diagnostic ATTRIBUTE_UNUSED
)
2132 pp_base_destroy_prefix (context
->printer
);
2135 /* Print current function onto BUFFER, in the process of reporting
2136 a diagnostic message. Called from cp_diagnostic_starter. */
2138 cp_print_error_function (diagnostic_context
*context
,
2139 diagnostic_info
*diagnostic
)
2141 if (diagnostic_last_function_changed (context
))
2143 const char *old_prefix
= context
->printer
->prefix
;
2144 const char *file
= LOCATION_FILE (diagnostic
->location
);
2145 char *new_prefix
= file
? file_name_as_prefix (file
) : NULL
;
2147 pp_base_set_prefix (context
->printer
, new_prefix
);
2149 if (current_function_decl
== NULL
)
2150 pp_base_string (context
->printer
, "At global scope:");
2152 pp_printf (context
->printer
, "In %s `%s':",
2153 function_category (current_function_decl
),
2154 cxx_printable_name (current_function_decl
, 2));
2155 pp_base_newline (context
->printer
);
2157 diagnostic_set_last_function (context
);
2158 pp_base_destroy_prefix (context
->printer
);
2159 context
->printer
->prefix
= old_prefix
;
2163 /* Returns a description of FUNCTION using standard terminology. */
2165 function_category (tree fn
)
2167 if (DECL_FUNCTION_MEMBER_P (fn
))
2169 if (DECL_STATIC_FUNCTION_P (fn
))
2170 return "static member function";
2171 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
2172 return "copy constructor";
2173 else if (DECL_CONSTRUCTOR_P (fn
))
2174 return "constructor";
2175 else if (DECL_DESTRUCTOR_P (fn
))
2176 return "destructor";
2178 return "member function";
2184 /* Report the full context of a current template instantiation,
2187 print_instantiation_full_context (diagnostic_context
*context
)
2189 tree p
= current_instantiation ();
2190 location_t location
= input_location
;
2194 if (current_function_decl
!= TINST_DECL (p
)
2195 && current_function_decl
!= NULL_TREE
)
2196 /* We can get here during the processing of some synthesized
2197 method. Then, TINST_DECL (p) will be the function that's causing
2202 if (current_function_decl
== TINST_DECL (p
))
2203 /* Avoid redundancy with the the "In function" line. */;
2205 pp_verbatim (context
->printer
,
2206 "%s: In instantiation of `%s':\n",
2207 LOCATION_FILE (location
),
2208 decl_as_string (TINST_DECL (p
),
2209 TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
));
2211 location
= EXPR_LOCATION (p
);
2216 print_instantiation_partial_context (context
, p
, location
);
2219 /* Same as above but less verbose. */
2221 print_instantiation_partial_context (diagnostic_context
*context
,
2222 tree t
, location_t loc
)
2224 expanded_location xloc
;
2225 for (; ; t
= TREE_CHAIN (t
))
2227 xloc
= expand_location (loc
);
2230 pp_verbatim (context
->printer
, "%s:%d: instantiated from `%s'\n",
2231 xloc
.file
, xloc
.line
,
2232 decl_as_string (TINST_DECL (t
),
2233 TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
));
2234 loc
= EXPR_LOCATION (t
);
2236 pp_verbatim (context
->printer
, "%s:%d: instantiated from here\n",
2237 xloc
.file
, xloc
.line
);
2240 /* Called from cp_thing to print the template context for an error. */
2242 maybe_print_instantiation_context (diagnostic_context
*context
)
2244 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2247 record_last_problematic_instantiation ();
2248 print_instantiation_full_context (context
);
2251 /* Report the bare minimum context of a template instantiation. */
2253 print_instantiation_context (void)
2255 print_instantiation_partial_context
2256 (global_dc
, current_instantiation (), input_location
);
2257 diagnostic_flush_buffer (global_dc
);
2260 /* Called from output_format -- during diagnostic message processing --
2261 to handle C++ specific format specifier with the following meanings:
2262 %A function argument-list.
2266 %F function declaration.
2267 %L language as used in extern "lang".
2269 %P function parameter whose position is indicated by an integer.
2270 %Q assignment operator.
2274 cp_printer (pretty_printer
*pp
, text_info
*text
)
2278 #define next_tree va_arg (*text->args_ptr, tree)
2279 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2280 #define next_lang va_arg (*text->args_ptr, enum languages)
2281 #define next_int va_arg (*text->args_ptr, int)
2283 if (*text
->format_spec
== '+')
2284 ++text
->format_spec
;
2285 if (*text
->format_spec
== '#')
2288 ++text
->format_spec
;
2291 switch (*text
->format_spec
)
2293 case 'A': result
= args_to_string (next_tree
, verbose
); break;
2294 case 'C': result
= code_to_string (next_tcode
); break;
2295 case 'D': result
= decl_to_string (next_tree
, verbose
); break;
2296 case 'E': result
= expr_to_string (next_tree
); break;
2297 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
2298 case 'L': result
= language_to_string (next_lang
); break;
2299 case 'O': result
= op_to_string (next_tcode
); break;
2300 case 'P': result
= parm_to_string (next_int
); break;
2301 case 'Q': result
= assop_to_string (next_tcode
); break;
2302 case 'T': result
= type_to_string (next_tree
, verbose
); break;
2303 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
2309 pp_base_string (pp
, result
);
2317 /* These are temporary wrapper functions which handle the historic
2318 behavior of cp_*_at. */
2321 locate_error (const char *msgid
, va_list ap
)
2327 for (f
= msgid
; *f
; f
++)
2340 /* Just ignore these possibilities. */
2343 case 'd': (void) va_arg (ap
, int); break;
2344 case 's': (void) va_arg (ap
, char *); break;
2345 case 'L': (void) va_arg (ap
, enum languages
); break;
2348 case 'Q': (void) va_arg (ap
, enum tree_code
); break;
2350 /* These take a tree, which may be where the error is
2358 t
= va_arg (ap
, tree
);
2364 errorcount
= 0; /* damn ICE suppression */
2365 internal_error ("unexpected letter `%c' in locate_error\n", *f
);
2371 here
= va_arg (ap
, tree
);
2378 cp_error_at (const char *msgid
, ...)
2381 diagnostic_info diagnostic
;
2384 va_start (ap
, msgid
);
2385 here
= locate_error (msgid
, ap
);
2388 va_start (ap
, msgid
);
2389 diagnostic_set_info (&diagnostic
, msgid
, &ap
,
2390 location_of (here
), DK_ERROR
);
2391 report_diagnostic (&diagnostic
);
2396 cp_warning_at (const char *msgid
, ...)
2399 diagnostic_info diagnostic
;
2402 va_start (ap
, msgid
);
2403 here
= locate_error (msgid
, ap
);
2406 va_start (ap
, msgid
);
2407 diagnostic_set_info (&diagnostic
, msgid
, &ap
,
2408 location_of (here
), DK_WARNING
);
2409 report_diagnostic (&diagnostic
);
2414 cp_pedwarn_at (const char *msgid
, ...)
2417 diagnostic_info diagnostic
;
2420 va_start (ap
, msgid
);
2421 here
= locate_error (msgid
, ap
);
2424 va_start (ap
, msgid
);
2425 diagnostic_set_info (&diagnostic
, msgid
, &ap
,
2426 location_of (here
), pedantic_error_kind());
2427 report_diagnostic (&diagnostic
);