This code is non-reentrant.
Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002
Free Software Foundation, Inc.
- This file is part of GNU CC.
+ This file is part of GCC.
-GNU CC is free software; you can redistribute it and/or modify
+GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
-GNU CC is distributed in the hope that it will be useful,
+GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GNU CC; see the file COPYING. If not, write to
+along with GCC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include "config.h"
#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
#include "tree.h"
#include "cp-tree.h"
#include "real.h"
-#include "obstack.h"
#include "toplev.h"
#include "flags.h"
#include "diagnostic.h"
print_non_consecutive_character ((BUFFER), '<')
#define print_template_argument_list_end(BUFFER) \
print_non_consecutive_character ((BUFFER), '>')
-#define print_whitespace(BUFFER, TFI) \
- do { \
- output_add_space (BUFFER); \
- put_whitespace (TFI) = none; \
- } while (0)
#define print_tree_identifier(BUFFER, TID) \
output_add_string ((BUFFER), IDENTIFIER_POINTER (TID))
#define print_identifier(BUFFER, ID) output_add_string ((BUFFER), (ID))
#define reinit_global_formatting_buffer() \
output_clear_message_text (scratch_buffer)
-static const char *args_to_string PARAMS ((tree, int));
-static const char *assop_to_string PARAMS ((enum tree_code, int));
-static const char *code_to_string PARAMS ((enum tree_code, int));
-static const char *cv_to_string PARAMS ((tree, int));
-static const char *decl_to_string PARAMS ((tree, int));
-static const char *expr_to_string PARAMS ((tree, int));
-static const char *fndecl_to_string PARAMS ((tree, int));
-static const char *op_to_string PARAMS ((enum tree_code, int));
-static const char *parm_to_string PARAMS ((int, int));
-static const char *type_to_string PARAMS ((tree, int));
-
-static void dump_type PARAMS ((tree, int));
-static void dump_typename PARAMS ((tree, int));
-static void dump_simple_decl PARAMS ((tree, tree, int));
-static void dump_decl PARAMS ((tree, int));
-static void dump_template_decl PARAMS ((tree, int));
-static void dump_function_decl PARAMS ((tree, int));
-static void dump_expr PARAMS ((tree, int));
-static void dump_unary_op PARAMS ((const char *, tree, int));
-static void dump_binary_op PARAMS ((const char *, tree, int));
-static void dump_aggr_type PARAMS ((tree, int));
-static enum pad dump_type_prefix PARAMS ((tree, int));
-static void dump_type_suffix PARAMS ((tree, int));
-static void dump_function_name PARAMS ((tree, int));
-static void dump_expr_list PARAMS ((tree, int));
-static void dump_global_iord PARAMS ((tree));
-static enum pad dump_qualifiers PARAMS ((tree, enum pad));
-static void dump_char PARAMS ((int));
-static void dump_parameters PARAMS ((tree, int));
-static void dump_exception_spec PARAMS ((tree, int));
-static const char *class_key_or_enum PARAMS ((tree));
-static void dump_template_argument PARAMS ((tree, int));
-static void dump_template_argument_list PARAMS ((tree, int));
-static void dump_template_parameter PARAMS ((tree, int));
-static void dump_template_bindings PARAMS ((tree, tree));
-static void dump_scope PARAMS ((tree, int));
-static void dump_template_parms PARAMS ((tree, int, int));
-
-static const char *function_category PARAMS ((tree));
-static void maybe_print_instantiation_context PARAMS ((diagnostic_context *));
-static void print_instantiation_full_context PARAMS ((diagnostic_context *));
-static void print_instantiation_partial_context PARAMS ((diagnostic_context *,
- tree,
- const char *, int));
-static void cp_diagnostic_starter PARAMS ((diagnostic_context *,
- diagnostic_info *));
-static void cp_diagnostic_finalizer PARAMS ((diagnostic_context *,
- diagnostic_info *));
-static void cp_print_error_function PARAMS ((diagnostic_context *,
- diagnostic_info *));
-
-static bool cp_printer PARAMS ((output_buffer *, text_info *));
-static void print_non_consecutive_character PARAMS ((output_buffer *, int));
-static void print_integer PARAMS ((output_buffer *, HOST_WIDE_INT));
-static tree locate_error PARAMS ((const char *, va_list));
+static const char *args_to_string (tree, int);
+static const char *assop_to_string (enum tree_code, int);
+static const char *code_to_string (enum tree_code, int);
+static const char *cv_to_string (tree, int);
+static const char *decl_to_string (tree, int);
+static const char *expr_to_string (tree, int);
+static const char *fndecl_to_string (tree, int);
+static const char *op_to_string (enum tree_code, int);
+static const char *parm_to_string (int, int);
+static const char *type_to_string (tree, int);
+
+static void dump_type (tree, int);
+static void dump_typename (tree, int);
+static void dump_simple_decl (tree, tree, int);
+static void dump_decl (tree, int);
+static void dump_template_decl (tree, int);
+static void dump_function_decl (tree, int);
+static void dump_expr (tree, int);
+static void dump_unary_op (const char *, tree, int);
+static void dump_binary_op (const char *, tree, int);
+static void dump_aggr_type (tree, int);
+static enum pad dump_type_prefix (tree, int);
+static void dump_type_suffix (tree, int);
+static void dump_function_name (tree, int);
+static void dump_expr_list (tree, int);
+static void dump_global_iord (tree);
+static enum pad dump_qualifiers (tree, enum pad);
+static void dump_char (int);
+static void dump_parameters (tree, int);
+static void dump_exception_spec (tree, int);
+static const char *class_key_or_enum (tree);
+static void dump_template_argument (tree, int);
+static void dump_template_argument_list (tree, int);
+static void dump_template_parameter (tree, int);
+static void dump_template_bindings (tree, tree);
+static void dump_scope (tree, int);
+static void dump_template_parms (tree, int, int);
+
+static const char *function_category (tree);
+static void maybe_print_instantiation_context (diagnostic_context *);
+static void print_instantiation_full_context (diagnostic_context *);
+static void print_instantiation_partial_context (diagnostic_context *,
+ tree, const char *, int);
+static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
+static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
+static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
+
+static bool cp_printer (output_buffer *, text_info *);
+static void print_non_consecutive_character (output_buffer *, int);
+static void print_integer (output_buffer *, HOST_WIDE_INT);
+static tree locate_error (const char *, va_list);
void
-init_error ()
+init_error (void)
{
diagnostic_starter (global_dc) = cp_diagnostic_starter;
diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer;
/* Dump a scope, if deemed necessary. */
static void
-dump_scope (scope, flags)
- tree scope;
- int flags;
+dump_scope (tree scope, int flags)
{
int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF));
indication of whether we dumped something. */
static enum pad
-dump_qualifiers (t, p)
- tree t;
- enum pad p;
+dump_qualifiers (tree t, enum pad p)
{
static const int masks[] =
{TYPE_QUAL_CONST, TYPE_QUAL_VOLATILE, TYPE_QUAL_RESTRICT};
/* Dump the template ARGument under control of FLAGS. */
static void
-dump_template_argument (arg, flags)
- tree arg;
- int flags;
+dump_template_argument (tree arg, int flags)
{
if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
of FLAGS. */
static void
-dump_template_argument_list (args, flags)
- tree args;
- int flags;
+dump_template_argument_list (tree args, int flags)
{
int n = TREE_VEC_LENGTH (args);
int need_comma = 0;
/* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
static void
-dump_template_parameter (parm, flags)
- tree parm;
- int flags;
+dump_template_parameter (tree parm, int flags)
{
tree p = TREE_VALUE (parm);
tree a = TREE_PURPOSE (parm);
TREE_VEC. */
static void
-dump_template_bindings (parms, args)
- tree parms, args;
+dump_template_bindings (tree parms, tree args)
{
int need_comma = 0;
}
}
-/* Dump into the obstack a human-readable equivalent of TYPE. FLAGS
- controls the format. */
+/* Dump a human-readable equivalent of TYPE. FLAGS controls the
+ format. */
static void
-dump_type (t, flags)
- tree t;
- int flags;
+dump_type (tree t, int flags)
{
if (t == NULL_TREE)
return;
break;
case TEMPLATE_TEMPLATE_PARM:
- /* For parameters inside template signature. */
+ /* For parameters inside template signature. */
if (TYPE_IDENTIFIER (t))
print_tree_identifier (scratch_buffer, TYPE_IDENTIFIER (t));
else
break;
}
case TYPENAME_TYPE:
- if (!IMPLICIT_TYPENAME_P (t))
- output_add_string (scratch_buffer, "typename ");
+ dump_qualifiers (t, after);
+ output_add_string (scratch_buffer, "typename ");
dump_typename (t, flags);
break;
default:
sorry_for_unsupported_tree (t);
- /* Fall through to error. */
+ /* Fall through to error. */
case ERROR_MARK:
print_identifier (scratch_buffer, "<type error>");
a TYPENAME_TYPE. */
static void
-dump_typename (t, flags)
- tree t;
- int flags;
+dump_typename (tree t, int flags)
{
tree ctx = TYPE_CONTEXT (t);
/* Return the name of the supplied aggregate, or enumeral type. */
static const char *
-class_key_or_enum (t)
- tree t;
+class_key_or_enum (tree t)
{
if (TREE_CODE (t) == ENUMERAL_TYPE)
return "enum";
in the form `class foo'. */
static void
-dump_aggr_type (t, flags)
- tree t;
- int flags;
+dump_aggr_type (tree t, int flags)
{
tree name;
const char *variety = class_key_or_enum (t);
want to pad non-*, non-& cores, but not pad * or & types. */
static enum pad
-dump_type_prefix (t, flags)
- tree t;
- int flags;
+dump_type_prefix (tree t, int flags)
{
enum pad padding = before;
case TYPENAME_TYPE:
case COMPLEX_TYPE:
case VECTOR_TYPE:
+ case TYPEOF_TYPE:
dump_type (t, flags);
padding = before;
break;
which appears after the identifier (or function parms). */
static void
-dump_type_suffix (t, flags)
- tree t;
- int flags;
+dump_type_suffix (tree t, int flags)
{
if (TYPE_PTRMEMFUNC_P (t))
t = TYPE_PTRMEMFUNC_FN_TYPE (t);
case TYPENAME_TYPE:
case COMPLEX_TYPE:
case VECTOR_TYPE:
+ case TYPEOF_TYPE:
break;
default:
}
static void
-dump_global_iord (t)
- tree t;
+dump_global_iord (tree t)
{
const char *p = NULL;
}
static void
-dump_simple_decl (t, type, flags)
- tree t;
- tree type;
- int flags;
+dump_simple_decl (tree t, tree type, int flags)
{
if (flags & TFF_DECL_SPECIFIERS)
{
/* Dump a human readable string for the decl T under control of FLAGS. */
static void
-dump_decl (t, flags)
- tree t;
- int flags;
+dump_decl (tree t, int flags)
{
if (t == NULL_TREE)
return;
{
if ((flags & TFF_DECL_SPECIFIERS)
&& TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
- /* Say `class T' not just `T'. */
+ /* Say `class T' not just `T'. */
output_add_string (scratch_buffer, "class ");
dump_type (TREE_TYPE (t), flags);
break;
case OVERLOAD:
+ if (OVL_CHAIN (t))
+ {
+ t = OVL_CURRENT (t);
+ if (DECL_CLASS_SCOPE_P (t))
+ {
+ dump_type (DECL_CONTEXT (t), flags);
+ output_add_string (scratch_buffer, "::");
+ }
+ else if (DECL_CONTEXT (t))
+ {
+ dump_decl (DECL_CONTEXT (t), flags);
+ output_add_string (scratch_buffer, "::");
+ }
+ dump_decl (DECL_NAME (t), flags);
+ break;
+ }
+
+ /* If there's only one function, just treat it like an ordinary
+ FUNCTION_DECL. */
t = OVL_CURRENT (t);
/* Fall through. */
print_tree_identifier (scratch_buffer, DECL_NAME (t));
break;
+ case BASELINK:
+ dump_decl (BASELINK_FUNCTIONS (t), flags);
+ break;
+
default:
sorry_for_unsupported_tree (t);
/* Fallthrough to error. */
'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
static void
-dump_template_decl (t, flags)
- tree t;
- int flags;
+dump_template_decl (tree t, int flags)
{
tree orig_parms = DECL_TEMPLATE_PARMS (t);
tree parms;
nreverse(orig_parms);
if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
- /* Say `template<arg> class TT' not just `template<arg> TT'. */
+ /* Say `template<arg> class TT' not just `template<arg> TT'. */
output_add_string (scratch_buffer, "class ");
}
dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
break;
default:
- /* This case can occur with some illegal code. */
+ /* This case can occur with some invalid code. */
dump_type (TREE_TYPE (t),
(flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
| (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0));
/* Pretty print a function decl. There are several ways we want to print a
function declaration. The TFF_ bits in FLAGS tells us how to behave.
As error can only apply the '#' flag once to give 0 and 1 for V, there
- is %D which doesn't print the throw specs, and %F which does. */
+ is %D which doesn't print the throw specs, and %F which does. */
static void
-dump_function_decl (t, flags)
- tree t;
- int flags;
+dump_function_decl (tree t, int flags)
{
tree fntype;
tree parmtypes;
/* Print a parameter list. If this is for a member function, the
member object ptr (and any other hidden args) should have
- already been removed. */
+ already been removed. */
static void
-dump_parameters (parmtypes, flags)
- tree parmtypes;
- int flags;
+dump_parameters (tree parmtypes, int flags)
{
int first;
print_right_paren (scratch_buffer);
}
-/* Print an exception specification. T is the exception specification. */
+/* Print an exception specification. T is the exception specification. */
static void
-dump_exception_spec (t, flags)
- tree t;
- int flags;
+dump_exception_spec (tree t, int flags)
{
if (t)
{
and destructors properly. */
static void
-dump_function_name (t, flags)
- tree t;
- int flags;
+dump_function_name (tree t, int flags)
{
tree name = DECL_NAME (t);
decoration. */
static void
-dump_template_parms (info, primary, flags)
- tree info;
- int primary;
- int flags;
+dump_template_parms (tree info, int primary, int flags)
{
tree args = info ? TI_ARGS (info) : NULL_TREE;
}
static void
-dump_char (c)
- int c;
+dump_char (int c)
{
switch (c)
{
/* Print out a list of initializers (subr of dump_expr) */
static void
-dump_expr_list (l, flags)
- tree l;
- int flags;
+dump_expr_list (tree l, int flags)
{
while (l)
{
}
}
-/* Print out an expression E under control of FLAGS. */
+/* Print out an expression E under control of FLAGS. */
static void
-dump_expr (t, flags)
- tree t;
- int flags;
+dump_expr (tree t, int flags)
{
+ if (t == 0)
+ return;
+
switch (TREE_CODE (t))
{
case VAR_DECL:
case TEMPLATE_DECL:
case NAMESPACE_DECL:
case OVERLOAD:
+ case IDENTIFIER_NODE:
dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
break;
else if (type == char_type_node)
{
output_add_character (scratch_buffer, '\'');
- dump_char (tree_low_cst (t, 0));
+ if (host_integerp (t, TREE_UNSIGNED (type)))
+ dump_char (tree_low_cst (t, TREE_UNSIGNED (type)));
+ else
+ output_printf (scratch_buffer, "\\x%x",
+ (unsigned int) TREE_INT_CST_LOW (t));
output_add_character (scratch_buffer, '\'');
}
else
break;
case REAL_CST:
- {
- const unsigned char *p = (const unsigned char *) &TREE_REAL_CST (t);
- size_t i;
- strcpy (digit_buffer, "0x");
- for (i = 0; i < sizeof TREE_REAL_CST (t); i++)
- sprintf (digit_buffer + 2 + 2*i, "%02x", *p++);
- }
+ real_to_decimal (digit_buffer, &TREE_REAL_CST (t),
+ sizeof (digit_buffer), 0, 1);
output_add_string (scratch_buffer, digit_buffer);
break;
case CONSTRUCTOR:
if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
{
- tree idx = build_component_ref (t, pfn_identifier, NULL_TREE, 0);
+ tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
if (integer_zerop (idx))
{
dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
break;
- case IDENTIFIER_NODE:
- print_tree_identifier (scratch_buffer, t);
- break;
-
case SCOPE_REF:
dump_type (TREE_OPERAND (t, 0), flags);
print_scope_operator (scratch_buffer);
output_add_string (scratch_buffer, ") break; ");
break;
- case TREE_LIST:
- if (TREE_VALUE (t) && TREE_CODE (TREE_VALUE (t)) == FUNCTION_DECL)
- {
- print_tree_identifier (scratch_buffer, DECL_NAME (TREE_VALUE (t)));
- break;
- }
+ case BASELINK:
+ print_tree_identifier (scratch_buffer, DECL_NAME (get_first_fn (t)));
+ break;
+
/* else fall through */
/* This list is incomplete, but should suffice for now.
}
static void
-dump_binary_op (opstring, t, flags)
- const char *opstring;
- tree t;
- int flags;
+dump_binary_op (const char *opstring, tree t, int flags)
{
print_left_paren (scratch_buffer);
dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
}
static void
-dump_unary_op (opstring, t, flags)
- const char *opstring;
- tree t;
- int flags;
+dump_unary_op (const char *opstring, tree t, int flags)
{
if (flags & TFF_EXPR_IN_PARENS)
print_left_paren (scratch_buffer);
control. */
const char *
-type_as_string (typ, flags)
- tree typ;
- int flags;
+type_as_string (tree typ, int flags)
{
reinit_global_formatting_buffer ();
}
const char *
-expr_as_string (decl, flags)
- tree decl;
- int flags;
+expr_as_string (tree decl, int flags)
{
reinit_global_formatting_buffer ();
}
const char *
-decl_as_string (decl, flags)
- tree decl;
- int flags;
+decl_as_string (tree decl, int flags)
{
reinit_global_formatting_buffer ();
}
const char *
-context_as_string (context, flags)
- tree context;
- int flags;
+context_as_string (tree context, int flags)
{
reinit_global_formatting_buffer ();
/* Generate the three forms of printable names for cxx_printable_name. */
const char *
-lang_decl_name (decl, v)
- tree decl;
- int v;
+lang_decl_name (tree decl, int v)
{
if (v >= 2)
return decl_as_string (decl, TFF_DECL_SPECIFIERS);
}
const char *
-cp_file_of (t)
- tree t;
+cp_file_of (tree t)
{
if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
return DECL_SOURCE_FILE (DECL_CONTEXT (t));
}
int
-cp_line_of (t)
- tree t;
+cp_line_of (tree t)
{
int line = 0;
if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
function. */
static const char *
-decl_to_string (decl, verbose)
- tree decl;
- int verbose;
+decl_to_string (tree decl, int verbose)
{
int flags = 0;
}
static const char *
-expr_to_string (decl, verbose)
- tree decl;
- int verbose ATTRIBUTE_UNUSED;
+expr_to_string (tree decl, int verbose ATTRIBUTE_UNUSED)
{
reinit_global_formatting_buffer ();
}
static const char *
-fndecl_to_string (fndecl, verbose)
- tree fndecl;
- int verbose;
+fndecl_to_string (tree fndecl, int verbose)
{
int flags;
static const char *
-code_to_string (c, v)
- enum tree_code c;
- int v ATTRIBUTE_UNUSED;
+code_to_string (enum tree_code c, int v ATTRIBUTE_UNUSED)
{
return tree_code_name [c];
}
const char *
-language_to_string (c, v)
- enum languages c;
- int v ATTRIBUTE_UNUSED;
+language_to_string (enum languages c, int v ATTRIBUTE_UNUSED)
{
switch (c)
{
/* Return the proper printed version of a parameter to a C++ function. */
static const char *
-parm_to_string (p, v)
- int p;
- int v ATTRIBUTE_UNUSED;
+parm_to_string (int p, int v ATTRIBUTE_UNUSED)
{
if (p < 0)
return "`this'";
}
static const char *
-op_to_string (p, v)
- enum tree_code p;
- int v ATTRIBUTE_UNUSED;
+op_to_string (enum tree_code p, int v ATTRIBUTE_UNUSED)
{
tree id;
}
static const char *
-type_to_string (typ, verbose)
- tree typ;
- int verbose;
+type_to_string (tree typ, int verbose)
{
int flags;
}
static const char *
-assop_to_string (p, v)
- enum tree_code p;
- int v ATTRIBUTE_UNUSED;
+assop_to_string (enum tree_code p, int v ATTRIBUTE_UNUSED)
{
tree id;
}
static const char *
-args_to_string (p, verbose)
- tree p;
- int verbose;
+args_to_string (tree p, int verbose)
{
int flags = 0;
if (verbose)
}
static const char *
-cv_to_string (p, v)
- tree p;
- int v;
+cv_to_string (tree p, int v)
{
reinit_global_formatting_buffer ();
/* Langhook for print_error_function. */
void
-cxx_print_error_function (context, file)
- diagnostic_context *context;
- const char *file;
+cxx_print_error_function (diagnostic_context *context, const char *file)
{
lhd_print_error_function (context, file);
output_set_prefix (&context->buffer, file);
}
static void
-cp_diagnostic_starter (context, diagnostic)
- diagnostic_context *context;
- diagnostic_info *diagnostic;
+cp_diagnostic_starter (diagnostic_context *context,
+ diagnostic_info *diagnostic)
{
diagnostic_report_current_module (context);
cp_print_error_function (context, diagnostic);
}
static void
-cp_diagnostic_finalizer (context, diagnostic)
- diagnostic_context *context;
- diagnostic_info *diagnostic __attribute__((unused));
+cp_diagnostic_finalizer (diagnostic_context *context,
+ diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
{
output_destroy_prefix (&context->buffer);
}
/* Print current function onto BUFFER, in the process of reporting
a diagnostic message. Called from cp_diagnostic_starter. */
static void
-cp_print_error_function (context, diagnostic)
- diagnostic_context *context;
- diagnostic_info *diagnostic;
+cp_print_error_function (diagnostic_context *context,
+ diagnostic_info *diagnostic)
{
if (diagnostic_last_function_changed (context))
{
/* Returns a description of FUNCTION using standard terminology. */
static const char *
-function_category (fn)
- tree fn;
+function_category (tree fn)
{
if (DECL_FUNCTION_MEMBER_P (fn))
{
/* Report the full context of a current template instantiation,
onto BUFFER. */
static void
-print_instantiation_full_context (context)
- diagnostic_context *context;
+print_instantiation_full_context (diagnostic_context *context)
{
tree p = current_instantiation ();
int line = lineno;
/* Same as above but less verbose. */
static void
-print_instantiation_partial_context (context, t, file, line)
- diagnostic_context *context;
- tree t;
- const char *file;
- int line;
+print_instantiation_partial_context (diagnostic_context *context,
+ tree t, const char *file, int line)
{
for (; t; t = TREE_CHAIN (t))
{
/* Called from cp_thing to print the template context for an error. */
static void
-maybe_print_instantiation_context (context)
- diagnostic_context *context;
+maybe_print_instantiation_context (diagnostic_context *context)
{
if (!problematic_instantiation_changed () || current_instantiation () == 0)
return;
/* Report the bare minimum context of a template instantiation. */
void
-print_instantiation_context ()
+print_instantiation_context (void)
{
print_instantiation_partial_context
(global_dc, current_instantiation (), input_filename, lineno);
%T type.
%V cv-qualifier. */
static bool
-cp_printer (buffer, text)
- output_buffer *buffer;
- text_info *text;
+cp_printer (output_buffer *buffer, text_info *text)
{
int verbose = 0;
const char *result;
}
static void
-print_integer (buffer, i)
- output_buffer *buffer;
- HOST_WIDE_INT i;
+print_integer (output_buffer *buffer, HOST_WIDE_INT i)
{
sprintf (digit_buffer, HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT) i);
output_add_string (buffer, digit_buffer);
}
static void
-print_non_consecutive_character (buffer, c)
- output_buffer *buffer;
- int c;
+print_non_consecutive_character (output_buffer *buffer, int c)
{
const char *p = output_last_position (buffer);
behavior of cp_*_at. */
static tree
-locate_error (msgid, ap)
- const char *msgid;
- va_list ap;
+locate_error (const char *msgid, va_list ap)
{
tree here = 0, t;
int plus = 0;
OSDN Git Service
