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 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
1477 static char format[12]; /* "0x%x%09999x\0" */
1479 sprintf (format, "0x%%x%%0%dx", HOST_BITS_PER_INT / 4);
1480 sprintf (digit_buffer, format, TREE_INT_CST_HIGH (val),
1481 TREE_INT_CST_LOW (val));
1482 output_add_string (scratch_buffer, digit_buffer);
1486 print_integer (scratch_buffer, TREE_INT_CST_LOW (t));
1492 real_to_decimal (digit_buffer, &TREE_REAL_CST (t),
1493 sizeof (digit_buffer), 0, 1);
1494 output_add_string (scratch_buffer, digit_buffer);
1498 output_add_character (scratch_buffer, '&');
1499 dump_type (PTRMEM_CST_CLASS (t), flags);
1500 print_scope_operator (scratch_buffer);
1501 print_tree_identifier
1502 (scratch_buffer, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1507 const char *p = TREE_STRING_POINTER (t);
1508 int len = TREE_STRING_LENGTH (t) - 1;
1511 output_add_character (scratch_buffer, '\"');
1512 for (i = 0; i < len; i++)
1514 output_add_character (scratch_buffer, '\"');
1519 print_left_paren (scratch_buffer);
1520 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1521 separate_with_comma (scratch_buffer);
1522 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1523 print_right_paren (scratch_buffer);
1527 print_left_paren (scratch_buffer);
1528 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1529 output_add_string (scratch_buffer, " ? ");
1530 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1531 output_add_string (scratch_buffer, " : ");
1532 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1533 print_right_paren (scratch_buffer);
1537 if (TREE_HAS_CONSTRUCTOR (t))
1539 output_add_string (scratch_buffer, "new ");
1540 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1544 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1548 case AGGR_INIT_EXPR:
1550 tree fn = NULL_TREE;
1552 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
1553 fn = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
1555 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1557 if (DECL_CONSTRUCTOR_P (fn))
1558 print_tree_identifier
1559 (scratch_buffer, TYPE_IDENTIFIER (TREE_TYPE (t)));
1564 dump_expr (TREE_OPERAND (t, 0), 0);
1566 print_left_paren (scratch_buffer);
1567 if (TREE_OPERAND (t, 1))
1568 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1569 print_right_paren (scratch_buffer);
1574 tree fn = TREE_OPERAND (t, 0);
1575 tree args = TREE_OPERAND (t, 1);
1577 if (TREE_CODE (fn) == ADDR_EXPR)
1578 fn = TREE_OPERAND (fn, 0);
1580 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1582 tree ob = TREE_VALUE (args);
1583 if (TREE_CODE (ob) == ADDR_EXPR)
1585 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1586 output_add_character (scratch_buffer, '.');
1588 else if (TREE_CODE (ob) != PARM_DECL
1589 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1591 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1592 output_add_string (scratch_buffer, "->");
1594 args = TREE_CHAIN (args);
1596 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1597 print_left_paren (scratch_buffer);
1598 dump_expr_list (args, flags);
1599 print_right_paren (scratch_buffer);
1605 tree type = TREE_OPERAND (t, 1);
1606 tree init = TREE_OPERAND (t, 2);
1607 if (NEW_EXPR_USE_GLOBAL (t))
1608 print_scope_operator (scratch_buffer);
1609 output_add_string (scratch_buffer, "new ");
1610 if (TREE_OPERAND (t, 0))
1612 print_left_paren (scratch_buffer);
1613 dump_expr_list (TREE_OPERAND (t, 0), flags);
1614 output_add_string (scratch_buffer, ") ");
1616 if (TREE_CODE (type) == ARRAY_REF)
1617 type = build_cplus_array_type
1618 (TREE_OPERAND (type, 0),
1619 build_index_type (fold (build (MINUS_EXPR, integer_type_node,
1620 TREE_OPERAND (type, 1),
1621 integer_one_node))));
1622 dump_type (type, flags);
1625 print_left_paren (scratch_buffer);
1626 if (TREE_CODE (init) == TREE_LIST)
1627 dump_expr_list (init, flags);
1628 else if (init == void_zero_node)
1629 /* This representation indicates an empty initializer,
1630 e.g.: "new int()". */
1633 dump_expr (init, flags);
1634 print_right_paren (scratch_buffer);
1640 /* Note that this only works for G++ target exprs. If somebody
1641 builds a general TARGET_EXPR, there's no way to represent that
1642 it initializes anything other that the parameter slot for the
1643 default argument. Note we may have cleared out the first
1644 operand in expand_expr, so don't go killing ourselves. */
1645 if (TREE_OPERAND (t, 1))
1646 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1654 case TRUNC_DIV_EXPR:
1655 case TRUNC_MOD_EXPR:
1663 case BIT_ANDTC_EXPR:
1664 case TRUTH_ANDIF_EXPR:
1665 case TRUTH_ORIF_EXPR:
1672 case EXACT_DIV_EXPR:
1673 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1677 case FLOOR_DIV_EXPR:
1678 case ROUND_DIV_EXPR:
1679 dump_binary_op ("/", t, flags);
1683 case FLOOR_MOD_EXPR:
1684 case ROUND_MOD_EXPR:
1685 dump_binary_op ("%", t, flags);
1690 tree ob = TREE_OPERAND (t, 0);
1691 if (TREE_CODE (ob) == INDIRECT_REF)
1693 ob = TREE_OPERAND (ob, 0);
1694 if (TREE_CODE (ob) != PARM_DECL
1695 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1697 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1698 output_add_string (scratch_buffer, "->");
1703 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1704 output_add_character (scratch_buffer, '.');
1706 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1711 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1712 print_left_bracket (scratch_buffer);
1713 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1714 print_right_bracket (scratch_buffer);
1718 if (TREE_TYPE (t) && VOID_TYPE_P (TREE_TYPE (t)))
1720 print_left_paren (scratch_buffer);
1721 dump_type (TREE_TYPE (t), flags);
1722 print_right_paren (scratch_buffer);
1723 dump_expr (TREE_OPERAND (t, 0), flags);
1726 dump_unary_op ("+", t, flags);
1730 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1731 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1732 /* An ADDR_EXPR can have reference type. In that case, we
1733 shouldn't print the `&' doing so indicates to the user
1734 that the expression has pointer type. */
1736 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1737 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1739 dump_unary_op ("&", t, flags);
1743 if (TREE_HAS_CONSTRUCTOR (t))
1745 t = TREE_OPERAND (t, 0);
1746 my_friendly_assert (TREE_CODE (t) == CALL_EXPR, 237);
1747 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1748 print_left_paren (scratch_buffer);
1749 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1750 print_right_paren (scratch_buffer);
1754 if (TREE_OPERAND (t,0) != NULL_TREE
1755 && TREE_TYPE (TREE_OPERAND (t, 0))
1756 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1757 dump_expr (TREE_OPERAND (t, 0), flags);
1759 dump_unary_op ("*", t, flags);
1765 case TRUTH_NOT_EXPR:
1766 case PREDECREMENT_EXPR:
1767 case PREINCREMENT_EXPR:
1768 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1771 case POSTDECREMENT_EXPR:
1772 case POSTINCREMENT_EXPR:
1773 print_left_paren (scratch_buffer);
1774 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1776 (scratch_buffer, operator_name_info[(int)TREE_CODE (t)].name);
1777 print_right_paren (scratch_buffer);
1780 case NON_LVALUE_EXPR:
1781 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1782 should be another level of INDIRECT_REF so that I don't have to do
1784 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1786 tree next = TREE_TYPE (TREE_TYPE (t));
1788 while (TREE_CODE (next) == POINTER_TYPE)
1789 next = TREE_TYPE (next);
1791 if (TREE_CODE (next) == FUNCTION_TYPE)
1793 if (flags & TFF_EXPR_IN_PARENS)
1794 print_left_paren (scratch_buffer);
1795 output_add_character (scratch_buffer, '*');
1796 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1797 if (flags & TFF_EXPR_IN_PARENS)
1798 print_right_paren (scratch_buffer);
1803 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1807 dump_expr (TREE_OPERAND (t, 0), flags);
1810 case EXPR_WITH_FILE_LOCATION:
1811 dump_expr (EXPR_WFL_NODE (t), flags);
1815 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1817 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1819 if (integer_zerop (idx))
1821 /* A NULL pointer-to-member constant. */
1822 output_add_string (scratch_buffer, "((");
1823 dump_type (TREE_TYPE (t), flags);
1824 output_add_string (scratch_buffer, ") 0)");
1827 else if (host_integerp (idx, 0))
1830 unsigned HOST_WIDE_INT n;
1832 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1833 t = TYPE_METHOD_BASETYPE (t);
1834 virtuals = TYPE_BINFO_VIRTUALS (TYPE_MAIN_VARIANT (t));
1836 n = tree_low_cst (idx, 0);
1838 /* Map vtable index back one, to allow for the null pointer to
1842 while (n > 0 && virtuals)
1845 virtuals = TREE_CHAIN (virtuals);
1849 dump_expr (BV_FN (virtuals),
1850 flags | TFF_EXPR_IN_PARENS);
1855 if (TREE_TYPE (t) && !CONSTRUCTOR_ELTS (t))
1857 dump_type (TREE_TYPE (t), 0);
1858 output_add_character (scratch_buffer, '(');
1859 output_add_character (scratch_buffer, ')');
1863 output_add_character (scratch_buffer, '{');
1864 dump_expr_list (CONSTRUCTOR_ELTS (t), flags);
1865 output_add_character (scratch_buffer, '}');
1872 tree ob = TREE_OPERAND (t, 0);
1873 if (is_dummy_object (ob))
1875 t = TREE_OPERAND (t, 1);
1876 if (TREE_CODE (t) == FUNCTION_DECL)
1878 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1879 else if (BASELINK_P (t))
1880 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1881 flags | TFF_EXPR_IN_PARENS);
1883 dump_decl (t, flags);
1887 if (TREE_CODE (ob) == INDIRECT_REF)
1889 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1890 output_add_string (scratch_buffer, "->*");
1894 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1895 output_add_string (scratch_buffer, ".*");
1897 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1902 case TEMPLATE_PARM_INDEX:
1903 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1907 dump_type (TREE_OPERAND (t, 0), flags);
1908 print_scope_operator (scratch_buffer);
1909 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1913 if (TREE_OPERAND (t, 0) == NULL_TREE
1914 || TREE_CHAIN (TREE_OPERAND (t, 0)))
1916 dump_type (TREE_TYPE (t), flags);
1917 print_left_paren (scratch_buffer);
1918 dump_expr_list (TREE_OPERAND (t, 0), flags);
1919 print_right_paren (scratch_buffer);
1923 print_left_paren (scratch_buffer);
1924 dump_type (TREE_TYPE (t), flags);
1925 output_add_string (scratch_buffer, ")(");
1926 dump_expr_list (TREE_OPERAND (t, 0), flags);
1927 print_right_paren (scratch_buffer);
1931 case STATIC_CAST_EXPR:
1932 output_add_string (scratch_buffer, "static_cast<");
1934 case REINTERPRET_CAST_EXPR:
1935 output_add_string (scratch_buffer, "reinterpret_cast<");
1937 case CONST_CAST_EXPR:
1938 output_add_string (scratch_buffer, "const_cast<");
1940 case DYNAMIC_CAST_EXPR:
1941 output_add_string (scratch_buffer, "dynamic_cast<");
1943 dump_type (TREE_TYPE (t), flags);
1944 output_add_string (scratch_buffer, ">(");
1945 dump_expr (TREE_OPERAND (t, 0), flags);
1946 print_right_paren (scratch_buffer);
1950 print_tree_identifier (scratch_buffer, TREE_OPERAND (t, 0));
1954 dump_expr (TREE_OPERAND (t, 0), flags);
1955 output_add_string (scratch_buffer, "->");
1960 if (TREE_CODE (t) == SIZEOF_EXPR)
1961 output_add_string (scratch_buffer, "sizeof (");
1964 my_friendly_assert (TREE_CODE (t) == ALIGNOF_EXPR, 0);
1965 output_add_string (scratch_buffer, "__alignof__ (");
1967 if (TYPE_P (TREE_OPERAND (t, 0)))
1968 dump_type (TREE_OPERAND (t, 0), flags);
1970 dump_unary_op ("*", t, flags | TFF_EXPR_IN_PARENS);
1971 print_right_paren (scratch_buffer);
1975 print_identifier (scratch_buffer, "<unparsed>");
1978 case TRY_CATCH_EXPR:
1979 case WITH_CLEANUP_EXPR:
1980 case CLEANUP_POINT_EXPR:
1981 dump_expr (TREE_OPERAND (t, 0), flags);
1984 case PSEUDO_DTOR_EXPR:
1985 dump_expr (TREE_OPERAND (t, 2), flags);
1986 output_add_character (scratch_buffer, '.');
1987 dump_type (TREE_OPERAND (t, 0), flags);
1988 output_add_string (scratch_buffer, "::~");
1989 dump_type (TREE_OPERAND (t, 1), flags);
1992 case TEMPLATE_ID_EXPR:
1993 dump_decl (t, flags);
1997 /* We don't yet have a way of dumping statements in a
1998 human-readable format. */
1999 output_add_string (scratch_buffer, "({...})");
2003 output_add_character (scratch_buffer, '{');
2004 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
2005 output_add_character (scratch_buffer, '}');
2009 output_add_string (scratch_buffer, "while (1) { ");
2010 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2011 output_add_character (scratch_buffer, '}');
2015 output_add_string (scratch_buffer, "if (");
2016 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2017 output_add_string (scratch_buffer, ") break; ");
2021 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
2024 /* else fall through */
2026 /* This list is incomplete, but should suffice for now.
2027 It is very important that `sorry' does not call
2028 `report_error_function'. That could cause an infinite loop. */
2030 sorry_for_unsupported_tree (t);
2031 /* fall through to ERROR_MARK... */
2033 print_identifier (scratch_buffer, "<expression error>");
2039 dump_binary_op (const char *opstring, tree t, int flags)
2041 print_left_paren (scratch_buffer);
2042 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2043 output_add_space (scratch_buffer);
2045 print_identifier (scratch_buffer, opstring);
2047 print_identifier (scratch_buffer, "<unknown operator>");
2048 output_add_space (scratch_buffer);
2049 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2050 print_right_paren (scratch_buffer);
2054 dump_unary_op (const char *opstring, tree t, int flags)
2056 if (flags & TFF_EXPR_IN_PARENS)
2057 print_left_paren (scratch_buffer);
2058 print_identifier (scratch_buffer, opstring);
2059 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2060 if (flags & TFF_EXPR_IN_PARENS)
2061 print_right_paren (scratch_buffer);
2064 /* Exported interface to stringifying types, exprs and decls under TFF_*
2068 type_as_string (tree typ, int flags)
2070 reinit_global_formatting_buffer ();
2072 dump_type (typ, flags);
2074 return output_finalize_message (scratch_buffer);
2078 expr_as_string (tree decl, int flags)
2080 reinit_global_formatting_buffer ();
2082 dump_expr (decl, flags);
2084 return output_finalize_message (scratch_buffer);
2088 decl_as_string (tree decl, int flags)
2090 reinit_global_formatting_buffer ();
2092 dump_decl (decl, flags);
2094 return output_finalize_message (scratch_buffer);
2098 context_as_string (tree context, int flags)
2100 reinit_global_formatting_buffer ();
2102 dump_scope (context, flags);
2104 return output_finalize_message (scratch_buffer);
2107 /* Generate the three forms of printable names for cxx_printable_name. */
2110 lang_decl_name (tree decl, int v)
2113 return decl_as_string (decl, TFF_DECL_SPECIFIERS);
2115 reinit_global_formatting_buffer ();
2117 if (v == 1 && DECL_CLASS_SCOPE_P (decl))
2119 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2120 print_scope_operator (scratch_buffer);
2123 if (TREE_CODE (decl) == FUNCTION_DECL)
2124 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2126 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2128 return output_finalize_message (scratch_buffer);
2134 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2135 return DECL_SOURCE_FILE (DECL_CONTEXT (t));
2136 else if (TYPE_P (t))
2137 return DECL_SOURCE_FILE (TYPE_MAIN_DECL (t));
2138 else if (TREE_CODE (t) == OVERLOAD)
2139 return DECL_SOURCE_FILE (OVL_FUNCTION (t));
2141 return DECL_SOURCE_FILE (t);
2148 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2149 line = DECL_SOURCE_LINE (DECL_CONTEXT (t));
2150 if (TREE_CODE (t) == TYPE_DECL && DECL_ARTIFICIAL (t)
2151 && TYPE_MAIN_DECL (TREE_TYPE (t)))
2155 line = DECL_SOURCE_LINE (TYPE_MAIN_DECL (t));
2156 else if (TREE_CODE (t) == OVERLOAD)
2157 line = DECL_SOURCE_LINE (OVL_FUNCTION (t));
2159 line = DECL_SOURCE_LINE (t);
2167 /* Now the interfaces from error et al to dump_type et al. Each takes an
2168 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2172 decl_to_string (tree decl, int verbose)
2176 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2177 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2178 flags = TFF_CLASS_KEY_OR_ENUM;
2180 flags |= TFF_DECL_SPECIFIERS | TFF_FUNCTION_DEFAULT_ARGUMENTS;
2181 else if (TREE_CODE (decl) == FUNCTION_DECL)
2182 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2183 flags |= TFF_TEMPLATE_HEADER;
2185 reinit_global_formatting_buffer ();
2187 dump_decl (decl, flags);
2189 return output_finalize_message (scratch_buffer);
2193 expr_to_string (tree decl, int verbose ATTRIBUTE_UNUSED)
2195 reinit_global_formatting_buffer ();
2197 dump_expr (decl, 0);
2199 return output_finalize_message (scratch_buffer);
2203 fndecl_to_string (tree fndecl, int verbose)
2207 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS;
2209 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2210 reinit_global_formatting_buffer ();
2212 dump_decl (fndecl, flags);
2214 return output_finalize_message (scratch_buffer);
2219 code_to_string (enum tree_code c, int v ATTRIBUTE_UNUSED)
2221 return tree_code_name [c];
2225 language_to_string (enum languages c, int v ATTRIBUTE_UNUSED)
2232 case lang_cplusplus:
2244 /* Return the proper printed version of a parameter to a C++ function. */
2247 parm_to_string (int p, int v ATTRIBUTE_UNUSED)
2252 sprintf (digit_buffer, "%d", p+1);
2253 return digit_buffer;
2257 op_to_string (enum tree_code p, int v ATTRIBUTE_UNUSED)
2261 id = operator_name_info[(int) p].identifier;
2262 return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2266 type_to_string (tree typ, int verbose)
2272 flags |= TFF_CLASS_KEY_OR_ENUM;
2273 flags |= TFF_TEMPLATE_HEADER;
2275 reinit_global_formatting_buffer ();
2277 dump_type (typ, flags);
2279 return output_finalize_message (scratch_buffer);
2283 assop_to_string (enum tree_code p, int v ATTRIBUTE_UNUSED)
2287 id = assignment_operator_name_info[(int) p].identifier;
2288 return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2292 args_to_string (tree p, int verbose)
2296 flags |= TFF_CLASS_KEY_OR_ENUM;
2301 if (TYPE_P (TREE_VALUE (p)))
2302 return type_as_string (p, flags);
2304 reinit_global_formatting_buffer ();
2305 for (; p; p = TREE_CHAIN (p))
2307 if (TREE_VALUE (p) == null_node)
2308 print_identifier (scratch_buffer, "NULL");
2310 dump_type (error_type (TREE_VALUE (p)), flags);
2312 separate_with_comma (scratch_buffer);
2314 return output_finalize_message (scratch_buffer);
2318 cv_to_string (tree p, int v)
2320 reinit_global_formatting_buffer ();
2322 dump_qualifiers (p, v ? before : none);
2324 return output_finalize_message (scratch_buffer);
2327 /* Langhook for print_error_function. */
2329 cxx_print_error_function (diagnostic_context *context, const char *file)
2331 lhd_print_error_function (context, file);
2332 output_set_prefix (&context->buffer, file);
2333 maybe_print_instantiation_context (context);
2337 cp_diagnostic_starter (diagnostic_context *context,
2338 diagnostic_info *diagnostic)
2340 diagnostic_report_current_module (context);
2341 cp_print_error_function (context, diagnostic);
2342 maybe_print_instantiation_context (context);
2343 output_set_prefix (&context->buffer, diagnostic_build_prefix (diagnostic));
2347 cp_diagnostic_finalizer (diagnostic_context *context,
2348 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2350 output_destroy_prefix (&context->buffer);
2353 /* Print current function onto BUFFER, in the process of reporting
2354 a diagnostic message. Called from cp_diagnostic_starter. */
2356 cp_print_error_function (diagnostic_context *context,
2357 diagnostic_info *diagnostic)
2359 if (diagnostic_last_function_changed (context))
2361 const char *old_prefix = output_prefix (&context->buffer);
2362 char *new_prefix = diagnostic->location.file
2363 ? file_name_as_prefix (diagnostic->location.file)
2366 output_set_prefix (&context->buffer, new_prefix);
2368 if (current_function_decl == NULL)
2369 output_add_string (&context->buffer, "At global scope:");
2371 output_printf (&context->buffer, "In %s `%s':",
2372 function_category (current_function_decl),
2373 cxx_printable_name (current_function_decl, 2));
2374 output_add_newline (&context->buffer);
2376 diagnostic_set_last_function (context);
2377 output_destroy_prefix (&context->buffer);
2378 context->buffer.state.prefix = old_prefix;
2382 /* Returns a description of FUNCTION using standard terminology. */
2384 function_category (tree fn)
2386 if (DECL_FUNCTION_MEMBER_P (fn))
2388 if (DECL_STATIC_FUNCTION_P (fn))
2389 return "static member function";
2390 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2391 return "copy constructor";
2392 else if (DECL_CONSTRUCTOR_P (fn))
2393 return "constructor";
2394 else if (DECL_DESTRUCTOR_P (fn))
2395 return "destructor";
2397 return "member function";
2403 /* Report the full context of a current template instantiation,
2406 print_instantiation_full_context (diagnostic_context *context)
2408 tree p = current_instantiation ();
2409 location_t location = input_location;
2413 if (current_function_decl != TINST_DECL (p)
2414 && current_function_decl != NULL_TREE)
2415 /* We can get here during the processing of some synthesized
2416 method. Then, TINST_DECL (p) will be the function that's causing
2421 if (current_function_decl == TINST_DECL (p))
2422 /* Avoid redundancy with the the "In function" line. */;
2424 output_verbatim (&context->buffer,
2425 "%s: In instantiation of `%s':\n", location.file,
2426 decl_as_string (TINST_DECL (p),
2427 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2429 location.line = TINST_LINE (p);
2430 location.file = TINST_FILE (p);
2435 print_instantiation_partial_context (context, p,
2436 location.file, location.line);
2439 /* Same as above but less verbose. */
2441 print_instantiation_partial_context (diagnostic_context *context,
2442 tree t, const char *file, int line)
2444 for (; t; t = TREE_CHAIN (t))
2447 (&context->buffer, "%s:%d: instantiated from `%s'\n", file, line,
2448 decl_as_string (TINST_DECL (t), TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2449 line = TINST_LINE (t);
2450 file = TINST_FILE (t);
2452 output_verbatim (&context->buffer, "%s:%d: instantiated from here\n", file, line);
2455 /* Called from cp_thing to print the template context for an error. */
2457 maybe_print_instantiation_context (diagnostic_context *context)
2459 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2462 record_last_problematic_instantiation ();
2463 print_instantiation_full_context (context);
2466 /* Report the bare minimum context of a template instantiation. */
2468 print_instantiation_context (void)
2470 print_instantiation_partial_context
2471 (global_dc, current_instantiation (), input_filename, input_line);
2472 diagnostic_flush_buffer (global_dc);
2475 /* Called from output_format -- during diagnostic message processing --
2476 to handle C++ specific format specifier with the following meanings:
2477 %A function argument-list.
2481 %F function declaration.
2482 %L language as used in extern "lang".
2484 %P function parameter whose position is indicated by an integer.
2485 %Q assignment operator.
2489 cp_printer (output_buffer *buffer, text_info *text)
2493 #define next_tree va_arg (*text->args_ptr, tree)
2494 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2495 #define next_lang va_arg (*text->args_ptr, enum languages)
2496 #define next_int va_arg (*text->args_ptr, int)
2498 if (*text->format_spec == '+')
2499 ++text->format_spec;
2500 if (*text->format_spec == '#')
2503 ++text->format_spec;
2506 switch (*text->format_spec)
2508 case 'A': result = args_to_string (next_tree, verbose); break;
2509 case 'C': result = code_to_string (next_tcode, verbose); break;
2510 case 'D': result = decl_to_string (next_tree, verbose); break;
2511 case 'E': result = expr_to_string (next_tree, verbose); break;
2512 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2513 case 'L': result = language_to_string (next_lang, verbose); break;
2514 case 'O': result = op_to_string (next_tcode, verbose); break;
2515 case 'P': result = parm_to_string (next_int, verbose); break;
2516 case 'Q': result = assop_to_string (next_tcode, verbose); break;
2517 case 'T': result = type_to_string (next_tree, verbose); break;
2518 case 'V': result = cv_to_string (next_tree, verbose); break;
2524 output_add_string (buffer, result);
2533 print_integer (output_buffer *buffer, HOST_WIDE_INT i)
2535 sprintf (digit_buffer, HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT) i);
2536 output_add_string (buffer, digit_buffer);
2540 print_non_consecutive_character (output_buffer *buffer, int c)
2542 const char *p = output_last_position (buffer);
2544 if (p != NULL && *p == c)
2545 output_add_space (buffer);
2546 output_add_character (buffer, c);
2549 /* These are temporary wrapper functions which handle the historic
2550 behavior of cp_*_at. */
2553 locate_error (const char *msgid, va_list ap)
2559 for (f = msgid; *f; f++)
2572 /* Just ignore these possibilities. */
2574 case 'd': (void) va_arg (ap, int); break;
2575 case 's': (void) va_arg (ap, char *); break;
2576 case 'L': (void) va_arg (ap, enum languages); break;
2579 case 'Q': (void) va_arg (ap, enum tree_code); break;
2581 /* These take a tree, which may be where the error is
2590 t = va_arg (ap, tree);
2596 errorcount = 0; /* damn ICE suppression */
2597 internal_error ("unexpected letter `%c' in locate_error\n", *f);
2603 here = va_arg (ap, tree);
2610 cp_error_at VPARAMS ((const char *msgid, ...))
2613 diagnostic_info diagnostic;
2615 VA_OPEN (ap, msgid);
2616 VA_FIXEDARG (ap, const char *, msgid);
2617 here = locate_error (msgid, ap);
2620 VA_OPEN (ap, msgid);
2621 VA_FIXEDARG (ap, const char *, msgid);
2623 diagnostic_set_info (&diagnostic, msgid, &ap,
2624 cp_file_of (here), cp_line_of (here), DK_ERROR);
2625 report_diagnostic (&diagnostic);
2630 cp_warning_at VPARAMS ((const char *msgid, ...))
2633 diagnostic_info diagnostic;
2635 VA_OPEN (ap, msgid);
2636 VA_FIXEDARG (ap, const char *, msgid);
2637 here = locate_error (msgid, ap);
2640 VA_OPEN (ap, msgid);
2641 VA_FIXEDARG (ap, const char *, msgid);
2643 diagnostic_set_info (&diagnostic, msgid, &ap,
2644 cp_file_of (here), cp_line_of (here), DK_WARNING);
2645 report_diagnostic (&diagnostic);
2650 cp_pedwarn_at VPARAMS ((const char *msgid, ...))
2653 diagnostic_info diagnostic;
2655 VA_OPEN (ap, msgid);
2656 VA_FIXEDARG (ap, const char *, msgid);
2657 here = locate_error (msgid, ap);
2660 VA_OPEN (ap, msgid);
2661 VA_FIXEDARG (ap, const char *, msgid);
2663 diagnostic_set_info (&diagnostic, msgid, &ap,
2664 cp_file_of (here), cp_line_of (here),
2665 pedantic_error_kind());
2666 report_diagnostic (&diagnostic);