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"
34 enum pad { none, before, after };
36 #define sorry_for_unsupported_tree(T) \
37 sorry ("`%s' not supported by %s", tree_code_name[(int) TREE_CODE (T)], \
40 #define print_scope_operator(BUFFER) output_add_string ((BUFFER), "::")
41 #define print_left_paren(BUFFER) output_add_character ((BUFFER), '(')
42 #define print_right_paren(BUFFER) output_add_character ((BUFFER), ')')
43 #define print_left_bracket(BUFFER) output_add_character ((BUFFER), '[')
44 #define print_right_bracket(BUFFER) output_add_character ((BUFFER), ']')
45 #define print_template_argument_list_start(BUFFER) \
46 print_non_consecutive_character ((BUFFER), '<')
47 #define print_template_argument_list_end(BUFFER) \
48 print_non_consecutive_character ((BUFFER), '>')
49 #define print_tree_identifier(BUFFER, TID) \
50 output_add_string ((BUFFER), IDENTIFIER_POINTER (TID))
51 #define print_identifier(BUFFER, ID) output_add_string ((BUFFER), (ID))
52 #define separate_with_comma(BUFFER) output_add_string ((BUFFER), ", ")
54 /* The global buffer where we dump everything. It is there only for
55 transitional purpose. It is expected, in the near future, to be
56 completely removed. */
57 static output_buffer scratch_buffer_rec;
58 static output_buffer *scratch_buffer = &scratch_buffer_rec;
60 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
62 #define reinit_global_formatting_buffer() \
63 output_clear_message_text (scratch_buffer)
65 static const char *args_to_string (tree, int);
66 static const char *assop_to_string (enum tree_code, int);
67 static const char *code_to_string (enum tree_code, int);
68 static const char *cv_to_string (tree, int);
69 static const char *decl_to_string (tree, int);
70 static const char *expr_to_string (tree, int);
71 static const char *fndecl_to_string (tree, int);
72 static const char *op_to_string (enum tree_code, int);
73 static const char *parm_to_string (int, int);
74 static const char *type_to_string (tree, int);
76 static void dump_type (tree, int);
77 static void dump_typename (tree, int);
78 static void dump_simple_decl (tree, tree, int);
79 static void dump_decl (tree, int);
80 static void dump_template_decl (tree, int);
81 static void dump_function_decl (tree, int);
82 static void dump_expr (tree, int);
83 static void dump_unary_op (const char *, tree, int);
84 static void dump_binary_op (const char *, tree, int);
85 static void dump_aggr_type (tree, int);
86 static enum pad dump_type_prefix (tree, int);
87 static void dump_type_suffix (tree, int);
88 static void dump_function_name (tree, int);
89 static void dump_expr_list (tree, int);
90 static void dump_global_iord (tree);
91 static enum pad dump_qualifiers (tree, enum pad);
92 static void dump_char (int);
93 static void dump_parameters (tree, int);
94 static void dump_exception_spec (tree, int);
95 static const char *class_key_or_enum (tree);
96 static void dump_template_argument (tree, int);
97 static void dump_template_argument_list (tree, int);
98 static void dump_template_parameter (tree, int);
99 static void dump_template_bindings (tree, tree);
100 static void dump_scope (tree, int);
101 static void dump_template_parms (tree, int, int);
103 static const char *function_category (tree);
104 static void maybe_print_instantiation_context (diagnostic_context *);
105 static void print_instantiation_full_context (diagnostic_context *);
106 static void print_instantiation_partial_context (diagnostic_context *,
107 tree, const char *, int);
108 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
109 static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
110 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
112 static bool cp_printer (output_buffer *, text_info *);
113 static void print_non_consecutive_character (output_buffer *, int);
114 static void print_integer (output_buffer *, HOST_WIDE_INT);
115 static tree locate_error (const char *, va_list);
120 diagnostic_starter (global_dc) = cp_diagnostic_starter;
121 diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer;
122 diagnostic_format_decoder (global_dc) = cp_printer;
124 init_output_buffer (scratch_buffer, /* prefix */NULL, /* line-width */0);
127 /* Dump a scope, if deemed necessary. */
130 dump_scope (tree scope, int flags)
132 int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF));
134 if (scope == NULL_TREE)
137 if (TREE_CODE (scope) == NAMESPACE_DECL)
139 if (scope != global_namespace)
141 dump_decl (scope, f);
142 print_scope_operator (scratch_buffer);
145 else if (AGGREGATE_TYPE_P (scope))
147 dump_type (scope, f);
148 print_scope_operator (scratch_buffer);
150 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
152 dump_function_decl (scope, f);
153 print_scope_operator (scratch_buffer);
157 /* Dump type qualifiers, providing padding as requested. Return an
158 indication of whether we dumped something. */
161 dump_qualifiers (tree t, enum pad p)
163 static const int masks[] =
164 {TYPE_QUAL_CONST, TYPE_QUAL_VOLATILE, TYPE_QUAL_RESTRICT};
165 static const char *const names[] =
166 {"const", "volatile", "__restrict"};
168 int quals = TYPE_QUALS (t);
169 int do_after = p == after;
173 for (ix = 0; ix != 3; ix++)
174 if (masks[ix] & quals)
177 output_add_space (scratch_buffer);
179 print_identifier (scratch_buffer, names[ix]);
182 output_add_space (scratch_buffer);
189 /* This must be large enough to hold any printed integer or floating-point
191 static char digit_buffer[128];
193 /* Dump the template ARGument under control of FLAGS. */
196 dump_template_argument (tree arg, int flags)
198 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
199 dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
201 dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
204 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
208 dump_template_argument_list (tree args, int flags)
210 int n = TREE_VEC_LENGTH (args);
214 for (i = 0; i< n; ++i)
217 separate_with_comma (scratch_buffer);
218 dump_template_argument (TREE_VEC_ELT (args, i), flags);
223 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
226 dump_template_parameter (tree parm, int flags)
228 tree p = TREE_VALUE (parm);
229 tree a = TREE_PURPOSE (parm);
231 if (TREE_CODE (p) == TYPE_DECL)
233 if (flags & TFF_DECL_SPECIFIERS)
235 print_identifier (scratch_buffer, "class");
238 output_add_space (scratch_buffer);
239 print_tree_identifier (scratch_buffer, DECL_NAME (p));
242 else if (DECL_NAME (p))
243 print_tree_identifier (scratch_buffer, DECL_NAME (p));
245 print_identifier (scratch_buffer, "{template default argument error}");
248 dump_decl (p, flags | TFF_DECL_SPECIFIERS);
250 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
252 output_add_string (scratch_buffer, " = ");
253 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
254 dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
256 dump_expr (a, flags | TFF_EXPR_IN_PARENS);
260 /* Dump, under control of FLAGS, a template-parameter-list binding.
261 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
265 dump_template_bindings (tree parms, tree args)
271 tree p = TREE_VALUE (parms);
272 int lvl = TMPL_PARMS_DEPTH (parms);
276 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
278 tree arg = NULL_TREE;
280 /* Don't crash if we had an invalid argument list. */
281 if (TMPL_ARGS_DEPTH (args) >= lvl)
283 tree lvl_args = TMPL_ARGS_LEVEL (args, lvl);
284 if (NUM_TMPL_ARGS (lvl_args) > arg_idx)
285 arg = TREE_VEC_ELT (lvl_args, arg_idx);
289 separate_with_comma (scratch_buffer);
290 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
291 output_add_string (scratch_buffer, " = ");
293 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
295 print_identifier (scratch_buffer, "<missing>");
301 parms = TREE_CHAIN (parms);
305 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
309 dump_type (tree t, int flags)
314 if (TYPE_PTRMEMFUNC_P (t))
317 switch (TREE_CODE (t))
320 print_identifier (scratch_buffer, "<unknown type>");
324 /* A list of function parms. */
325 dump_parameters (t, flags);
328 case IDENTIFIER_NODE:
329 print_tree_identifier (scratch_buffer, t);
333 dump_type (BINFO_TYPE (t), flags);
339 dump_aggr_type (t, flags);
343 if (flags & TFF_CHASE_TYPEDEF)
345 dump_type (DECL_ORIGINAL_TYPE (t)
346 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
349 /* else fallthrough */
353 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
357 output_add_string (scratch_buffer, "__complex__ ");
358 dump_type (TREE_TYPE (t), flags);
362 output_add_string (scratch_buffer, "vector ");
364 /* The subtype of a VECTOR_TYPE is something like intQI_type_node,
365 which has no name and is not very useful for diagnostics. So
366 look up the equivalent C type and print its name. */
367 tree elt = TREE_TYPE (t);
368 elt = c_common_type_for_mode (TYPE_MODE (elt), TREE_UNSIGNED (elt));
369 dump_type (elt, flags);
374 if (!TREE_UNSIGNED (TYPE_MAIN_VARIANT (t)) && TREE_UNSIGNED (t))
375 output_add_string (scratch_buffer, "unsigned ");
376 else if (TREE_UNSIGNED (TYPE_MAIN_VARIANT (t)) && !TREE_UNSIGNED (t))
377 output_add_string (scratch_buffer, "signed ");
385 dump_qualifiers (t, after);
386 type = flags & TFF_CHASE_TYPEDEF ? TYPE_MAIN_VARIANT (t) : t;
387 if (TYPE_NAME (type) && TYPE_IDENTIFIER (type))
388 print_tree_identifier (scratch_buffer, TYPE_IDENTIFIER (type));
390 /* Types like intQI_type_node and friends have no names.
391 These don't come up in user error messages, but it's nice
392 to be able to print them from the debugger. */
393 print_identifier (scratch_buffer, "<anonymous>");
397 case TEMPLATE_TEMPLATE_PARM:
398 /* For parameters inside template signature. */
399 if (TYPE_IDENTIFIER (t))
400 print_tree_identifier (scratch_buffer, TYPE_IDENTIFIER (t));
403 (scratch_buffer, "<anonymous template template parameter>");
406 case BOUND_TEMPLATE_TEMPLATE_PARM:
408 tree args = TYPE_TI_ARGS (t);
409 print_tree_identifier (scratch_buffer, TYPE_IDENTIFIER (t));
410 print_template_argument_list_start (scratch_buffer);
411 dump_template_argument_list (args, flags);
412 print_template_argument_list_end (scratch_buffer);
416 case TEMPLATE_TYPE_PARM:
417 dump_qualifiers (t, after);
418 if (TYPE_IDENTIFIER (t))
419 print_tree_identifier (scratch_buffer, TYPE_IDENTIFIER (t));
422 (scratch_buffer, "<anonymous template type parameter>");
425 /* This is not always necessary for pointers and such, but doing this
426 reduces code size. */
435 dump_type_prefix (t, flags);
436 dump_type_suffix (t, flags);
440 dump_qualifiers (t, after);
441 output_add_string (scratch_buffer, "typename ");
442 dump_typename (t, flags);
445 case UNBOUND_CLASS_TEMPLATE:
446 dump_type (TYPE_CONTEXT (t), flags);
447 print_scope_operator (scratch_buffer);
448 print_identifier (scratch_buffer, "template ");
449 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
453 output_add_string (scratch_buffer, "__typeof (");
454 dump_expr (TYPE_FIELDS (t), flags & ~TFF_EXPR_IN_PARENS);
455 print_right_paren (scratch_buffer);
459 sorry_for_unsupported_tree (t);
460 /* Fall through to error. */
463 print_identifier (scratch_buffer, "<type error>");
468 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
472 dump_typename (tree t, int flags)
474 tree ctx = TYPE_CONTEXT (t);
476 if (TREE_CODE (ctx) == TYPENAME_TYPE)
477 dump_typename (ctx, flags);
479 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
480 print_scope_operator (scratch_buffer);
481 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
484 /* Return the name of the supplied aggregate, or enumeral type. */
487 class_key_or_enum (tree t)
489 if (TREE_CODE (t) == ENUMERAL_TYPE)
491 else if (TREE_CODE (t) == UNION_TYPE)
493 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
499 /* Print out a class declaration T under the control of FLAGS,
500 in the form `class foo'. */
503 dump_aggr_type (tree t, int flags)
506 const char *variety = class_key_or_enum (t);
510 dump_qualifiers (t, after);
512 if (flags & TFF_CLASS_KEY_OR_ENUM)
514 print_identifier (scratch_buffer, variety);
515 output_add_space (scratch_buffer);
518 if (flags & TFF_CHASE_TYPEDEF)
519 t = TYPE_MAIN_VARIANT (t);
521 name = TYPE_NAME (t);
525 typdef = !DECL_ARTIFICIAL (name);
526 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
527 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
528 && (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
529 || TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
530 || DECL_TEMPLATE_SPECIALIZATION (CLASSTYPE_TI_TEMPLATE (t))
531 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
532 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
535 /* Because the template names are mangled, we have to locate
536 the most general template, and use that name. */
537 tree tpl = CLASSTYPE_TI_TEMPLATE (t);
539 while (DECL_TEMPLATE_INFO (tpl))
540 tpl = DECL_TI_TEMPLATE (tpl);
543 name = DECL_NAME (name);
546 if (name == 0 || ANON_AGGRNAME_P (name))
548 if (flags & TFF_CLASS_KEY_OR_ENUM)
549 print_identifier (scratch_buffer, "<anonymous>");
551 output_printf (scratch_buffer, "<anonymous %s>", variety);
554 print_tree_identifier (scratch_buffer, name);
556 dump_template_parms (TYPE_TEMPLATE_INFO (t),
557 !CLASSTYPE_USE_TEMPLATE (t),
558 flags & ~TFF_TEMPLATE_HEADER);
561 /* Dump into the obstack the initial part of the output for a given type.
562 This is necessary when dealing with things like functions returning
565 return type of `int (* fee ())()': pointer -> function -> int. Both
566 pointer (and reference and offset) and function (and member) types must
567 deal with prefix and suffix.
569 Arrays must also do this for DECL nodes, like int a[], and for things like
572 Return indicates how you should pad an object name after this. I.e. you
573 want to pad non-*, non-& cores, but not pad * or & types. */
576 dump_type_prefix (tree t, int flags)
578 enum pad padding = before;
580 if (TYPE_PTRMEMFUNC_P (t))
582 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
586 switch (TREE_CODE (t))
591 tree sub = TREE_TYPE (t);
593 padding = dump_type_prefix (sub, flags);
594 /* A tree for a member pointer looks like pointer to offset,
595 so let the OFFSET_TYPE case handle it. */
596 if (!TYPE_PTRMEM_P (t))
598 if (TREE_CODE (sub) == ARRAY_TYPE)
600 output_add_space (scratch_buffer);
601 print_left_paren (scratch_buffer);
604 (scratch_buffer, "&*"[TREE_CODE (t) == POINTER_TYPE]);
605 padding = dump_qualifiers (t, before);
612 padding = dump_type_prefix (TREE_TYPE (t), flags);
613 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
616 output_add_space (scratch_buffer);
617 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
618 print_scope_operator (scratch_buffer);
620 output_add_character (scratch_buffer, '*');
621 padding = dump_qualifiers (t, none);
624 /* Can only be reached through function pointer -- this would not be
625 correct if FUNCTION_DECLs used it. */
627 padding = dump_type_prefix (TREE_TYPE (t), flags);
629 output_add_space (scratch_buffer);
630 print_left_paren (scratch_buffer);
635 padding = dump_type_prefix (TREE_TYPE (t), flags);
637 output_add_space (scratch_buffer);
638 print_left_paren (scratch_buffer);
640 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
641 print_scope_operator (scratch_buffer);
645 padding = dump_type_prefix (TREE_TYPE (t), flags);
649 case IDENTIFIER_NODE:
654 case TEMPLATE_TYPE_PARM:
655 case TEMPLATE_TEMPLATE_PARM:
656 case BOUND_TEMPLATE_TEMPLATE_PARM:
667 dump_type (t, flags);
672 sorry_for_unsupported_tree (t);
675 print_identifier (scratch_buffer, "<typeprefixerror>");
681 /* Dump the suffix of type T, under control of FLAGS. This is the part
682 which appears after the identifier (or function parms). */
685 dump_type_suffix (tree t, int flags)
687 if (TYPE_PTRMEMFUNC_P (t))
688 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
690 switch (TREE_CODE (t))
695 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
696 print_right_paren (scratch_buffer);
697 dump_type_suffix (TREE_TYPE (t), flags);
700 /* Can only be reached through function pointer */
705 print_right_paren (scratch_buffer);
706 arg = TYPE_ARG_TYPES (t);
707 if (TREE_CODE (t) == METHOD_TYPE)
708 arg = TREE_CHAIN (arg);
710 /* Function pointers don't have default args. Not in standard C++,
711 anyway; they may in g++, but we'll just pretend otherwise. */
712 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
714 if (TREE_CODE (t) == METHOD_TYPE)
716 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), before);
717 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
718 dump_type_suffix (TREE_TYPE (t), flags);
723 print_left_bracket (scratch_buffer);
726 if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0))
729 tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1);
730 else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR)
731 dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0),
732 flags & ~TFF_EXPR_IN_PARENS);
734 dump_expr (fold (cp_build_binary_op
735 (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)),
737 flags & ~TFF_EXPR_IN_PARENS);
739 print_right_bracket (scratch_buffer);
740 dump_type_suffix (TREE_TYPE (t), flags);
744 case IDENTIFIER_NODE:
749 case TEMPLATE_TYPE_PARM:
750 case TEMPLATE_TEMPLATE_PARM:
751 case BOUND_TEMPLATE_TEMPLATE_PARM:
765 sorry_for_unsupported_tree (t);
767 /* Don't mark it here, we should have already done in
774 dump_global_iord (tree t)
776 const char *p = NULL;
778 if (DECL_GLOBAL_CTOR_P (t))
780 else if (DECL_GLOBAL_DTOR_P (t))
785 output_printf (scratch_buffer, "(static %s for %s)", p, input_filename);
789 dump_simple_decl (tree t, tree type, int flags)
791 if (flags & TFF_DECL_SPECIFIERS)
793 if (dump_type_prefix (type, flags) != none)
794 output_add_space (scratch_buffer);
796 if (!DECL_INITIAL (t) || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX)
797 dump_scope (CP_DECL_CONTEXT (t), flags);
799 dump_decl (DECL_NAME (t), flags);
801 print_identifier (scratch_buffer, "<anonymous>");
802 if (flags & TFF_DECL_SPECIFIERS)
803 dump_type_suffix (type, flags);
806 /* Dump a human readable string for the decl T under control of FLAGS. */
809 dump_decl (tree t, int flags)
814 switch (TREE_CODE (t))
818 /* Don't say 'typedef class A' */
819 if (DECL_ARTIFICIAL (t))
821 if ((flags & TFF_DECL_SPECIFIERS)
822 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
823 /* Say `class T' not just `T'. */
824 output_add_string (scratch_buffer, "class ");
826 dump_type (TREE_TYPE (t), flags);
830 if (flags & TFF_DECL_SPECIFIERS)
831 output_add_string (scratch_buffer, "typedef ");
832 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
833 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
838 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
840 output_add_string (scratch_buffer, "vtable for ");
841 my_friendly_assert (TYPE_P (DECL_CONTEXT (t)), 20010720);
842 dump_type (DECL_CONTEXT (t), flags);
845 /* else fall through */
848 dump_simple_decl (t, TREE_TYPE (t), flags);
852 output_add_string (scratch_buffer, "<return value> ");
853 dump_simple_decl (t, TREE_TYPE (t), flags);
857 dump_scope (CP_DECL_CONTEXT (t), flags);
858 if (DECL_NAME (t) == anonymous_namespace_name)
859 print_identifier (scratch_buffer, "<unnamed>");
861 print_tree_identifier (scratch_buffer, DECL_NAME (t));
865 dump_decl (TREE_OPERAND (t, 0), flags & ~TFF_DECL_SPECIFIERS);
866 print_scope_operator (scratch_buffer);
867 dump_decl (TREE_OPERAND (t, 1), flags);
871 dump_decl (TREE_OPERAND (t, 0), flags);
872 print_left_bracket (scratch_buffer);
873 dump_decl (TREE_OPERAND (t, 1), flags);
874 print_right_bracket (scratch_buffer);
877 /* So that we can do dump_decl on an aggr type. */
881 dump_type (t, flags);
888 /* These special cases are duplicated here so that other functions
889 can feed identifiers to error and get them demangled properly. */
890 case IDENTIFIER_NODE:
891 if (IDENTIFIER_TYPENAME_P (t))
893 output_add_string (scratch_buffer, "operator ");
894 /* Not exactly IDENTIFIER_TYPE_VALUE. */
895 dump_type (TREE_TYPE (t), flags);
899 print_tree_identifier (scratch_buffer, t);
906 if (DECL_CLASS_SCOPE_P (t))
908 dump_type (DECL_CONTEXT (t), flags);
909 output_add_string (scratch_buffer, "::");
911 else if (DECL_CONTEXT (t))
913 dump_decl (DECL_CONTEXT (t), flags);
914 output_add_string (scratch_buffer, "::");
916 dump_decl (DECL_NAME (t), flags);
920 /* If there's only one function, just treat it like an ordinary
926 if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
927 dump_global_iord (t);
928 else if (! DECL_LANG_SPECIFIC (t))
929 print_identifier (scratch_buffer, "<internal>");
931 dump_function_decl (t, flags);
935 dump_template_decl (t, flags);
938 case TEMPLATE_ID_EXPR:
941 tree name = TREE_OPERAND (t, 0);
942 if (is_overloaded_fn (name))
943 name = DECL_NAME (get_first_fn (name));
944 dump_decl (name, flags);
945 print_template_argument_list_start (scratch_buffer);
946 for (args = TREE_OPERAND (t, 1); args; args = TREE_CHAIN (args))
948 dump_template_argument (TREE_VALUE (args), flags);
949 if (TREE_CHAIN (args))
950 separate_with_comma (scratch_buffer);
952 print_template_argument_list_end (scratch_buffer);
957 dump_decl (TREE_OPERAND (t, 0), flags);
961 print_tree_identifier (scratch_buffer, DECL_NAME (t));
965 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
966 || (DECL_INITIAL (t) &&
967 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
968 dump_simple_decl (t, TREE_TYPE (t), flags);
969 else if (DECL_NAME (t))
970 dump_decl (DECL_NAME (t), flags);
971 else if (DECL_INITIAL (t))
972 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
974 print_identifier (scratch_buffer, "<enumerator>");
978 output_add_string (scratch_buffer, "using ");
979 dump_type (DECL_INITIAL (t), flags);
980 print_scope_operator (scratch_buffer);
981 print_tree_identifier (scratch_buffer, DECL_NAME (t));
985 dump_decl (BASELINK_FUNCTIONS (t), flags);
989 sorry_for_unsupported_tree (t);
990 /* Fallthrough to error. */
993 print_identifier (scratch_buffer, "<declaration error>");
998 /* Dump a template declaration T under control of FLAGS. This means the
999 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1002 dump_template_decl (tree t, int flags)
1004 tree orig_parms = DECL_TEMPLATE_PARMS (t);
1008 if (flags & TFF_TEMPLATE_HEADER)
1010 for (parms = orig_parms = nreverse (orig_parms);
1012 parms = TREE_CHAIN (parms))
1014 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
1015 int len = TREE_VEC_LENGTH (inner_parms);
1017 output_add_string (scratch_buffer, "template<");
1019 /* If we've shown the template prefix, we'd better show the
1020 parameters' and decl's type too. */
1021 flags |= TFF_DECL_SPECIFIERS;
1023 for (i = 0; i < len; i++)
1026 separate_with_comma (scratch_buffer);
1027 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
1029 print_template_argument_list_end (scratch_buffer);
1030 output_add_space (scratch_buffer);
1032 nreverse(orig_parms);
1034 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1035 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1036 output_add_string (scratch_buffer, "class ");
1039 if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
1040 dump_type (TREE_TYPE (t),
1041 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1042 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1043 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
1044 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1045 else if (TREE_TYPE (t) == NULL_TREE)
1048 switch (NEXT_CODE (t))
1052 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1055 /* This case can occur with some invalid code. */
1056 dump_type (TREE_TYPE (t),
1057 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1058 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0));
1062 /* Pretty print a function decl. There are several ways we want to print a
1063 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1064 As error can only apply the '#' flag once to give 0 and 1 for V, there
1065 is %D which doesn't print the throw specs, and %F which does. */
1068 dump_function_decl (tree t, int flags)
1072 tree cname = NULL_TREE;
1073 tree template_args = NULL_TREE;
1074 tree template_parms = NULL_TREE;
1075 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1077 if (TREE_CODE (t) == TEMPLATE_DECL)
1078 t = DECL_TEMPLATE_RESULT (t);
1080 /* Pretty print template instantiations only. */
1081 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t))
1085 template_args = DECL_TI_ARGS (t);
1086 tmpl = most_general_template (t);
1087 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1089 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1094 fntype = TREE_TYPE (t);
1095 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1097 if (DECL_CLASS_SCOPE_P (t))
1098 cname = DECL_CONTEXT (t);
1099 /* this is for partially instantiated template methods */
1100 else if (TREE_CODE (fntype) == METHOD_TYPE)
1101 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1103 if (!(flags & TFF_DECL_SPECIFIERS))
1105 else if (DECL_STATIC_FUNCTION_P (t))
1106 print_identifier (scratch_buffer, "static ");
1107 else if (DECL_VIRTUAL_P (t))
1108 print_identifier (scratch_buffer, "virtual ");
1110 /* Print the return type? */
1112 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1113 && !DECL_DESTRUCTOR_P (t);
1116 dump_type_prefix (TREE_TYPE (fntype), flags);
1117 output_add_space (scratch_buffer);
1120 /* Print the function name. */
1123 dump_type (cname, flags);
1124 print_scope_operator (scratch_buffer);
1127 dump_scope (CP_DECL_CONTEXT (t), flags);
1129 dump_function_name (t, flags);
1133 dump_parameters (parmtypes, flags);
1135 if (TREE_CODE (fntype) == METHOD_TYPE)
1136 dump_qualifiers (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))),
1139 if (flags & TFF_EXCEPTION_SPECIFICATION)
1140 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
1143 dump_type_suffix (TREE_TYPE (fntype), flags);
1146 /* If T is a template instantiation, dump the parameter binding. */
1147 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1149 output_add_string (scratch_buffer, " [with ");
1150 dump_template_bindings (template_parms, template_args);
1151 print_right_bracket (scratch_buffer);
1155 /* Print a parameter list. If this is for a member function, the
1156 member object ptr (and any other hidden args) should have
1157 already been removed. */
1160 dump_parameters (tree parmtypes, int flags)
1164 print_left_paren (scratch_buffer);
1166 for (first = 1; parmtypes != void_list_node;
1167 parmtypes = TREE_CHAIN (parmtypes))
1170 separate_with_comma (scratch_buffer);
1174 print_identifier (scratch_buffer, "...");
1177 dump_type (TREE_VALUE (parmtypes), flags);
1179 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1181 output_add_string (scratch_buffer, " = ");
1182 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1186 print_right_paren (scratch_buffer);
1189 /* Print an exception specification. T is the exception specification. */
1192 dump_exception_spec (tree t, int flags)
1196 output_add_string (scratch_buffer, " throw (");
1197 if (TREE_VALUE (t) != NULL_TREE)
1200 dump_type (TREE_VALUE (t), flags);
1204 separate_with_comma (scratch_buffer);
1206 print_right_paren (scratch_buffer);
1210 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1211 and destructors properly. */
1214 dump_function_name (tree t, int flags)
1216 tree name = DECL_NAME (t);
1218 if (TREE_CODE (t) == TEMPLATE_DECL)
1219 t = DECL_TEMPLATE_RESULT (t);
1221 /* Don't let the user see __comp_ctor et al. */
1222 if (DECL_CONSTRUCTOR_P (t)
1223 || DECL_DESTRUCTOR_P (t))
1224 name = constructor_name (DECL_CONTEXT (t));
1226 if (DECL_DESTRUCTOR_P (t))
1228 output_add_character (scratch_buffer, '~');
1229 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1231 else if (DECL_CONV_FN_P (t))
1233 /* This cannot use the hack that the operator's return
1234 type is stashed off of its name because it may be
1235 used for error reporting. In the case of conflicting
1236 declarations, both will have the same name, yet
1237 the types will be different, hence the TREE_TYPE field
1238 of the first name will be clobbered by the second. */
1239 output_add_string (scratch_buffer, "operator ");
1240 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1242 else if (IDENTIFIER_OPNAME_P (name))
1243 print_tree_identifier (scratch_buffer, name);
1245 dump_decl (name, flags);
1247 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
1248 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1249 && (DECL_TEMPLATE_SPECIALIZATION (t)
1250 || TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1251 || DECL_TEMPLATE_SPECIALIZATION (DECL_TI_TEMPLATE (t))
1252 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1253 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1256 /* Dump the template parameters from the template info INFO under control of
1257 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1258 specialization (partial or complete). For partial specializations we show
1259 the specialized parameter values. For a primary template we show no
1263 dump_template_parms (tree info, int primary, int flags)
1265 tree args = info ? TI_ARGS (info) : NULL_TREE;
1267 if (primary && flags & TFF_TEMPLATE_NAME)
1269 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1270 print_template_argument_list_start (scratch_buffer);
1272 /* Be careful only to print things when we have them, so as not
1273 to crash producing error messages. */
1274 if (args && !primary)
1280 if (TREE_CODE (args) == TREE_VEC)
1282 if (TREE_VEC_LENGTH (args) > 0
1283 && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
1284 args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
1286 len = TREE_VEC_LENGTH (args);
1288 else if (TREE_CODE (args) == TREE_LIST)
1290 while (ix != len && args)
1295 arg = TREE_VEC_ELT (args, ix);
1300 arg = TREE_VALUE (args);
1301 args = TREE_CHAIN (args);
1304 separate_with_comma (scratch_buffer);
1307 print_identifier (scratch_buffer, "<template parameter error>");
1309 dump_template_argument (arg, flags);
1315 tree tpl = TI_TEMPLATE (info);
1316 tree parms = DECL_TEMPLATE_PARMS (tpl);
1319 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1320 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1322 for (ix = 0; ix != len; ix++)
1324 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1327 separate_with_comma (scratch_buffer);
1329 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1332 print_template_argument_list_end (scratch_buffer);
1340 case TARGET_NEWLINE:
1341 output_add_string (scratch_buffer, "\\n");
1344 output_add_string (scratch_buffer, "\\t");
1347 output_add_string (scratch_buffer, "\\v");
1350 output_add_string (scratch_buffer, "\\b");
1353 output_add_string (scratch_buffer, "\\r");
1356 output_add_string (scratch_buffer, "\\f");
1359 output_add_string (scratch_buffer, "\\a");
1362 output_add_string (scratch_buffer, "\\\\");
1365 output_add_string (scratch_buffer, "\\'");
1368 output_add_string (scratch_buffer, "\\\"");
1372 output_add_character (scratch_buffer, c);
1375 sprintf (digit_buffer, "\\%03o", (int) c);
1376 output_add_string (scratch_buffer, digit_buffer);
1381 /* Print out a list of initializers (subr of dump_expr) */
1384 dump_expr_list (tree l, int flags)
1388 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1391 separate_with_comma (scratch_buffer);
1395 /* Print out an expression E under control of FLAGS. */
1398 dump_expr (tree t, int flags)
1403 switch (TREE_CODE (t))
1411 case NAMESPACE_DECL:
1413 case IDENTIFIER_NODE:
1414 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
1419 tree type = TREE_TYPE (t);
1420 my_friendly_assert (type != 0, 81);
1422 /* If it's an enum, output its tag, rather than its value. */
1423 if (TREE_CODE (type) == ENUMERAL_TYPE)
1425 tree values = TYPE_VALUES (type);
1428 values = TREE_CHAIN (values))
1429 if (tree_int_cst_equal (TREE_VALUE (values), t))
1433 print_tree_identifier (scratch_buffer, TREE_PURPOSE (values));
1436 /* Value must have been cast. */
1437 print_left_paren (scratch_buffer);
1438 dump_type (type, flags);
1439 print_right_paren (scratch_buffer);
1443 else if (type == boolean_type_node)
1445 if (t == boolean_false_node || integer_zerop (t))
1446 print_identifier (scratch_buffer, "false");
1447 else if (t == boolean_true_node)
1448 print_identifier (scratch_buffer, "true");
1450 else if (type == char_type_node)
1452 output_add_character (scratch_buffer, '\'');
1453 if (host_integerp (t, TREE_UNSIGNED (type)))
1454 dump_char (tree_low_cst (t, TREE_UNSIGNED (type)));
1456 output_printf (scratch_buffer, "\\x%x",
1457 (unsigned int) TREE_INT_CST_LOW (t));
1458 output_add_character (scratch_buffer, '\'');
1463 if (! host_integerp (t, 0))
1467 if (tree_int_cst_sgn (val) < 0)
1469 output_add_character (scratch_buffer, '-');
1470 val = build_int_2 (-TREE_INT_CST_LOW (val),
1471 ~TREE_INT_CST_HIGH (val)
1472 + !TREE_INT_CST_LOW (val));
1474 sprintf (digit_buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
1475 TREE_INT_CST_HIGH (val), TREE_INT_CST_LOW (val));
1476 output_add_string (scratch_buffer, digit_buffer);
1479 print_integer (scratch_buffer, TREE_INT_CST_LOW (t));
1485 real_to_decimal (digit_buffer, &TREE_REAL_CST (t),
1486 sizeof (digit_buffer), 0, 1);
1487 output_add_string (scratch_buffer, digit_buffer);
1491 output_add_character (scratch_buffer, '&');
1492 dump_type (PTRMEM_CST_CLASS (t), flags);
1493 print_scope_operator (scratch_buffer);
1494 print_tree_identifier
1495 (scratch_buffer, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1500 const char *p = TREE_STRING_POINTER (t);
1501 int len = TREE_STRING_LENGTH (t) - 1;
1504 output_add_character (scratch_buffer, '\"');
1505 for (i = 0; i < len; i++)
1507 output_add_character (scratch_buffer, '\"');
1512 print_left_paren (scratch_buffer);
1513 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1514 separate_with_comma (scratch_buffer);
1515 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1516 print_right_paren (scratch_buffer);
1520 print_left_paren (scratch_buffer);
1521 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1522 output_add_string (scratch_buffer, " ? ");
1523 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1524 output_add_string (scratch_buffer, " : ");
1525 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1526 print_right_paren (scratch_buffer);
1530 if (TREE_HAS_CONSTRUCTOR (t))
1532 output_add_string (scratch_buffer, "new ");
1533 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1537 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1541 case AGGR_INIT_EXPR:
1543 tree fn = NULL_TREE;
1545 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
1546 fn = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
1548 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1550 if (DECL_CONSTRUCTOR_P (fn))
1551 print_tree_identifier
1552 (scratch_buffer, TYPE_IDENTIFIER (TREE_TYPE (t)));
1557 dump_expr (TREE_OPERAND (t, 0), 0);
1559 print_left_paren (scratch_buffer);
1560 if (TREE_OPERAND (t, 1))
1561 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1562 print_right_paren (scratch_buffer);
1567 tree fn = TREE_OPERAND (t, 0);
1568 tree args = TREE_OPERAND (t, 1);
1570 if (TREE_CODE (fn) == ADDR_EXPR)
1571 fn = TREE_OPERAND (fn, 0);
1573 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1575 tree ob = TREE_VALUE (args);
1576 if (TREE_CODE (ob) == ADDR_EXPR)
1578 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1579 output_add_character (scratch_buffer, '.');
1581 else if (TREE_CODE (ob) != PARM_DECL
1582 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1584 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1585 output_add_string (scratch_buffer, "->");
1587 args = TREE_CHAIN (args);
1589 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1590 print_left_paren (scratch_buffer);
1591 dump_expr_list (args, flags);
1592 print_right_paren (scratch_buffer);
1598 tree type = TREE_OPERAND (t, 1);
1599 tree init = TREE_OPERAND (t, 2);
1600 if (NEW_EXPR_USE_GLOBAL (t))
1601 print_scope_operator (scratch_buffer);
1602 output_add_string (scratch_buffer, "new ");
1603 if (TREE_OPERAND (t, 0))
1605 print_left_paren (scratch_buffer);
1606 dump_expr_list (TREE_OPERAND (t, 0), flags);
1607 output_add_string (scratch_buffer, ") ");
1609 if (TREE_CODE (type) == ARRAY_REF)
1610 type = build_cplus_array_type
1611 (TREE_OPERAND (type, 0),
1612 build_index_type (fold (build (MINUS_EXPR, integer_type_node,
1613 TREE_OPERAND (type, 1),
1614 integer_one_node))));
1615 dump_type (type, flags);
1618 print_left_paren (scratch_buffer);
1619 if (TREE_CODE (init) == TREE_LIST)
1620 dump_expr_list (init, flags);
1621 else if (init == void_zero_node)
1622 /* This representation indicates an empty initializer,
1623 e.g.: "new int()". */
1626 dump_expr (init, flags);
1627 print_right_paren (scratch_buffer);
1633 /* Note that this only works for G++ target exprs. If somebody
1634 builds a general TARGET_EXPR, there's no way to represent that
1635 it initializes anything other that the parameter slot for the
1636 default argument. Note we may have cleared out the first
1637 operand in expand_expr, so don't go killing ourselves. */
1638 if (TREE_OPERAND (t, 1))
1639 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1647 case TRUNC_DIV_EXPR:
1648 case TRUNC_MOD_EXPR:
1656 case BIT_ANDTC_EXPR:
1657 case TRUTH_ANDIF_EXPR:
1658 case TRUTH_ORIF_EXPR:
1665 case EXACT_DIV_EXPR:
1666 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1670 case FLOOR_DIV_EXPR:
1671 case ROUND_DIV_EXPR:
1672 dump_binary_op ("/", t, flags);
1676 case FLOOR_MOD_EXPR:
1677 case ROUND_MOD_EXPR:
1678 dump_binary_op ("%", t, flags);
1683 tree ob = TREE_OPERAND (t, 0);
1684 if (TREE_CODE (ob) == INDIRECT_REF)
1686 ob = TREE_OPERAND (ob, 0);
1687 if (TREE_CODE (ob) != PARM_DECL
1688 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1690 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1691 output_add_string (scratch_buffer, "->");
1696 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1697 output_add_character (scratch_buffer, '.');
1699 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1704 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1705 print_left_bracket (scratch_buffer);
1706 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1707 print_right_bracket (scratch_buffer);
1711 if (TREE_TYPE (t) && VOID_TYPE_P (TREE_TYPE (t)))
1713 print_left_paren (scratch_buffer);
1714 dump_type (TREE_TYPE (t), flags);
1715 print_right_paren (scratch_buffer);
1716 dump_expr (TREE_OPERAND (t, 0), flags);
1719 dump_unary_op ("+", t, flags);
1723 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1724 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1725 /* An ADDR_EXPR can have reference type. In that case, we
1726 shouldn't print the `&' doing so indicates to the user
1727 that the expression has pointer type. */
1729 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1730 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1732 dump_unary_op ("&", t, flags);
1736 if (TREE_HAS_CONSTRUCTOR (t))
1738 t = TREE_OPERAND (t, 0);
1739 my_friendly_assert (TREE_CODE (t) == CALL_EXPR, 237);
1740 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1741 print_left_paren (scratch_buffer);
1742 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1743 print_right_paren (scratch_buffer);
1747 if (TREE_OPERAND (t,0) != NULL_TREE
1748 && TREE_TYPE (TREE_OPERAND (t, 0))
1749 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1750 dump_expr (TREE_OPERAND (t, 0), flags);
1752 dump_unary_op ("*", t, flags);
1758 case TRUTH_NOT_EXPR:
1759 case PREDECREMENT_EXPR:
1760 case PREINCREMENT_EXPR:
1761 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1764 case POSTDECREMENT_EXPR:
1765 case POSTINCREMENT_EXPR:
1766 print_left_paren (scratch_buffer);
1767 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1769 (scratch_buffer, operator_name_info[(int)TREE_CODE (t)].name);
1770 print_right_paren (scratch_buffer);
1773 case NON_LVALUE_EXPR:
1774 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1775 should be another level of INDIRECT_REF so that I don't have to do
1777 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1779 tree next = TREE_TYPE (TREE_TYPE (t));
1781 while (TREE_CODE (next) == POINTER_TYPE)
1782 next = TREE_TYPE (next);
1784 if (TREE_CODE (next) == FUNCTION_TYPE)
1786 if (flags & TFF_EXPR_IN_PARENS)
1787 print_left_paren (scratch_buffer);
1788 output_add_character (scratch_buffer, '*');
1789 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1790 if (flags & TFF_EXPR_IN_PARENS)
1791 print_right_paren (scratch_buffer);
1796 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1800 dump_expr (TREE_OPERAND (t, 0), flags);
1803 case EXPR_WITH_FILE_LOCATION:
1804 dump_expr (EXPR_WFL_NODE (t), flags);
1808 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1810 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1812 if (integer_zerop (idx))
1814 /* A NULL pointer-to-member constant. */
1815 output_add_string (scratch_buffer, "((");
1816 dump_type (TREE_TYPE (t), flags);
1817 output_add_string (scratch_buffer, ") 0)");
1820 else if (host_integerp (idx, 0))
1823 unsigned HOST_WIDE_INT n;
1825 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1826 t = TYPE_METHOD_BASETYPE (t);
1827 virtuals = TYPE_BINFO_VIRTUALS (TYPE_MAIN_VARIANT (t));
1829 n = tree_low_cst (idx, 0);
1831 /* Map vtable index back one, to allow for the null pointer to
1835 while (n > 0 && virtuals)
1838 virtuals = TREE_CHAIN (virtuals);
1842 dump_expr (BV_FN (virtuals),
1843 flags | TFF_EXPR_IN_PARENS);
1848 if (TREE_TYPE (t) && !CONSTRUCTOR_ELTS (t))
1850 dump_type (TREE_TYPE (t), 0);
1851 output_add_character (scratch_buffer, '(');
1852 output_add_character (scratch_buffer, ')');
1856 output_add_character (scratch_buffer, '{');
1857 dump_expr_list (CONSTRUCTOR_ELTS (t), flags);
1858 output_add_character (scratch_buffer, '}');
1865 tree ob = TREE_OPERAND (t, 0);
1866 if (is_dummy_object (ob))
1868 t = TREE_OPERAND (t, 1);
1869 if (TREE_CODE (t) == FUNCTION_DECL)
1871 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1872 else if (BASELINK_P (t))
1873 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1874 flags | TFF_EXPR_IN_PARENS);
1876 dump_decl (t, flags);
1880 if (TREE_CODE (ob) == INDIRECT_REF)
1882 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1883 output_add_string (scratch_buffer, "->*");
1887 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1888 output_add_string (scratch_buffer, ".*");
1890 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1895 case TEMPLATE_PARM_INDEX:
1896 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1900 dump_type (TREE_OPERAND (t, 0), flags);
1901 print_scope_operator (scratch_buffer);
1902 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1906 if (TREE_OPERAND (t, 0) == NULL_TREE
1907 || TREE_CHAIN (TREE_OPERAND (t, 0)))
1909 dump_type (TREE_TYPE (t), flags);
1910 print_left_paren (scratch_buffer);
1911 dump_expr_list (TREE_OPERAND (t, 0), flags);
1912 print_right_paren (scratch_buffer);
1916 print_left_paren (scratch_buffer);
1917 dump_type (TREE_TYPE (t), flags);
1918 output_add_string (scratch_buffer, ")(");
1919 dump_expr_list (TREE_OPERAND (t, 0), flags);
1920 print_right_paren (scratch_buffer);
1924 case STATIC_CAST_EXPR:
1925 output_add_string (scratch_buffer, "static_cast<");
1927 case REINTERPRET_CAST_EXPR:
1928 output_add_string (scratch_buffer, "reinterpret_cast<");
1930 case CONST_CAST_EXPR:
1931 output_add_string (scratch_buffer, "const_cast<");
1933 case DYNAMIC_CAST_EXPR:
1934 output_add_string (scratch_buffer, "dynamic_cast<");
1936 dump_type (TREE_TYPE (t), flags);
1937 output_add_string (scratch_buffer, ">(");
1938 dump_expr (TREE_OPERAND (t, 0), flags);
1939 print_right_paren (scratch_buffer);
1943 print_tree_identifier (scratch_buffer, TREE_OPERAND (t, 0));
1947 dump_expr (TREE_OPERAND (t, 0), flags);
1948 output_add_string (scratch_buffer, "->");
1953 if (TREE_CODE (t) == SIZEOF_EXPR)
1954 output_add_string (scratch_buffer, "sizeof (");
1957 my_friendly_assert (TREE_CODE (t) == ALIGNOF_EXPR, 0);
1958 output_add_string (scratch_buffer, "__alignof__ (");
1960 if (TYPE_P (TREE_OPERAND (t, 0)))
1961 dump_type (TREE_OPERAND (t, 0), flags);
1963 dump_unary_op ("*", t, flags | TFF_EXPR_IN_PARENS);
1964 print_right_paren (scratch_buffer);
1968 print_identifier (scratch_buffer, "<unparsed>");
1971 case TRY_CATCH_EXPR:
1972 case WITH_CLEANUP_EXPR:
1973 case CLEANUP_POINT_EXPR:
1974 dump_expr (TREE_OPERAND (t, 0), flags);
1977 case PSEUDO_DTOR_EXPR:
1978 dump_expr (TREE_OPERAND (t, 2), flags);
1979 output_add_character (scratch_buffer, '.');
1980 dump_type (TREE_OPERAND (t, 0), flags);
1981 output_add_string (scratch_buffer, "::~");
1982 dump_type (TREE_OPERAND (t, 1), flags);
1985 case TEMPLATE_ID_EXPR:
1986 dump_decl (t, flags);
1990 /* We don't yet have a way of dumping statements in a
1991 human-readable format. */
1992 output_add_string (scratch_buffer, "({...})");
1996 output_add_character (scratch_buffer, '{');
1997 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1998 output_add_character (scratch_buffer, '}');
2002 output_add_string (scratch_buffer, "while (1) { ");
2003 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2004 output_add_character (scratch_buffer, '}');
2008 output_add_string (scratch_buffer, "if (");
2009 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2010 output_add_string (scratch_buffer, ") break; ");
2014 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
2017 /* else fall through */
2019 /* This list is incomplete, but should suffice for now.
2020 It is very important that `sorry' does not call
2021 `report_error_function'. That could cause an infinite loop. */
2023 sorry_for_unsupported_tree (t);
2024 /* fall through to ERROR_MARK... */
2026 print_identifier (scratch_buffer, "<expression error>");
2032 dump_binary_op (const char *opstring, tree t, int flags)
2034 print_left_paren (scratch_buffer);
2035 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2036 output_add_space (scratch_buffer);
2038 print_identifier (scratch_buffer, opstring);
2040 print_identifier (scratch_buffer, "<unknown operator>");
2041 output_add_space (scratch_buffer);
2042 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2043 print_right_paren (scratch_buffer);
2047 dump_unary_op (const char *opstring, tree t, int flags)
2049 if (flags & TFF_EXPR_IN_PARENS)
2050 print_left_paren (scratch_buffer);
2051 print_identifier (scratch_buffer, opstring);
2052 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2053 if (flags & TFF_EXPR_IN_PARENS)
2054 print_right_paren (scratch_buffer);
2057 /* Exported interface to stringifying types, exprs and decls under TFF_*
2061 type_as_string (tree typ, int flags)
2063 reinit_global_formatting_buffer ();
2065 dump_type (typ, flags);
2067 return output_finalize_message (scratch_buffer);
2071 expr_as_string (tree decl, int flags)
2073 reinit_global_formatting_buffer ();
2075 dump_expr (decl, flags);
2077 return output_finalize_message (scratch_buffer);
2081 decl_as_string (tree decl, int flags)
2083 reinit_global_formatting_buffer ();
2085 dump_decl (decl, flags);
2087 return output_finalize_message (scratch_buffer);
2091 context_as_string (tree context, int flags)
2093 reinit_global_formatting_buffer ();
2095 dump_scope (context, flags);
2097 return output_finalize_message (scratch_buffer);
2100 /* Generate the three forms of printable names for cxx_printable_name. */
2103 lang_decl_name (tree decl, int v)
2106 return decl_as_string (decl, TFF_DECL_SPECIFIERS);
2108 reinit_global_formatting_buffer ();
2110 if (v == 1 && DECL_CLASS_SCOPE_P (decl))
2112 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2113 print_scope_operator (scratch_buffer);
2116 if (TREE_CODE (decl) == FUNCTION_DECL)
2117 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2119 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2121 return output_finalize_message (scratch_buffer);
2127 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2128 return DECL_SOURCE_FILE (DECL_CONTEXT (t));
2129 else if (TYPE_P (t))
2130 return DECL_SOURCE_FILE (TYPE_MAIN_DECL (t));
2131 else if (TREE_CODE (t) == OVERLOAD)
2132 return DECL_SOURCE_FILE (OVL_FUNCTION (t));
2134 return DECL_SOURCE_FILE (t);
2141 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2142 line = DECL_SOURCE_LINE (DECL_CONTEXT (t));
2143 if (TREE_CODE (t) == TYPE_DECL && DECL_ARTIFICIAL (t)
2144 && TYPE_MAIN_DECL (TREE_TYPE (t)))
2148 line = DECL_SOURCE_LINE (TYPE_MAIN_DECL (t));
2149 else if (TREE_CODE (t) == OVERLOAD)
2150 line = DECL_SOURCE_LINE (OVL_FUNCTION (t));
2152 line = DECL_SOURCE_LINE (t);
2160 /* Now the interfaces from error et al to dump_type et al. Each takes an
2161 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2165 decl_to_string (tree decl, int verbose)
2169 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2170 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2171 flags = TFF_CLASS_KEY_OR_ENUM;
2173 flags |= TFF_DECL_SPECIFIERS | TFF_FUNCTION_DEFAULT_ARGUMENTS;
2174 else if (TREE_CODE (decl) == FUNCTION_DECL)
2175 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2176 flags |= TFF_TEMPLATE_HEADER;
2178 reinit_global_formatting_buffer ();
2180 dump_decl (decl, flags);
2182 return output_finalize_message (scratch_buffer);
2186 expr_to_string (tree decl, int verbose ATTRIBUTE_UNUSED)
2188 reinit_global_formatting_buffer ();
2190 dump_expr (decl, 0);
2192 return output_finalize_message (scratch_buffer);
2196 fndecl_to_string (tree fndecl, int verbose)
2200 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS;
2202 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2203 reinit_global_formatting_buffer ();
2205 dump_decl (fndecl, flags);
2207 return output_finalize_message (scratch_buffer);
2212 code_to_string (enum tree_code c, int v ATTRIBUTE_UNUSED)
2214 return tree_code_name [c];
2218 language_to_string (enum languages c, int v ATTRIBUTE_UNUSED)
2225 case lang_cplusplus:
2237 /* Return the proper printed version of a parameter to a C++ function. */
2240 parm_to_string (int p, int v ATTRIBUTE_UNUSED)
2245 sprintf (digit_buffer, "%d", p+1);
2246 return digit_buffer;
2250 op_to_string (enum tree_code p, int v ATTRIBUTE_UNUSED)
2254 id = operator_name_info[(int) p].identifier;
2255 return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2259 type_to_string (tree typ, int verbose)
2265 flags |= TFF_CLASS_KEY_OR_ENUM;
2266 flags |= TFF_TEMPLATE_HEADER;
2268 reinit_global_formatting_buffer ();
2270 dump_type (typ, flags);
2272 return output_finalize_message (scratch_buffer);
2276 assop_to_string (enum tree_code p, int v ATTRIBUTE_UNUSED)
2280 id = assignment_operator_name_info[(int) p].identifier;
2281 return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2285 args_to_string (tree p, int verbose)
2289 flags |= TFF_CLASS_KEY_OR_ENUM;
2294 if (TYPE_P (TREE_VALUE (p)))
2295 return type_as_string (p, flags);
2297 reinit_global_formatting_buffer ();
2298 for (; p; p = TREE_CHAIN (p))
2300 if (TREE_VALUE (p) == null_node)
2301 print_identifier (scratch_buffer, "NULL");
2303 dump_type (error_type (TREE_VALUE (p)), flags);
2305 separate_with_comma (scratch_buffer);
2307 return output_finalize_message (scratch_buffer);
2311 cv_to_string (tree p, int v)
2313 reinit_global_formatting_buffer ();
2315 dump_qualifiers (p, v ? before : none);
2317 return output_finalize_message (scratch_buffer);
2320 /* Langhook for print_error_function. */
2322 cxx_print_error_function (diagnostic_context *context, const char *file)
2324 lhd_print_error_function (context, file);
2325 output_set_prefix (&context->buffer, file);
2326 maybe_print_instantiation_context (context);
2330 cp_diagnostic_starter (diagnostic_context *context,
2331 diagnostic_info *diagnostic)
2333 diagnostic_report_current_module (context);
2334 cp_print_error_function (context, diagnostic);
2335 maybe_print_instantiation_context (context);
2336 output_set_prefix (&context->buffer, diagnostic_build_prefix (diagnostic));
2340 cp_diagnostic_finalizer (diagnostic_context *context,
2341 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2343 output_destroy_prefix (&context->buffer);
2346 /* Print current function onto BUFFER, in the process of reporting
2347 a diagnostic message. Called from cp_diagnostic_starter. */
2349 cp_print_error_function (diagnostic_context *context,
2350 diagnostic_info *diagnostic)
2352 if (diagnostic_last_function_changed (context))
2354 const char *old_prefix = output_prefix (&context->buffer);
2355 char *new_prefix = diagnostic->location.file
2356 ? file_name_as_prefix (diagnostic->location.file)
2359 output_set_prefix (&context->buffer, new_prefix);
2361 if (current_function_decl == NULL)
2362 output_add_string (&context->buffer, "At global scope:");
2364 output_printf (&context->buffer, "In %s `%s':",
2365 function_category (current_function_decl),
2366 cxx_printable_name (current_function_decl, 2));
2367 output_add_newline (&context->buffer);
2369 diagnostic_set_last_function (context);
2370 output_destroy_prefix (&context->buffer);
2371 context->buffer.state.prefix = old_prefix;
2375 /* Returns a description of FUNCTION using standard terminology. */
2377 function_category (tree fn)
2379 if (DECL_FUNCTION_MEMBER_P (fn))
2381 if (DECL_STATIC_FUNCTION_P (fn))
2382 return "static member function";
2383 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2384 return "copy constructor";
2385 else if (DECL_CONSTRUCTOR_P (fn))
2386 return "constructor";
2387 else if (DECL_DESTRUCTOR_P (fn))
2388 return "destructor";
2390 return "member function";
2396 /* Report the full context of a current template instantiation,
2399 print_instantiation_full_context (diagnostic_context *context)
2401 tree p = current_instantiation ();
2402 location_t location = input_location;
2406 if (current_function_decl != TINST_DECL (p)
2407 && current_function_decl != NULL_TREE)
2408 /* We can get here during the processing of some synthesized
2409 method. Then, TINST_DECL (p) will be the function that's causing
2414 if (current_function_decl == TINST_DECL (p))
2415 /* Avoid redundancy with the the "In function" line. */;
2417 output_verbatim (&context->buffer,
2418 "%s: In instantiation of `%s':\n", location.file,
2419 decl_as_string (TINST_DECL (p),
2420 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2422 location.line = TINST_LINE (p);
2423 location.file = TINST_FILE (p);
2428 print_instantiation_partial_context (context, p,
2429 location.file, location.line);
2432 /* Same as above but less verbose. */
2434 print_instantiation_partial_context (diagnostic_context *context,
2435 tree t, const char *file, int line)
2437 for (; t; t = TREE_CHAIN (t))
2440 (&context->buffer, "%s:%d: instantiated from `%s'\n", file, line,
2441 decl_as_string (TINST_DECL (t), TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2442 line = TINST_LINE (t);
2443 file = TINST_FILE (t);
2445 output_verbatim (&context->buffer, "%s:%d: instantiated from here\n", file, line);
2448 /* Called from cp_thing to print the template context for an error. */
2450 maybe_print_instantiation_context (diagnostic_context *context)
2452 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2455 record_last_problematic_instantiation ();
2456 print_instantiation_full_context (context);
2459 /* Report the bare minimum context of a template instantiation. */
2461 print_instantiation_context (void)
2463 print_instantiation_partial_context
2464 (global_dc, current_instantiation (), input_filename, input_line);
2465 diagnostic_flush_buffer (global_dc);
2468 /* Called from output_format -- during diagnostic message processing --
2469 to handle C++ specific format specifier with the following meanings:
2470 %A function argument-list.
2474 %F function declaration.
2475 %L language as used in extern "lang".
2477 %P function parameter whose position is indicated by an integer.
2478 %Q assignment operator.
2482 cp_printer (output_buffer *buffer, text_info *text)
2486 #define next_tree va_arg (*text->args_ptr, tree)
2487 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2488 #define next_lang va_arg (*text->args_ptr, enum languages)
2489 #define next_int va_arg (*text->args_ptr, int)
2491 if (*text->format_spec == '+')
2492 ++text->format_spec;
2493 if (*text->format_spec == '#')
2496 ++text->format_spec;
2499 switch (*text->format_spec)
2501 case 'A': result = args_to_string (next_tree, verbose); break;
2502 case 'C': result = code_to_string (next_tcode, verbose); break;
2503 case 'D': result = decl_to_string (next_tree, verbose); break;
2504 case 'E': result = expr_to_string (next_tree, verbose); break;
2505 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2506 case 'L': result = language_to_string (next_lang, verbose); break;
2507 case 'O': result = op_to_string (next_tcode, verbose); break;
2508 case 'P': result = parm_to_string (next_int, verbose); break;
2509 case 'Q': result = assop_to_string (next_tcode, verbose); break;
2510 case 'T': result = type_to_string (next_tree, verbose); break;
2511 case 'V': result = cv_to_string (next_tree, verbose); break;
2517 output_add_string (buffer, result);
2526 print_integer (output_buffer *buffer, HOST_WIDE_INT i)
2528 sprintf (digit_buffer, HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT) i);
2529 output_add_string (buffer, digit_buffer);
2533 print_non_consecutive_character (output_buffer *buffer, int c)
2535 const char *p = output_last_position (buffer);
2537 if (p != NULL && *p == c)
2538 output_add_space (buffer);
2539 output_add_character (buffer, c);
2542 /* These are temporary wrapper functions which handle the historic
2543 behavior of cp_*_at. */
2546 locate_error (const char *msgid, va_list ap)
2552 for (f = msgid; *f; f++)
2565 /* Just ignore these possibilities. */
2567 case 'd': (void) va_arg (ap, int); break;
2568 case 's': (void) va_arg (ap, char *); break;
2569 case 'L': (void) va_arg (ap, enum languages); break;
2572 case 'Q': (void) va_arg (ap, enum tree_code); break;
2574 /* These take a tree, which may be where the error is
2583 t = va_arg (ap, tree);
2589 errorcount = 0; /* damn ICE suppression */
2590 internal_error ("unexpected letter `%c' in locate_error\n", *f);
2596 here = va_arg (ap, tree);
2603 cp_error_at (const char *msgid, ...)
2606 diagnostic_info diagnostic;
2609 va_start (ap, msgid);
2610 here = locate_error (msgid, ap);
2613 va_start (ap, msgid);
2614 diagnostic_set_info (&diagnostic, msgid, &ap,
2615 cp_file_of (here), cp_line_of (here), DK_ERROR);
2616 report_diagnostic (&diagnostic);
2621 cp_warning_at (const char *msgid, ...)
2624 diagnostic_info diagnostic;
2627 va_start (ap, msgid);
2628 here = locate_error (msgid, ap);
2631 va_start (ap, msgid);
2632 diagnostic_set_info (&diagnostic, msgid, &ap,
2633 cp_file_of (here), cp_line_of (here), DK_WARNING);
2634 report_diagnostic (&diagnostic);
2639 cp_pedwarn_at (const char *msgid, ...)
2642 diagnostic_info diagnostic;
2645 va_start (ap, msgid);
2646 here = locate_error (msgid, ap);
2649 va_start (ap, msgid);
2650 diagnostic_set_info (&diagnostic, msgid, &ap,
2651 cp_file_of (here), cp_line_of (here),
2652 pedantic_error_kind());
2653 report_diagnostic (&diagnostic);