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 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 enum pad { none, before, after };
37 #define pp_template_argument_list_start(PP) \
38 pp_non_consecutive_character (PP, '<')
39 #define pp_template_argument_list_end(PP) \
40 pp_non_consecutive_character (PP, '>')
41 #define pp_separate_with_comma(PP) pp_string (PP, ", ")
43 /* The global buffer where we dump everything. It is there only for
44 transitional purpose. It is expected, in the near future, to be
45 completely removed. */
46 static cxx_pretty_printer scratch_pretty_printer;
47 #define cxx_pp (&scratch_pretty_printer)
49 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
51 #define reinit_global_formatting_buffer() \
52 output_clear_message_text (scratch_buffer)
54 static const char *args_to_string (tree, int);
55 static const char *assop_to_string (enum tree_code);
56 static const char *code_to_string (enum tree_code);
57 static const char *cv_to_string (tree, int);
58 static const char *decl_to_string (tree, int);
59 static const char *expr_to_string (tree);
60 static const char *fndecl_to_string (tree, int);
61 static const char *op_to_string (enum tree_code);
62 static const char *parm_to_string (int);
63 static const char *type_to_string (tree, int);
65 static void dump_type (tree, int);
66 static void dump_typename (tree, int);
67 static void dump_simple_decl (tree, tree, int);
68 static void dump_decl (tree, int);
69 static void dump_template_decl (tree, int);
70 static void dump_function_decl (tree, int);
71 static void dump_expr (tree, int);
72 static void dump_unary_op (const char *, tree, int);
73 static void dump_binary_op (const char *, tree, int);
74 static void dump_aggr_type (tree, int);
75 static enum pad dump_type_prefix (tree, int);
76 static void dump_type_suffix (tree, int);
77 static void dump_function_name (tree, int);
78 static void dump_expr_list (tree, int);
79 static void dump_global_iord (tree);
80 static enum pad dump_qualifiers (tree, enum pad);
81 static void dump_parameters (tree, int);
82 static void dump_exception_spec (tree, int);
83 static const char *class_key_or_enum (tree);
84 static void dump_template_argument (tree, int);
85 static void dump_template_argument_list (tree, int);
86 static void dump_template_parameter (tree, int);
87 static void dump_template_bindings (tree, tree);
88 static void dump_scope (tree, int);
89 static void dump_template_parms (tree, int, int);
91 static const char *function_category (tree);
92 static void maybe_print_instantiation_context (diagnostic_context *);
93 static void print_instantiation_full_context (diagnostic_context *);
94 static void print_instantiation_partial_context (diagnostic_context *,
96 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
97 static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
98 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
100 static bool cp_printer (pretty_printer *, text_info *);
101 static void pp_non_consecutive_character (cxx_pretty_printer *, int);
102 static tree locate_error (const char *, va_list);
103 static location_t location_of (tree);
108 diagnostic_starter (global_dc) = cp_diagnostic_starter;
109 diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer;
110 diagnostic_format_decoder (global_dc) = cp_printer;
112 pp_construct (pp_base (cxx_pp), NULL, 0);
113 pp_cxx_pretty_printer_init (cxx_pp);
116 /* Dump a scope, if deemed necessary. */
119 dump_scope (tree scope, int flags)
121 int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF));
123 if (scope == NULL_TREE)
126 if (TREE_CODE (scope) == NAMESPACE_DECL)
128 if (scope != global_namespace)
130 dump_decl (scope, f);
131 pp_colon_colon (cxx_pp);
134 else if (AGGREGATE_TYPE_P (scope))
136 dump_type (scope, f);
137 pp_colon_colon (cxx_pp);
139 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
141 dump_function_decl (scope, f);
142 pp_colon_colon (cxx_pp);
146 /* Dump type qualifiers, providing padding as requested. Return an
147 indication of whether we dumped something. */
150 dump_qualifiers (tree t, enum pad p)
152 static const int masks[] =
153 {TYPE_QUAL_CONST, TYPE_QUAL_VOLATILE, TYPE_QUAL_RESTRICT};
154 static const char *const names[] =
155 {"const", "volatile", "__restrict"};
157 int quals = TYPE_QUALS (t);
158 int do_after = p == after;
162 for (ix = 0; ix != 3; ix++)
163 if (masks[ix] & quals)
168 pp_identifier (cxx_pp, names[ix]);
178 /* Dump the template ARGument under control of FLAGS. */
181 dump_template_argument (tree arg, int flags)
183 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
184 dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
186 dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
189 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
193 dump_template_argument_list (tree args, int flags)
195 int n = TREE_VEC_LENGTH (args);
199 for (i = 0; i< n; ++i)
202 pp_separate_with_comma (cxx_pp);
203 dump_template_argument (TREE_VEC_ELT (args, i), flags);
208 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
211 dump_template_parameter (tree parm, int flags)
213 tree p = TREE_VALUE (parm);
214 tree a = TREE_PURPOSE (parm);
216 if (TREE_CODE (p) == TYPE_DECL)
218 if (flags & TFF_DECL_SPECIFIERS)
220 pp_identifier (cxx_pp, "class");
224 pp_tree_identifier (cxx_pp, DECL_NAME (p));
227 else if (DECL_NAME (p))
228 pp_tree_identifier (cxx_pp, DECL_NAME (p));
230 pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
233 dump_decl (p, flags | TFF_DECL_SPECIFIERS);
235 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
237 pp_string (cxx_pp, " = ");
238 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
239 dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
241 dump_expr (a, flags | TFF_EXPR_IN_PARENS);
245 /* Dump, under control of FLAGS, a template-parameter-list binding.
246 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
250 dump_template_bindings (tree parms, tree args)
256 tree p = TREE_VALUE (parms);
257 int lvl = TMPL_PARMS_DEPTH (parms);
261 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
263 tree arg = NULL_TREE;
265 /* Don't crash if we had an invalid argument list. */
266 if (TMPL_ARGS_DEPTH (args) >= lvl)
268 tree lvl_args = TMPL_ARGS_LEVEL (args, lvl);
269 if (NUM_TMPL_ARGS (lvl_args) > arg_idx)
270 arg = TREE_VEC_ELT (lvl_args, arg_idx);
274 pp_separate_with_comma (cxx_pp);
275 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
276 pp_string (cxx_pp, " = ");
278 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
280 pp_identifier (cxx_pp, "<missing>");
286 parms = TREE_CHAIN (parms);
290 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
294 dump_type (tree t, int flags)
299 if (TYPE_PTRMEMFUNC_P (t))
302 switch (TREE_CODE (t))
305 pp_identifier (cxx_pp, "<unknown type>");
309 /* A list of function parms. */
310 dump_parameters (t, flags);
313 case IDENTIFIER_NODE:
314 pp_tree_identifier (cxx_pp, t);
318 dump_type (BINFO_TYPE (t), flags);
324 dump_aggr_type (t, flags);
328 if (flags & TFF_CHASE_TYPEDEF)
330 dump_type (DECL_ORIGINAL_TYPE (t)
331 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
334 /* Else fall through. */
338 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
347 pp_base (cxx_pp)->padding = pp_none;
348 pp_type_specifier_seq (cxx_pp, t);
351 case TEMPLATE_TEMPLATE_PARM:
352 /* For parameters inside template signature. */
353 if (TYPE_IDENTIFIER (t))
354 pp_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
356 pp_cxx_canonical_template_parameter (cxx_pp, t);
359 case BOUND_TEMPLATE_TEMPLATE_PARM:
361 tree args = TYPE_TI_ARGS (t);
362 dump_qualifiers (t, after);
363 pp_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
364 pp_template_argument_list_start (cxx_pp);
365 dump_template_argument_list (args, flags);
366 pp_template_argument_list_end (cxx_pp);
370 case TEMPLATE_TYPE_PARM:
371 dump_qualifiers (t, after);
372 if (TYPE_IDENTIFIER (t))
373 pp_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
375 pp_cxx_canonical_template_parameter
376 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
379 /* This is not always necessary for pointers and such, but doing this
380 reduces code size. */
389 dump_type_prefix (t, flags);
390 dump_type_suffix (t, flags);
394 dump_qualifiers (t, after);
395 pp_string (cxx_pp, "typename ");
396 dump_typename (t, flags);
399 case UNBOUND_CLASS_TEMPLATE:
400 dump_type (TYPE_CONTEXT (t), flags);
401 pp_colon_colon (cxx_pp);
402 pp_identifier (cxx_pp, "template ");
403 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
407 pp_string (cxx_pp, "__typeof (");
408 dump_expr (TYPE_FIELDS (t), flags & ~TFF_EXPR_IN_PARENS);
409 pp_right_paren (cxx_pp);
413 pp_unsupported_tree (cxx_pp, t);
414 /* Fall through to error. */
417 pp_identifier (cxx_pp, "<type error>");
422 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
426 dump_typename (tree t, int flags)
428 tree ctx = TYPE_CONTEXT (t);
430 if (TREE_CODE (ctx) == TYPENAME_TYPE)
431 dump_typename (ctx, flags);
433 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
434 pp_colon_colon (cxx_pp);
435 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
438 /* Return the name of the supplied aggregate, or enumeral type. */
441 class_key_or_enum (tree t)
443 if (TREE_CODE (t) == ENUMERAL_TYPE)
445 else if (TREE_CODE (t) == UNION_TYPE)
447 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
453 /* Print out a class declaration T under the control of FLAGS,
454 in the form `class foo'. */
457 dump_aggr_type (tree t, int flags)
460 const char *variety = class_key_or_enum (t);
464 dump_qualifiers (t, after);
466 if (flags & TFF_CLASS_KEY_OR_ENUM)
468 pp_identifier (cxx_pp, variety);
472 if (flags & TFF_CHASE_TYPEDEF)
473 t = TYPE_MAIN_VARIANT (t);
475 name = TYPE_NAME (t);
479 typdef = !DECL_ARTIFICIAL (name);
480 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
481 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
482 && (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
483 || TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
484 || DECL_TEMPLATE_SPECIALIZATION (CLASSTYPE_TI_TEMPLATE (t))
485 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
486 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
489 /* Because the template names are mangled, we have to locate
490 the most general template, and use that name. */
491 tree tpl = CLASSTYPE_TI_TEMPLATE (t);
493 while (DECL_TEMPLATE_INFO (tpl))
494 tpl = DECL_TI_TEMPLATE (tpl);
497 name = DECL_NAME (name);
500 if (name == 0 || ANON_AGGRNAME_P (name))
502 if (flags & TFF_CLASS_KEY_OR_ENUM)
503 pp_identifier (cxx_pp, "<anonymous>");
505 pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety);
508 pp_tree_identifier (cxx_pp, name);
510 dump_template_parms (TYPE_TEMPLATE_INFO (t),
511 !CLASSTYPE_USE_TEMPLATE (t),
512 flags & ~TFF_TEMPLATE_HEADER);
515 /* Dump into the obstack the initial part of the output for a given type.
516 This is necessary when dealing with things like functions returning
519 return type of `int (* fee ())()': pointer -> function -> int. Both
520 pointer (and reference and offset) and function (and member) types must
521 deal with prefix and suffix.
523 Arrays must also do this for DECL nodes, like int a[], and for things like
526 Return indicates how you should pad an object name after this. I.e. you
527 want to pad non-*, non-& cores, but not pad * or & types. */
530 dump_type_prefix (tree t, int flags)
532 enum pad padding = before;
534 if (TYPE_PTRMEMFUNC_P (t))
536 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
540 switch (TREE_CODE (t))
545 tree sub = TREE_TYPE (t);
547 padding = dump_type_prefix (sub, flags);
548 if (TREE_CODE (sub) == ARRAY_TYPE)
551 pp_left_paren (cxx_pp);
553 pp_character (cxx_pp, "&*"[TREE_CODE (t) == POINTER_TYPE]);
554 padding = dump_qualifiers (t, before);
560 padding = dump_type_prefix (TREE_TYPE (t), flags);
561 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
565 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
566 pp_colon_colon (cxx_pp);
569 padding = dump_qualifiers (t, none);
572 /* Can only be reached through function pointer -- this would not be
573 correct if FUNCTION_DECLs used it. */
575 padding = dump_type_prefix (TREE_TYPE (t), flags);
578 pp_left_paren (cxx_pp);
583 padding = dump_type_prefix (TREE_TYPE (t), flags);
586 pp_left_paren (cxx_pp);
588 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
589 pp_colon_colon (cxx_pp);
593 padding = dump_type_prefix (TREE_TYPE (t), flags);
597 case IDENTIFIER_NODE:
602 case TEMPLATE_TYPE_PARM:
603 case TEMPLATE_TEMPLATE_PARM:
604 case BOUND_TEMPLATE_TEMPLATE_PARM:
615 dump_type (t, flags);
620 pp_unsupported_tree (cxx_pp, t);
623 pp_identifier (cxx_pp, "<typeprefixerror>");
629 /* Dump the suffix of type T, under control of FLAGS. This is the part
630 which appears after the identifier (or function parms). */
633 dump_type_suffix (tree t, int flags)
635 if (TYPE_PTRMEMFUNC_P (t))
636 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
638 switch (TREE_CODE (t))
643 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
644 pp_right_paren (cxx_pp);
645 dump_type_suffix (TREE_TYPE (t), flags);
648 /* Can only be reached through function pointer. */
653 pp_right_paren (cxx_pp);
654 arg = TYPE_ARG_TYPES (t);
655 if (TREE_CODE (t) == METHOD_TYPE)
656 arg = TREE_CHAIN (arg);
658 /* Function pointers don't have default args. Not in standard C++,
659 anyway; they may in g++, but we'll just pretend otherwise. */
660 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
662 if (TREE_CODE (t) == METHOD_TYPE)
664 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), before);
665 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
666 dump_type_suffix (TREE_TYPE (t), flags);
671 pp_left_bracket (cxx_pp);
674 if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0))
676 (cxx_pp, tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1);
677 else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR)
678 dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0),
679 flags & ~TFF_EXPR_IN_PARENS);
681 dump_expr (fold (cp_build_binary_op
682 (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)),
684 flags & ~TFF_EXPR_IN_PARENS);
686 pp_right_bracket (cxx_pp);
687 dump_type_suffix (TREE_TYPE (t), flags);
691 case IDENTIFIER_NODE:
696 case TEMPLATE_TYPE_PARM:
697 case TEMPLATE_TEMPLATE_PARM:
698 case BOUND_TEMPLATE_TEMPLATE_PARM:
712 pp_unsupported_tree (cxx_pp, t);
714 /* Don't mark it here, we should have already done in
721 dump_global_iord (tree t)
723 const char *p = NULL;
725 if (DECL_GLOBAL_CTOR_P (t))
727 else if (DECL_GLOBAL_DTOR_P (t))
732 pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename);
736 dump_simple_decl (tree t, tree type, int flags)
738 if (flags & TFF_DECL_SPECIFIERS)
740 if (dump_type_prefix (type, flags) != none)
743 if (!DECL_INITIAL (t) || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX)
744 dump_scope (CP_DECL_CONTEXT (t), flags);
746 dump_decl (DECL_NAME (t), flags);
748 pp_identifier (cxx_pp, "<anonymous>");
749 if (flags & TFF_DECL_SPECIFIERS)
750 dump_type_suffix (type, flags);
753 /* Dump a human readable string for the decl T under control of FLAGS. */
756 dump_decl (tree t, int flags)
761 switch (TREE_CODE (t))
765 /* Don't say 'typedef class A' */
766 if (DECL_ARTIFICIAL (t))
768 if ((flags & TFF_DECL_SPECIFIERS)
769 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
770 /* Say `class T' not just `T'. */
771 pp_string (cxx_pp, "class ");
773 dump_type (TREE_TYPE (t), flags);
777 if (flags & TFF_DECL_SPECIFIERS)
778 pp_string (cxx_pp, "typedef ");
779 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
780 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
785 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
787 pp_string (cxx_pp, "vtable for ");
788 my_friendly_assert (TYPE_P (DECL_CONTEXT (t)), 20010720);
789 dump_type (DECL_CONTEXT (t), flags);
792 /* Else fall through. */
796 dump_simple_decl (t, TREE_TYPE (t), flags);
800 pp_string (cxx_pp, "<return value> ");
801 dump_simple_decl (t, TREE_TYPE (t), flags);
805 if (flags & TFF_DECL_SPECIFIERS)
806 pp_cxx_declaration (cxx_pp, t);
809 dump_scope (CP_DECL_CONTEXT (t), flags);
810 if (DECL_NAME (t) == NULL_TREE)
811 pp_identifier (cxx_pp, "<unnamed>");
813 pp_tree_identifier (cxx_pp, DECL_NAME (t));
818 pp_expression (cxx_pp, t);
822 dump_decl (TREE_OPERAND (t, 0), flags);
823 pp_left_bracket (cxx_pp);
824 dump_decl (TREE_OPERAND (t, 1), flags);
825 pp_right_bracket (cxx_pp);
828 /* So that we can do dump_decl on an aggr type. */
832 dump_type (t, flags);
836 /* This is a pseudo destructor call which has not been folded into
837 a PSEUDO_DTOR_EXPR yet. */
838 pp_complement (cxx_pp);
839 dump_type (TREE_OPERAND (t, 0), flags);
846 /* These special cases are duplicated here so that other functions
847 can feed identifiers to error and get them demangled properly. */
848 case IDENTIFIER_NODE:
849 if (IDENTIFIER_TYPENAME_P (t))
851 pp_string (cxx_pp, "operator ");
852 /* Not exactly IDENTIFIER_TYPE_VALUE. */
853 dump_type (TREE_TYPE (t), flags);
857 pp_tree_identifier (cxx_pp, t);
864 if (DECL_CLASS_SCOPE_P (t))
866 dump_type (DECL_CONTEXT (t), flags);
867 pp_colon_colon (cxx_pp);
869 else if (DECL_CONTEXT (t))
871 dump_decl (DECL_CONTEXT (t), flags);
872 pp_colon_colon (cxx_pp);
874 dump_decl (DECL_NAME (t), flags);
878 /* If there's only one function, just treat it like an ordinary
884 if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
885 dump_global_iord (t);
886 else if (! DECL_LANG_SPECIFIC (t))
887 pp_identifier (cxx_pp, "<internal>");
889 dump_function_decl (t, flags);
893 dump_template_decl (t, flags);
896 case TEMPLATE_ID_EXPR:
898 tree name = TREE_OPERAND (t, 0);
900 if (is_overloaded_fn (name))
901 name = DECL_NAME (get_first_fn (name));
902 dump_decl (name, flags);
903 pp_template_argument_list_start (cxx_pp);
904 if (TREE_OPERAND (t, 1))
905 dump_template_argument_list (TREE_OPERAND (t, 1), flags);
906 pp_template_argument_list_end (cxx_pp);
911 pp_tree_identifier (cxx_pp, DECL_NAME (t));
915 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
916 || (DECL_INITIAL (t) &&
917 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
918 dump_simple_decl (t, TREE_TYPE (t), flags);
919 else if (DECL_NAME (t))
920 dump_decl (DECL_NAME (t), flags);
921 else if (DECL_INITIAL (t))
922 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
924 pp_identifier (cxx_pp, "<enumerator>");
928 pp_string (cxx_pp, "using ");
929 dump_type (DECL_INITIAL (t), flags);
930 pp_colon_colon (cxx_pp);
931 dump_decl (DECL_NAME (t), flags);
935 dump_decl (BASELINK_FUNCTIONS (t), flags);
938 case NON_DEPENDENT_EXPR:
939 dump_expr (t, flags);
942 case TEMPLATE_TYPE_PARM:
943 if (flags & TFF_DECL_SPECIFIERS)
944 pp_cxx_declaration (cxx_pp, t);
946 pp_type_id (cxx_pp, t);
950 pp_unsupported_tree (cxx_pp, t);
951 /* Fallthrough to error. */
954 pp_identifier (cxx_pp, "<declaration error>");
959 /* Dump a template declaration T under control of FLAGS. This means the
960 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
963 dump_template_decl (tree t, int flags)
965 tree orig_parms = DECL_TEMPLATE_PARMS (t);
969 if (flags & TFF_TEMPLATE_HEADER)
971 for (parms = orig_parms = nreverse (orig_parms);
973 parms = TREE_CHAIN (parms))
975 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
976 int len = TREE_VEC_LENGTH (inner_parms);
978 pp_string (cxx_pp, "template<");
980 /* If we've shown the template prefix, we'd better show the
981 parameters' and decl's type too. */
982 flags |= TFF_DECL_SPECIFIERS;
984 for (i = 0; i < len; i++)
987 pp_separate_with_comma (cxx_pp);
988 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
990 pp_template_argument_list_end (cxx_pp);
993 nreverse(orig_parms);
995 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
996 /* Say `template<arg> class TT' not just `template<arg> TT'. */
997 pp_string (cxx_pp, "class ");
1000 if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
1001 dump_type (TREE_TYPE (t),
1002 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1003 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1004 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
1005 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1006 else if (TREE_TYPE (t) == NULL_TREE)
1009 switch (NEXT_CODE (t))
1013 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1016 /* This case can occur with some invalid code. */
1017 dump_type (TREE_TYPE (t),
1018 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1019 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0));
1023 /* Pretty print a function decl. There are several ways we want to print a
1024 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1025 As error can only apply the '#' flag once to give 0 and 1 for V, there
1026 is %D which doesn't print the throw specs, and %F which does. */
1029 dump_function_decl (tree t, int flags)
1033 tree cname = NULL_TREE;
1034 tree template_args = NULL_TREE;
1035 tree template_parms = NULL_TREE;
1036 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1038 if (TREE_CODE (t) == TEMPLATE_DECL)
1039 t = DECL_TEMPLATE_RESULT (t);
1041 /* Pretty print template instantiations only. */
1042 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t))
1046 template_args = DECL_TI_ARGS (t);
1047 tmpl = most_general_template (t);
1048 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1050 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1055 fntype = TREE_TYPE (t);
1056 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1058 if (DECL_CLASS_SCOPE_P (t))
1059 cname = DECL_CONTEXT (t);
1060 /* This is for partially instantiated template methods. */
1061 else if (TREE_CODE (fntype) == METHOD_TYPE)
1062 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1064 if (!(flags & TFF_DECL_SPECIFIERS))
1066 else if (DECL_STATIC_FUNCTION_P (t))
1067 pp_identifier (cxx_pp, "static ");
1068 else if (DECL_VIRTUAL_P (t))
1069 pp_identifier (cxx_pp, "virtual ");
1071 /* Print the return type? */
1073 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1074 && !DECL_DESTRUCTOR_P (t);
1077 dump_type_prefix (TREE_TYPE (fntype), flags);
1081 /* Print the function name. */
1084 dump_type (cname, flags);
1085 pp_colon_colon (cxx_pp);
1088 dump_scope (CP_DECL_CONTEXT (t), flags);
1090 dump_function_name (t, flags);
1092 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1094 dump_parameters (parmtypes, flags);
1096 if (TREE_CODE (fntype) == METHOD_TYPE)
1097 dump_qualifiers (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))),
1100 if (flags & TFF_EXCEPTION_SPECIFICATION)
1101 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
1104 dump_type_suffix (TREE_TYPE (fntype), flags);
1107 /* If T is a template instantiation, dump the parameter binding. */
1108 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1110 pp_string (cxx_pp, " [with ");
1111 dump_template_bindings (template_parms, template_args);
1112 pp_right_bracket (cxx_pp);
1116 /* Print a parameter list. If this is for a member function, the
1117 member object ptr (and any other hidden args) should have
1118 already been removed. */
1121 dump_parameters (tree parmtypes, int flags)
1125 pp_left_paren (cxx_pp);
1127 for (first = 1; parmtypes != void_list_node;
1128 parmtypes = TREE_CHAIN (parmtypes))
1131 pp_separate_with_comma (cxx_pp);
1135 pp_identifier (cxx_pp, "...");
1138 dump_type (TREE_VALUE (parmtypes), flags);
1140 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1142 pp_string (cxx_pp, " = ");
1143 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1147 pp_right_paren (cxx_pp);
1150 /* Print an exception specification. T is the exception specification. */
1153 dump_exception_spec (tree t, int flags)
1157 pp_string (cxx_pp, " throw (");
1158 if (TREE_VALUE (t) != NULL_TREE)
1161 dump_type (TREE_VALUE (t), flags);
1165 pp_separate_with_comma (cxx_pp);
1167 pp_right_paren (cxx_pp);
1171 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1172 and destructors properly. */
1175 dump_function_name (tree t, int flags)
1177 tree name = DECL_NAME (t);
1179 if (TREE_CODE (t) == TEMPLATE_DECL)
1180 t = DECL_TEMPLATE_RESULT (t);
1182 /* Don't let the user see __comp_ctor et al. */
1183 if (DECL_CONSTRUCTOR_P (t)
1184 || DECL_DESTRUCTOR_P (t))
1185 name = constructor_name (DECL_CONTEXT (t));
1187 if (DECL_DESTRUCTOR_P (t))
1189 pp_complement (cxx_pp);
1190 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1192 else if (DECL_CONV_FN_P (t))
1194 /* This cannot use the hack that the operator's return
1195 type is stashed off of its name because it may be
1196 used for error reporting. In the case of conflicting
1197 declarations, both will have the same name, yet
1198 the types will be different, hence the TREE_TYPE field
1199 of the first name will be clobbered by the second. */
1200 pp_string (cxx_pp, "operator ");
1201 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1203 else if (IDENTIFIER_OPNAME_P (name))
1204 pp_tree_identifier (cxx_pp, name);
1206 dump_decl (name, flags);
1208 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
1209 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1210 && (DECL_TEMPLATE_SPECIALIZATION (t)
1211 || TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1212 || DECL_TEMPLATE_SPECIALIZATION (DECL_TI_TEMPLATE (t))
1213 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1214 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1217 /* Dump the template parameters from the template info INFO under control of
1218 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1219 specialization (partial or complete). For partial specializations we show
1220 the specialized parameter values. For a primary template we show no
1224 dump_template_parms (tree info, int primary, int flags)
1226 tree args = info ? TI_ARGS (info) : NULL_TREE;
1228 if (primary && flags & TFF_TEMPLATE_NAME)
1230 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1231 pp_template_argument_list_start (cxx_pp);
1233 /* Be careful only to print things when we have them, so as not
1234 to crash producing error messages. */
1235 if (args && !primary)
1239 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
1240 args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
1242 len = TREE_VEC_LENGTH (args);
1244 for (ix = 0; ix != len; ix++)
1246 tree arg = TREE_VEC_ELT (args, ix);
1249 pp_separate_with_comma (cxx_pp);
1252 pp_identifier (cxx_pp, "<template parameter error>");
1254 dump_template_argument (arg, flags);
1259 tree tpl = TI_TEMPLATE (info);
1260 tree parms = DECL_TEMPLATE_PARMS (tpl);
1263 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1264 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1266 for (ix = 0; ix != len; ix++)
1268 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1271 pp_separate_with_comma (cxx_pp);
1273 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1276 pp_template_argument_list_end (cxx_pp);
1279 /* Print out a list of initializers (subr of dump_expr). */
1282 dump_expr_list (tree l, int flags)
1286 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1289 pp_separate_with_comma (cxx_pp);
1293 /* Print out an expression E under control of FLAGS. */
1296 dump_expr (tree t, int flags)
1301 switch (TREE_CODE (t))
1309 case NAMESPACE_DECL:
1312 case IDENTIFIER_NODE:
1313 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1319 pp_c_constant (pp_c_base (cxx_pp), t);
1323 pp_identifier (cxx_pp, "throw");
1324 dump_expr (TREE_OPERAND (t, 0), flags);
1328 pp_ampersand (cxx_pp);
1329 dump_type (PTRMEM_CST_CLASS (t), flags);
1330 pp_colon_colon (cxx_pp);
1331 pp_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1335 pp_left_paren (cxx_pp);
1336 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1337 pp_separate_with_comma (cxx_pp);
1338 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1339 pp_right_paren (cxx_pp);
1343 pp_left_paren (cxx_pp);
1344 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1345 pp_string (cxx_pp, " ? ");
1346 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1347 pp_string (cxx_pp, " : ");
1348 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1349 pp_right_paren (cxx_pp);
1353 if (TREE_HAS_CONSTRUCTOR (t))
1355 pp_string (cxx_pp, "new ");
1356 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1359 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1362 case AGGR_INIT_EXPR:
1364 tree fn = NULL_TREE;
1366 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
1367 fn = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
1369 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1371 if (DECL_CONSTRUCTOR_P (fn))
1372 pp_tree_identifier (cxx_pp, TYPE_IDENTIFIER (TREE_TYPE (t)));
1377 dump_expr (TREE_OPERAND (t, 0), 0);
1379 pp_left_paren (cxx_pp);
1380 if (TREE_OPERAND (t, 1))
1381 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1382 pp_right_paren (cxx_pp);
1387 tree fn = TREE_OPERAND (t, 0);
1388 tree args = TREE_OPERAND (t, 1);
1390 if (TREE_CODE (fn) == ADDR_EXPR)
1391 fn = TREE_OPERAND (fn, 0);
1393 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1395 tree ob = TREE_VALUE (args);
1396 if (TREE_CODE (ob) == ADDR_EXPR)
1398 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1401 else if (TREE_CODE (ob) != PARM_DECL
1402 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1404 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1407 args = TREE_CHAIN (args);
1409 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1410 pp_left_paren (cxx_pp);
1411 dump_expr_list (args, flags);
1412 pp_right_paren (cxx_pp);
1418 tree type = TREE_OPERAND (t, 1);
1419 tree init = TREE_OPERAND (t, 2);
1420 if (NEW_EXPR_USE_GLOBAL (t))
1421 pp_colon_colon (cxx_pp);
1422 pp_string (cxx_pp, "new ");
1423 if (TREE_OPERAND (t, 0))
1425 pp_left_paren (cxx_pp);
1426 dump_expr_list (TREE_OPERAND (t, 0), flags);
1427 pp_string (cxx_pp, ") ");
1429 if (TREE_CODE (type) == ARRAY_REF)
1430 type = build_cplus_array_type
1431 (TREE_OPERAND (type, 0),
1432 build_index_type (fold (build (MINUS_EXPR, integer_type_node,
1433 TREE_OPERAND (type, 1),
1434 integer_one_node))));
1435 dump_type (type, flags);
1438 pp_left_paren (cxx_pp);
1439 if (TREE_CODE (init) == TREE_LIST)
1440 dump_expr_list (init, flags);
1441 else if (init == void_zero_node)
1442 /* This representation indicates an empty initializer,
1443 e.g.: "new int()". */
1446 dump_expr (init, flags);
1447 pp_right_paren (cxx_pp);
1453 /* Note that this only works for G++ target exprs. If somebody
1454 builds a general TARGET_EXPR, there's no way to represent that
1455 it initializes anything other that the parameter slot for the
1456 default argument. Note we may have cleared out the first
1457 operand in expand_expr, so don't go killing ourselves. */
1458 if (TREE_OPERAND (t, 1))
1459 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1467 case TRUNC_DIV_EXPR:
1468 case TRUNC_MOD_EXPR:
1476 case TRUTH_ANDIF_EXPR:
1477 case TRUTH_ORIF_EXPR:
1484 case EXACT_DIV_EXPR:
1485 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1489 case FLOOR_DIV_EXPR:
1490 case ROUND_DIV_EXPR:
1492 dump_binary_op ("/", t, flags);
1496 case FLOOR_MOD_EXPR:
1497 case ROUND_MOD_EXPR:
1498 dump_binary_op ("%", t, flags);
1503 tree ob = TREE_OPERAND (t, 0);
1504 if (TREE_CODE (ob) == INDIRECT_REF)
1506 ob = TREE_OPERAND (ob, 0);
1507 if (TREE_CODE (ob) != PARM_DECL
1508 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1510 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1516 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1519 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1524 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1525 pp_left_bracket (cxx_pp);
1526 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1527 pp_right_bracket (cxx_pp);
1531 if (TREE_TYPE (t) && VOID_TYPE_P (TREE_TYPE (t)))
1533 pp_left_paren (cxx_pp);
1534 dump_type (TREE_TYPE (t), flags);
1535 pp_right_paren (cxx_pp);
1536 dump_expr (TREE_OPERAND (t, 0), flags);
1539 dump_unary_op ("+", t, flags);
1543 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1544 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1545 /* An ADDR_EXPR can have reference type. In that case, we
1546 shouldn't print the `&' doing so indicates to the user
1547 that the expression has pointer type. */
1549 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1550 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1551 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1552 dump_unary_op ("&&", t, flags);
1554 dump_unary_op ("&", t, flags);
1558 if (TREE_HAS_CONSTRUCTOR (t))
1560 t = TREE_OPERAND (t, 0);
1561 my_friendly_assert (TREE_CODE (t) == CALL_EXPR, 237);
1562 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1563 pp_left_paren (cxx_pp);
1564 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1565 pp_right_paren (cxx_pp);
1569 if (TREE_OPERAND (t,0) != NULL_TREE
1570 && TREE_TYPE (TREE_OPERAND (t, 0))
1571 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1572 dump_expr (TREE_OPERAND (t, 0), flags);
1574 dump_unary_op ("*", t, flags);
1580 case TRUTH_NOT_EXPR:
1581 case PREDECREMENT_EXPR:
1582 case PREINCREMENT_EXPR:
1583 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1586 case POSTDECREMENT_EXPR:
1587 case POSTINCREMENT_EXPR:
1588 pp_left_paren (cxx_pp);
1589 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1590 pp_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1591 pp_right_paren (cxx_pp);
1594 case NON_LVALUE_EXPR:
1595 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1596 should be another level of INDIRECT_REF so that I don't have to do
1598 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1600 tree next = TREE_TYPE (TREE_TYPE (t));
1602 while (TREE_CODE (next) == POINTER_TYPE)
1603 next = TREE_TYPE (next);
1605 if (TREE_CODE (next) == FUNCTION_TYPE)
1607 if (flags & TFF_EXPR_IN_PARENS)
1608 pp_left_paren (cxx_pp);
1610 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1611 if (flags & TFF_EXPR_IN_PARENS)
1612 pp_right_paren (cxx_pp);
1615 /* Else fall through. */
1617 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1622 tree op = TREE_OPERAND (t, 0);
1624 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1626 /* It is a cast, but we cannot tell whether it is a
1627 reinterpret or static cast. Use the C style notation. */
1628 if (flags & TFF_EXPR_IN_PARENS)
1629 pp_left_paren (cxx_pp);
1630 pp_left_paren (cxx_pp);
1631 dump_type (TREE_TYPE (t), flags);
1632 pp_right_paren (cxx_pp);
1633 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1634 if (flags & TFF_EXPR_IN_PARENS)
1635 pp_right_paren (cxx_pp);
1638 dump_expr (op, flags);
1642 case EXPR_WITH_FILE_LOCATION:
1643 dump_expr (EXPR_WFL_NODE (t), flags);
1647 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1649 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1651 if (integer_zerop (idx))
1653 /* A NULL pointer-to-member constant. */
1654 pp_left_paren (cxx_pp);
1655 pp_left_paren (cxx_pp);
1656 dump_type (TREE_TYPE (t), flags);
1657 pp_right_paren (cxx_pp);
1658 pp_string (cxx_pp, ")0)");
1661 else if (host_integerp (idx, 0))
1664 unsigned HOST_WIDE_INT n;
1666 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1667 t = TYPE_METHOD_BASETYPE (t);
1668 virtuals = TYPE_BINFO_VIRTUALS (TYPE_MAIN_VARIANT (t));
1670 n = tree_low_cst (idx, 0);
1672 /* Map vtable index back one, to allow for the null pointer to
1676 while (n > 0 && virtuals)
1679 virtuals = TREE_CHAIN (virtuals);
1683 dump_expr (BV_FN (virtuals),
1684 flags | TFF_EXPR_IN_PARENS);
1689 if (TREE_TYPE (t) && !CONSTRUCTOR_ELTS (t))
1691 dump_type (TREE_TYPE (t), 0);
1692 pp_left_paren (cxx_pp);
1693 pp_right_paren (cxx_pp);
1697 pp_left_brace (cxx_pp);
1698 dump_expr_list (CONSTRUCTOR_ELTS (t), flags);
1699 pp_right_brace (cxx_pp);
1706 tree ob = TREE_OPERAND (t, 0);
1707 if (is_dummy_object (ob))
1709 t = TREE_OPERAND (t, 1);
1710 if (TREE_CODE (t) == FUNCTION_DECL)
1712 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1713 else if (BASELINK_P (t))
1714 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1715 flags | TFF_EXPR_IN_PARENS);
1717 dump_decl (t, flags);
1721 if (TREE_CODE (ob) == INDIRECT_REF)
1723 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1724 pp_string (cxx_pp, "->*");
1728 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1729 pp_string (cxx_pp, ".*");
1731 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1736 case TEMPLATE_PARM_INDEX:
1737 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1741 pp_expression (cxx_pp, t);
1745 if (TREE_OPERAND (t, 0) == NULL_TREE
1746 || TREE_CHAIN (TREE_OPERAND (t, 0)))
1748 dump_type (TREE_TYPE (t), flags);
1749 pp_left_paren (cxx_pp);
1750 dump_expr_list (TREE_OPERAND (t, 0), flags);
1751 pp_right_paren (cxx_pp);
1755 pp_left_paren (cxx_pp);
1756 dump_type (TREE_TYPE (t), flags);
1757 pp_string (cxx_pp, ")(");
1758 dump_expr_list (TREE_OPERAND (t, 0), flags);
1759 pp_right_paren (cxx_pp);
1763 case STATIC_CAST_EXPR:
1764 pp_string (cxx_pp, "static_cast<");
1766 case REINTERPRET_CAST_EXPR:
1767 pp_string (cxx_pp, "reinterpret_cast<");
1769 case CONST_CAST_EXPR:
1770 pp_string (cxx_pp, "const_cast<");
1772 case DYNAMIC_CAST_EXPR:
1773 pp_string (cxx_pp, "dynamic_cast<");
1775 dump_type (TREE_TYPE (t), flags);
1776 pp_string (cxx_pp, ">(");
1777 dump_expr (TREE_OPERAND (t, 0), flags);
1778 pp_right_paren (cxx_pp);
1782 dump_expr (TREE_OPERAND (t, 0), flags);
1788 if (TREE_CODE (t) == SIZEOF_EXPR)
1789 pp_string (cxx_pp, "sizeof (");
1792 my_friendly_assert (TREE_CODE (t) == ALIGNOF_EXPR, 0);
1793 pp_string (cxx_pp, "__alignof__ (");
1795 if (TYPE_P (TREE_OPERAND (t, 0)))
1796 dump_type (TREE_OPERAND (t, 0), flags);
1798 dump_expr (TREE_OPERAND (t, 0), flags);
1799 pp_right_paren (cxx_pp);
1804 pp_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
1806 dump_expr (TREE_OPERAND (t, 0), flags);
1810 pp_identifier (cxx_pp, "<unparsed>");
1813 case TRY_CATCH_EXPR:
1814 case WITH_CLEANUP_EXPR:
1815 case CLEANUP_POINT_EXPR:
1816 dump_expr (TREE_OPERAND (t, 0), flags);
1819 case PSEUDO_DTOR_EXPR:
1820 dump_expr (TREE_OPERAND (t, 2), flags);
1822 dump_type (TREE_OPERAND (t, 0), flags);
1823 pp_colon_colon (cxx_pp);
1824 pp_complement (cxx_pp);
1825 dump_type (TREE_OPERAND (t, 1), flags);
1828 case TEMPLATE_ID_EXPR:
1829 dump_decl (t, flags);
1833 /* We don't yet have a way of dumping statements in a
1834 human-readable format. */
1835 pp_string (cxx_pp, "({...})");
1839 pp_left_brace (cxx_pp);
1840 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1841 pp_right_brace (cxx_pp);
1845 pp_string (cxx_pp, "while (1) { ");
1846 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1847 pp_right_brace (cxx_pp);
1851 pp_string (cxx_pp, "if (");
1852 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1853 pp_string (cxx_pp, ") break; ");
1857 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
1860 case EMPTY_CLASS_EXPR:
1861 dump_type (TREE_TYPE (t), flags);
1862 pp_left_paren (cxx_pp);
1863 pp_right_paren (cxx_pp);
1866 case NON_DEPENDENT_EXPR:
1867 dump_expr (TREE_OPERAND (t, 0), flags);
1870 /* This list is incomplete, but should suffice for now.
1871 It is very important that `sorry' does not call
1872 `report_error_function'. That could cause an infinite loop. */
1874 pp_unsupported_tree (cxx_pp, t);
1875 /* fall through to ERROR_MARK... */
1877 pp_identifier (cxx_pp, "<expression error>");
1883 dump_binary_op (const char *opstring, tree t, int flags)
1885 pp_left_paren (cxx_pp);
1886 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1889 pp_identifier (cxx_pp, opstring);
1891 pp_identifier (cxx_pp, "<unknown operator>");
1893 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1894 pp_right_paren (cxx_pp);
1898 dump_unary_op (const char *opstring, tree t, int flags)
1900 if (flags & TFF_EXPR_IN_PARENS)
1901 pp_left_paren (cxx_pp);
1902 pp_identifier (cxx_pp, opstring);
1903 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1904 if (flags & TFF_EXPR_IN_PARENS)
1905 pp_right_paren (cxx_pp);
1908 /* Exported interface to stringifying types, exprs and decls under TFF_*
1912 type_as_string (tree typ, int flags)
1914 pp_clear_output_area (cxx_pp);
1915 dump_type (typ, flags);
1916 return pp_formatted_text (cxx_pp);
1920 expr_as_string (tree decl, int flags)
1922 pp_clear_output_area (cxx_pp);
1923 dump_expr (decl, flags);
1924 return pp_formatted_text (cxx_pp);
1928 decl_as_string (tree decl, int flags)
1930 pp_clear_output_area (cxx_pp);
1931 dump_decl (decl, flags);
1932 return pp_formatted_text (cxx_pp);
1936 context_as_string (tree context, int flags)
1938 pp_clear_output_area (cxx_pp);
1939 dump_scope (context, flags);
1940 return pp_formatted_text (cxx_pp);
1943 /* Generate the three forms of printable names for cxx_printable_name. */
1946 lang_decl_name (tree decl, int v)
1949 return decl_as_string (decl, TFF_DECL_SPECIFIERS);
1951 pp_clear_output_area (cxx_pp);
1952 if (v == 1 && DECL_CLASS_SCOPE_P (decl))
1954 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
1955 pp_colon_colon (cxx_pp);
1958 if (TREE_CODE (decl) == FUNCTION_DECL)
1959 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
1961 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
1963 return pp_formatted_text (cxx_pp);
1967 location_of (tree t)
1969 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
1970 t = DECL_CONTEXT (t);
1971 else if (TYPE_P (t))
1972 t = TYPE_MAIN_DECL (t);
1973 else if (TREE_CODE (t) == OVERLOAD)
1974 t = OVL_FUNCTION (t);
1976 return DECL_SOURCE_LOCATION (t);
1979 /* Now the interfaces from error et al to dump_type et al. Each takes an
1980 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
1984 decl_to_string (tree decl, int verbose)
1988 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
1989 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
1990 flags = TFF_CLASS_KEY_OR_ENUM;
1992 flags |= TFF_DECL_SPECIFIERS;
1993 else if (TREE_CODE (decl) == FUNCTION_DECL)
1994 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
1995 flags |= TFF_TEMPLATE_HEADER;
1997 pp_clear_output_area (cxx_pp);
1998 dump_decl (decl, flags);
1999 return pp_formatted_text (cxx_pp);
2003 expr_to_string (tree decl)
2005 pp_clear_output_area (cxx_pp);
2006 dump_expr (decl, 0);
2007 return pp_formatted_text (cxx_pp);
2011 fndecl_to_string (tree fndecl, int verbose)
2015 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS;
2017 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2018 pp_clear_output_area (cxx_pp);
2019 dump_decl (fndecl, flags);
2020 return pp_formatted_text (cxx_pp);
2025 code_to_string (enum tree_code c)
2027 return tree_code_name [c];
2031 language_to_string (enum languages c)
2038 case lang_cplusplus:
2050 /* Return the proper printed version of a parameter to a C++ function. */
2053 parm_to_string (int p)
2055 pp_clear_output_area (cxx_pp);
2057 pp_string (cxx_pp, "'this'");
2059 pp_decimal_int (cxx_pp, p + 1);
2060 return pp_formatted_text (cxx_pp);
2064 op_to_string (enum tree_code p)
2066 tree id = operator_name_info[(int) p].identifier;
2067 return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2071 type_to_string (tree typ, int verbose)
2075 flags |= TFF_CLASS_KEY_OR_ENUM;
2076 flags |= TFF_TEMPLATE_HEADER;
2078 pp_clear_output_area (cxx_pp);
2079 dump_type (typ, flags);
2080 return pp_formatted_text (cxx_pp);
2084 assop_to_string (enum tree_code p)
2086 tree id = assignment_operator_name_info[(int) p].identifier;
2087 return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2091 args_to_string (tree p, int verbose)
2095 flags |= TFF_CLASS_KEY_OR_ENUM;
2100 if (TYPE_P (TREE_VALUE (p)))
2101 return type_as_string (p, flags);
2103 pp_clear_output_area (cxx_pp);
2104 for (; p; p = TREE_CHAIN (p))
2106 if (TREE_VALUE (p) == null_node)
2107 pp_identifier (cxx_pp, "NULL");
2109 dump_type (error_type (TREE_VALUE (p)), flags);
2111 pp_separate_with_comma (cxx_pp);
2113 return pp_formatted_text (cxx_pp);
2117 cv_to_string (tree p, int v)
2119 pp_clear_output_area (cxx_pp);
2120 dump_qualifiers (p, v ? before : none);
2121 return pp_formatted_text (cxx_pp);
2124 /* Langhook for print_error_function. */
2126 cxx_print_error_function (diagnostic_context *context, const char *file)
2128 lhd_print_error_function (context, file);
2129 pp_base_set_prefix (context->printer, file);
2130 maybe_print_instantiation_context (context);
2134 cp_diagnostic_starter (diagnostic_context *context,
2135 diagnostic_info *diagnostic)
2137 diagnostic_report_current_module (context);
2138 cp_print_error_function (context, diagnostic);
2139 maybe_print_instantiation_context (context);
2140 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2144 cp_diagnostic_finalizer (diagnostic_context *context,
2145 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2147 pp_base_destroy_prefix (context->printer);
2150 /* Print current function onto BUFFER, in the process of reporting
2151 a diagnostic message. Called from cp_diagnostic_starter. */
2153 cp_print_error_function (diagnostic_context *context,
2154 diagnostic_info *diagnostic)
2156 if (diagnostic_last_function_changed (context))
2158 const char *old_prefix = context->printer->prefix;
2159 char *new_prefix = diagnostic->location.file
2160 ? file_name_as_prefix (diagnostic->location.file)
2163 pp_base_set_prefix (context->printer, new_prefix);
2165 if (current_function_decl == NULL)
2166 pp_base_string (context->printer, "At global scope:");
2168 pp_printf (context->printer, "In %s `%s':",
2169 function_category (current_function_decl),
2170 cxx_printable_name (current_function_decl, 2));
2171 pp_base_newline (context->printer);
2173 diagnostic_set_last_function (context);
2174 pp_base_destroy_prefix (context->printer);
2175 context->printer->prefix = old_prefix;
2179 /* Returns a description of FUNCTION using standard terminology. */
2181 function_category (tree fn)
2183 if (DECL_FUNCTION_MEMBER_P (fn))
2185 if (DECL_STATIC_FUNCTION_P (fn))
2186 return "static member function";
2187 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2188 return "copy constructor";
2189 else if (DECL_CONSTRUCTOR_P (fn))
2190 return "constructor";
2191 else if (DECL_DESTRUCTOR_P (fn))
2192 return "destructor";
2194 return "member function";
2200 /* Report the full context of a current template instantiation,
2203 print_instantiation_full_context (diagnostic_context *context)
2205 tree p = current_instantiation ();
2206 location_t location = input_location;
2210 if (current_function_decl != TINST_DECL (p)
2211 && current_function_decl != NULL_TREE)
2212 /* We can get here during the processing of some synthesized
2213 method. Then, TINST_DECL (p) will be the function that's causing
2218 if (current_function_decl == TINST_DECL (p))
2219 /* Avoid redundancy with the the "In function" line. */;
2221 pp_verbatim (context->printer,
2222 "%s: In instantiation of `%s':\n", location.file,
2223 decl_as_string (TINST_DECL (p),
2224 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2226 location.line = TINST_LINE (p);
2227 location.file = TINST_FILE (p);
2232 print_instantiation_partial_context (context, p, location);
2235 /* Same as above but less verbose. */
2237 print_instantiation_partial_context (diagnostic_context *context,
2238 tree t, location_t loc)
2240 for (; t; t = TREE_CHAIN (t))
2242 pp_verbatim (context->printer, "%s:%d: instantiated from `%s'\n",
2244 decl_as_string (TINST_DECL (t),
2245 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2246 loc.line = TINST_LINE (t);
2247 loc.file = TINST_FILE (t);
2249 pp_verbatim (context->printer, "%s:%d: instantiated from here\n",
2250 loc.file, loc.line);
2253 /* Called from cp_thing to print the template context for an error. */
2255 maybe_print_instantiation_context (diagnostic_context *context)
2257 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2260 record_last_problematic_instantiation ();
2261 print_instantiation_full_context (context);
2264 /* Report the bare minimum context of a template instantiation. */
2266 print_instantiation_context (void)
2268 print_instantiation_partial_context
2269 (global_dc, current_instantiation (), input_location);
2270 diagnostic_flush_buffer (global_dc);
2273 /* Called from output_format -- during diagnostic message processing --
2274 to handle C++ specific format specifier with the following meanings:
2275 %A function argument-list.
2279 %F function declaration.
2280 %L language as used in extern "lang".
2282 %P function parameter whose position is indicated by an integer.
2283 %Q assignment operator.
2287 cp_printer (pretty_printer *pp, text_info *text)
2291 #define next_tree va_arg (*text->args_ptr, tree)
2292 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2293 #define next_lang va_arg (*text->args_ptr, enum languages)
2294 #define next_int va_arg (*text->args_ptr, int)
2296 if (*text->format_spec == '+')
2297 ++text->format_spec;
2298 if (*text->format_spec == '#')
2301 ++text->format_spec;
2304 switch (*text->format_spec)
2306 case 'A': result = args_to_string (next_tree, verbose); break;
2307 case 'C': result = code_to_string (next_tcode); break;
2308 case 'D': result = decl_to_string (next_tree, verbose); break;
2309 case 'E': result = expr_to_string (next_tree); break;
2310 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2311 case 'L': result = language_to_string (next_lang); break;
2312 case 'O': result = op_to_string (next_tcode); break;
2313 case 'P': result = parm_to_string (next_int); break;
2314 case 'Q': result = assop_to_string (next_tcode); break;
2315 case 'T': result = type_to_string (next_tree, verbose); break;
2316 case 'V': result = cv_to_string (next_tree, verbose); break;
2322 pp_base_string (pp, result);
2331 pp_non_consecutive_character (cxx_pretty_printer *pp, int c)
2333 const char *p = pp_last_position_in_text (pp);
2335 if (p != NULL && *p == c)
2337 pp_character (pp, c);
2340 /* These are temporary wrapper functions which handle the historic
2341 behavior of cp_*_at. */
2344 locate_error (const char *msgid, va_list ap)
2350 for (f = msgid; *f; f++)
2363 /* Just ignore these possibilities. */
2366 case 'd': (void) va_arg (ap, int); break;
2367 case 's': (void) va_arg (ap, char *); break;
2368 case 'L': (void) va_arg (ap, enum languages); break;
2371 case 'Q': (void) va_arg (ap, enum tree_code); break;
2373 /* These take a tree, which may be where the error is
2381 t = va_arg (ap, tree);
2387 errorcount = 0; /* damn ICE suppression */
2388 internal_error ("unexpected letter `%c' in locate_error\n", *f);
2394 here = va_arg (ap, tree);
2401 cp_error_at (const char *msgid, ...)
2404 diagnostic_info diagnostic;
2407 va_start (ap, msgid);
2408 here = locate_error (msgid, ap);
2411 va_start (ap, msgid);
2412 diagnostic_set_info (&diagnostic, msgid, &ap,
2413 input_location, DK_ERROR);
2414 cp_diagnostic_starter (global_dc, &diagnostic);
2415 diagnostic_set_info (&diagnostic, msgid, &ap,
2416 location_of (here), DK_ERROR);
2417 report_diagnostic (&diagnostic);
2422 cp_warning_at (const char *msgid, ...)
2425 diagnostic_info diagnostic;
2428 va_start (ap, msgid);
2429 here = locate_error (msgid, ap);
2432 va_start (ap, msgid);
2433 diagnostic_set_info (&diagnostic, msgid, &ap,
2434 location_of (here), DK_WARNING);
2435 report_diagnostic (&diagnostic);
2440 cp_pedwarn_at (const char *msgid, ...)
2443 diagnostic_info diagnostic;
2446 va_start (ap, msgid);
2447 here = locate_error (msgid, ap);
2450 va_start (ap, msgid);
2451 diagnostic_set_info (&diagnostic, msgid, &ap,
2452 location_of (here), pedantic_error_kind());
2453 report_diagnostic (&diagnostic);