-/* Language-independent diagnostic subroutines for the GNU C compiler
- Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
+/* Language-independent diagnostic subroutines for the GNU Compiler Collection
+ Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
Contributed by Gabriel Dos Reis <gdr@codesourcery.com>
-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
-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.
+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,
-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.
+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
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+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. */
/* This file implements the language independent aspect of diagnostic
#undef FLOAT /* This is for hpux. They should change hpux. */
#undef FFS /* Some systems define this in param.h. */
#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
#include "tree.h"
#include "tm_p.h"
#include "flags.h"
#include "toplev.h"
#include "intl.h"
#include "diagnostic.h"
-
-#define obstack_chunk_alloc xmalloc
-#define obstack_chunk_free free
-
-#define output_formatted_integer(BUFFER, FORMAT, INTEGER) \
- do { \
- sprintf ((BUFFER)->digit_buffer, FORMAT, INTEGER); \
- output_add_string (BUFFER, (BUFFER)->digit_buffer); \
- } while (0)
+#include "langhooks.h"
+#include "langhooks-def.h"
#define output_text_length(BUFFER) (BUFFER)->line_length
#define is_starting_newline(BUFFER) (output_text_length (BUFFER) == 0)
-#define output_prefix(BUFFER) (BUFFER)->state.prefix
#define line_wrap_cutoff(BUFFER) (BUFFER)->state.maximum_length
#define prefix_was_emitted_for(BUFFER) (BUFFER)->state.emitted_prefix_p
-#define output_buffer_ptr_to_format_args(BUFFER) (BUFFER)->state.format_args
-
-#define diagnostic_args output_buffer_ptr_to_format_args (diagnostic_buffer)
-#define diagnostic_msg output_buffer_text_cursor (diagnostic_buffer)
/* Prototypes. */
-static void diagnostic_finish PARAMS ((output_buffer *));
-static void output_do_verbatim PARAMS ((output_buffer *,
- const char *, va_list *));
+static void output_flush PARAMS ((output_buffer *));
+static void output_do_verbatim PARAMS ((output_buffer *, text_info *));
static void output_buffer_to_stream PARAMS ((output_buffer *));
-static void output_format PARAMS ((output_buffer *));
+static void output_format PARAMS ((output_buffer *, text_info *));
static void output_indent PARAMS ((output_buffer *));
static char *vbuild_message_string PARAMS ((const char *, va_list))
ATTRIBUTE_PRINTF (1, 0);
static char *build_message_string PARAMS ((const char *, ...))
ATTRIBUTE_PRINTF_1;
-static void output_do_printf PARAMS ((output_buffer *, const char *))
- ATTRIBUTE_PRINTF (2, 0);
-static void format_with_decl PARAMS ((output_buffer *, tree));
-static void diagnostic_for_decl PARAMS ((tree, const char *, va_list *, int));
+static void format_with_decl PARAMS ((output_buffer *, text_info *, tree));
+static void diagnostic_for_decl PARAMS ((diagnostic_info *, tree));
static void set_real_maximum_length PARAMS ((output_buffer *));
static void output_unsigned_decimal PARAMS ((output_buffer *, unsigned int));
static void output_long_decimal PARAMS ((output_buffer *, long int));
static void output_long_unsigned_decimal PARAMS ((output_buffer *,
- long unsigned int));
+ long unsigned int));
static void output_octal PARAMS ((output_buffer *, unsigned int));
static void output_long_octal PARAMS ((output_buffer *, unsigned long int));
static void output_hexadecimal PARAMS ((output_buffer *, unsigned int));
static void output_long_hexadecimal PARAMS ((output_buffer *,
- unsigned long int));
+ unsigned long int));
static void output_append_r PARAMS ((output_buffer *, const char *, int));
static void wrap_text PARAMS ((output_buffer *, const char *, const char *));
static void maybe_wrap_text PARAMS ((output_buffer *, const char *,
- const char *));
-static void clear_diagnostic_info PARAMS ((output_buffer *));
+ const char *));
+static void output_clear_data PARAMS ((output_buffer *));
-static void default_diagnostic_starter PARAMS ((output_buffer *,
- diagnostic_context *));
-static void default_diagnostic_finalizer PARAMS ((output_buffer *,
- diagnostic_context *));
+static void default_diagnostic_starter PARAMS ((diagnostic_context *,
+ diagnostic_info *));
+static void default_diagnostic_finalizer PARAMS ((diagnostic_context *,
+ diagnostic_info *));
-static void error_recursion PARAMS ((void)) ATTRIBUTE_NORETURN;
+static void error_recursion PARAMS ((diagnostic_context *)) ATTRIBUTE_NORETURN;
+static bool text_specifies_location PARAMS ((text_info *, location_t *));
extern int rtl_dump_and_exit;
extern int warnings_are_errors;
static diagnostic_context global_diagnostic_context;
diagnostic_context *global_dc = &global_diagnostic_context;
-/* This will be removed shortly. */
-output_buffer *diagnostic_buffer = &global_diagnostic_context.buffer;
-
-/* Function of last error message;
- more generally, function such that if next error message is in it
- then we don't have to mention the function name. */
-static tree last_error_function = NULL;
-
-/* Used to detect when input_file_stack has changed since last described. */
-static int last_error_tick;
-
-/* Called by report_error_function to print out function name.
- Default may be overridden by language front-ends. */
-
-void (*print_error_function) PARAMS ((diagnostic_context *, const char *))
- = default_print_error_function;
-
-/* Prevent recursion into the error handler. */
-static int diagnostic_lock;
-
\f
-/* Return truthvalue if current input file is different from the most recent
- file involved in a diagnostic message. */
-
-int
-error_module_changed ()
-{
- return last_error_tick != input_file_stack_tick;
-}
-
-/* Remember current file as being the most recent file involved in a
- diagnostic message. */
-
-void
-record_last_error_module ()
-{
- last_error_tick = input_file_stack_tick;
-}
-
-/* Same as error_module_changed, but for function. */
-
-int
-error_function_changed ()
-{
- return last_error_function != current_function_decl;
-}
-
-/* Same as record_last_error_module, but for function. */
-
-void
-record_last_error_function ()
-{
- last_error_function = current_function_decl;
-}
-
-/* Initialize the diagnostic message outputting machinery. */
-
-void
-diagnostic_initialize (context)
- diagnostic_context *context;
-{
- memset (context, 0, sizeof *context);
- obstack_init (&context->buffer.obstack);
-
- /* By default, diagnostics are sent to stderr. */
- output_buffer_attached_stream (&context->buffer) = stderr;
-
- /* By default, we emit prefixes once per message. */
- diagnostic_prefixing_rule (context) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
-
- diagnostic_starter (context) = default_diagnostic_starter;
- diagnostic_finalizer (context) = default_diagnostic_finalizer;
-}
-
-/* Returns true if BUFFER is in line-wrappind mode. */
-
-int
-output_is_line_wrapping (buffer)
- output_buffer *buffer;
-{
- return diagnostic_line_cutoff (buffer) > 0;
-}
-
-/* Return BUFFER's prefix. */
-
-const char *
-output_get_prefix (buffer)
- const output_buffer *buffer;
-{
- return output_prefix (buffer);
-}
-
/* Subroutine of output_set_maximum_length. Set up BUFFER's
internal maximum characters per line. */
-
static void
set_real_maximum_length (buffer)
output_buffer *buffer;
{
/* If we're told not to wrap lines then do the obvious thing. In case
we'll emit prefix only once per diagnostic message, it is appropriate
- not to increase unncessarily the line-length cut-off. */
- if (! output_is_line_wrapping (buffer)
- || diagnostic_prefixing_rule (buffer) == DIAGNOSTICS_SHOW_PREFIX_ONCE
- || diagnostic_prefixing_rule (buffer) == DIAGNOSTICS_SHOW_PREFIX_NEVER)
- line_wrap_cutoff (buffer) = diagnostic_line_cutoff (buffer);
+ not to increase unnecessarily the line-length cut-off. */
+ if (!output_is_line_wrapping (buffer)
+ || output_prefixing_rule (buffer) == DIAGNOSTICS_SHOW_PREFIX_ONCE
+ || output_prefixing_rule (buffer) == DIAGNOSTICS_SHOW_PREFIX_NEVER)
+ line_wrap_cutoff (buffer) = output_line_cutoff (buffer);
else
{
- int prefix_length =
- output_prefix (buffer) ? strlen (output_prefix (buffer)) : 0;
+ int prefix_length = buffer->state.prefix ?
+ strlen (buffer->state.prefix) : 0;
/* If the prefix is ridiculously too long, output at least
32 characters. */
- if (diagnostic_line_cutoff (buffer) - prefix_length < 32)
- line_wrap_cutoff (buffer) = diagnostic_line_cutoff (buffer) + 32;
+ if (output_line_cutoff (buffer) - prefix_length < 32)
+ line_wrap_cutoff (buffer) = output_line_cutoff (buffer) + 32;
else
- line_wrap_cutoff (buffer) = diagnostic_line_cutoff (buffer);
+ line_wrap_cutoff (buffer) = output_line_cutoff (buffer);
}
}
/* Sets the number of maximum characters per line BUFFER can output
in line-wrapping mode. A LENGTH value 0 suppresses line-wrapping. */
-
void
output_set_maximum_length (buffer, length)
output_buffer *buffer;
int length;
{
- diagnostic_line_cutoff (buffer) = length;
+ output_line_cutoff (buffer) = length;
set_real_maximum_length (buffer);
}
/* Sets BUFFER's PREFIX. */
-
void
output_set_prefix (buffer, prefix)
output_buffer *buffer;
const char *prefix;
{
- output_prefix (buffer) = prefix;
+ buffer->state.prefix = prefix;
set_real_maximum_length (buffer);
- prefix_was_emitted_for (buffer) = 0;
+ prefix_was_emitted_for (buffer) = false;
output_indentation (buffer) = 0;
}
const output_buffer *buffer;
{
const char *p = NULL;
-
+
if (obstack_base (&buffer->obstack) != obstack_next_free (&buffer->obstack))
p = ((const char *) obstack_next_free (&buffer->obstack)) - 1;
return p;
}
/* Free BUFFER's prefix, a previously malloc'd string. */
-
void
output_destroy_prefix (buffer)
output_buffer *buffer;
{
- if (output_prefix (buffer) != NULL)
+ if (buffer->state.prefix != NULL)
{
- free ((char *) output_prefix (buffer));
- output_prefix (buffer) = NULL;
+ free ((char *) buffer->state.prefix);
+ buffer->state.prefix = NULL;
}
}
/* Zero out any text output so far in BUFFER. */
-
void
output_clear_message_text (buffer)
output_buffer *buffer;
output_text_length (buffer) = 0;
}
-/* Zero out any diagnostic data used so far by BUFFER. */
-
+/* Zero out any formatting data used so far by BUFFER. */
static void
-clear_diagnostic_info (buffer)
+output_clear_data (buffer)
output_buffer *buffer;
{
- output_buffer_text_cursor (buffer) = NULL;
- output_buffer_ptr_to_format_args (buffer) = NULL;
- prefix_was_emitted_for (buffer) = 0;
+ prefix_was_emitted_for (buffer) = false;
output_indentation (buffer) = 0;
}
/* Construct an output BUFFER with PREFIX and of MAXIMUM_LENGTH
characters per line. */
-
void
init_output_buffer (buffer, prefix, maximum_length)
output_buffer *buffer;
memset (buffer, 0, sizeof (output_buffer));
obstack_init (&buffer->obstack);
output_buffer_attached_stream (buffer) = stderr;
- diagnostic_line_cutoff (buffer) = maximum_length;
- diagnostic_prefixing_rule (buffer) = diagnostic_prefixing_rule (global_dc);
+ output_line_cutoff (buffer) = maximum_length;
+ output_prefixing_rule (buffer) = diagnostic_prefixing_rule (global_dc);
output_set_prefix (buffer, prefix);
output_text_length (buffer) = 0;
- clear_diagnostic_info (buffer);
+ output_clear_data (buffer);
}
/* Reinitialize BUFFER. */
-
void
output_clear (buffer)
output_buffer *buffer;
{
output_clear_message_text (buffer);
- clear_diagnostic_info (buffer);
+ output_clear_data (buffer);
}
/* Finishes constructing a NULL-terminated character string representing
the BUFFERed message. */
-
const char *
output_finalize_message (buffer)
output_buffer *buffer;
return output_message_text (buffer);
}
-void
-flush_diagnostic_buffer ()
-{
- output_buffer_to_stream (diagnostic_buffer);
- fflush (output_buffer_attached_stream (diagnostic_buffer));
-}
-
/* Return the amount of characters BUFFER can accept to
make a full line. */
-
int
output_space_left (buffer)
const output_buffer *buffer;
}
/* Write out BUFFER's prefix. */
-
void
output_emit_prefix (buffer)
output_buffer *buffer;
{
- if (output_prefix (buffer) != NULL)
+ if (buffer->state.prefix != NULL)
{
- switch (diagnostic_prefixing_rule (buffer))
- {
- default:
- case DIAGNOSTICS_SHOW_PREFIX_NEVER:
- break;
-
- case DIAGNOSTICS_SHOW_PREFIX_ONCE:
- if (prefix_was_emitted_for (buffer))
- {
- output_indent (buffer);
- break;
- }
- output_indentation (buffer) += 3;
- /* Fall through. */
-
- case DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE:
- {
- int prefix_length = strlen (output_prefix (buffer));
- output_append_r (buffer, output_prefix (buffer), prefix_length);
- prefix_was_emitted_for (buffer) = 1;
- }
- break;
- }
+ switch (output_prefixing_rule (buffer))
+ {
+ default:
+ case DIAGNOSTICS_SHOW_PREFIX_NEVER:
+ break;
+
+ case DIAGNOSTICS_SHOW_PREFIX_ONCE:
+ if (prefix_was_emitted_for (buffer))
+ {
+ output_indent (buffer);
+ break;
+ }
+ output_indentation (buffer) += 3;
+ /* Fall through. */
+
+ case DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE:
+ {
+ int prefix_length = strlen (buffer->state.prefix);
+ output_append_r (buffer, buffer->state.prefix, prefix_length);
+ prefix_was_emitted_for (buffer) = true;
+ }
+ break;
+ }
}
}
/* Have BUFFER start a new line. */
-
void
output_add_newline (buffer)
output_buffer *buffer;
}
/* Appends a character to BUFFER. */
-
void
output_add_character (buffer, c)
output_buffer *buffer;
}
/* Adds a space to BUFFER. */
-
void
output_add_space (buffer)
output_buffer *buffer;
/* These functions format an INTEGER into BUFFER as suggested by their
names. */
-
void
output_decimal (buffer, i)
output_buffer *buffer;
int i;
{
- output_formatted_integer (buffer, "%d", i);
+ output_formatted_scalar (buffer, "%d", i);
}
static void
output_buffer *buffer;
long int i;
{
- output_formatted_integer (buffer, "%ld", i);
+ output_formatted_scalar (buffer, "%ld", i);
}
static void
output_buffer *buffer;
unsigned int i;
{
- output_formatted_integer (buffer, "%u", i);
+ output_formatted_scalar (buffer, "%u", i);
}
static void
output_buffer *buffer;
long unsigned int i;
{
- output_formatted_integer (buffer, "%lu", i);
+ output_formatted_scalar (buffer, "%lu", i);
}
static void
output_buffer *buffer;
unsigned int i;
{
- output_formatted_integer (buffer, "%o", i);
+ output_formatted_scalar (buffer, "%o", i);
}
static void
output_buffer *buffer;
unsigned long int i;
{
- output_formatted_integer (buffer, "%lo", i);
+ output_formatted_scalar (buffer, "%lo", i);
}
static void
output_buffer *buffer;
unsigned int i;
{
- output_formatted_integer (buffer, "%x", i);
+ output_formatted_scalar (buffer, "%x", i);
}
static void
output_buffer *buffer;
unsigned long int i;
{
- output_formatted_integer (buffer, "%lx", i);
+ output_formatted_scalar (buffer, "%lx", i);
}
/* Append to BUFFER a string specified by its STARTING character
and LENGTH. */
-
static void
output_append_r (buffer, start, length)
output_buffer *buffer;
}
/* Append a string deliminated by START and END to BUFFER. No wrapping is
- done. However, if beginning a new line then emit output_prefix (BUFFER)
+ done. However, if beginning a new line then emit BUFFER->state.prefix
and skip any leading whitespace if appropriate. The caller must ensure
that it is safe to do so. */
-
void
output_append (buffer, start, end)
output_buffer *buffer;
{
output_emit_prefix (buffer);
if (output_is_line_wrapping (buffer))
- while (start != end && *start == ' ')
- ++start;
+ while (start != end && *start == ' ')
+ ++start;
}
output_append_r (buffer, start, end - start);
}
}
/* Wrap a text delimited by START and END into BUFFER. */
-
static void
wrap_text (buffer, start, end)
output_buffer *buffer;
const char *start;
const char *end;
{
- int is_wrapping = output_is_line_wrapping (buffer);
-
+ bool is_wrapping = output_is_line_wrapping (buffer);
+
while (start != end)
{
- /* Dump anything bodered by whitespaces. */
+ /* Dump anything bordered by whitespaces. */
{
- const char *p = start;
- while (p != end && *p != ' ' && *p != '\n')
- ++p;
- if (is_wrapping && p - start >= output_space_left (buffer))
- output_add_newline (buffer);
- output_append (buffer, start, p);
- start = p;
+ const char *p = start;
+ while (p != end && *p != ' ' && *p != '\n')
+ ++p;
+ if (is_wrapping && p - start >= output_space_left (buffer))
+ output_add_newline (buffer);
+ output_append (buffer, start, p);
+ start = p;
}
if (start != end && *start == ' ')
- {
- output_add_space (buffer);
- ++start;
- }
+ {
+ output_add_space (buffer);
+ ++start;
+ }
if (start != end && *start == '\n')
- {
- output_add_newline (buffer);
- ++start;
- }
+ {
+ output_add_newline (buffer);
+ ++start;
+ }
}
}
/* Same as wrap_text but wrap text only when in line-wrapping mode. */
-
static void
maybe_wrap_text (buffer, start, end)
output_buffer *buffer;
/* Append a STRING to BUFFER; the STRING might be line-wrapped if in
appropriate mode. */
-
void
output_add_string (buffer, str)
output_buffer *buffer;
maybe_wrap_text (buffer, str, str + (str ? strlen (str) : 0));
}
+/* Append an identifier ID to BUFFER. */
+void
+output_add_identifier (buffer, id)
+ output_buffer *buffer;
+ tree id;
+{
+ output_append (buffer, IDENTIFIER_POINTER (id),
+ IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id));
+}
+
/* Flush the content of BUFFER onto the attached stream,
and reinitialize. */
output_clear_message_text (buffer);
}
-/* Format a message pointed to by output_buffer_text_cursor (BUFFER) using
- output_buffer_format_args (BUFFER) as appropriate. The following format
- specifiers are recognized as being language independent:
+/* Format a message pointed to by TEXT. The following format specifiers are
+ recognized as being language independent:
%d, %i: (signed) integer in base ten.
%u: unsigned integer in base ten.
%o: unsigned integer in base eight.
%c: character.
%s: string.
%%: `%'.
- %*.s: a substring the length of which is specified by an integer. */
-
+ %*.s: a substring the length of which is specified by an integer.
+ %H: location_t. */
static void
-output_format (buffer)
+output_format (buffer, text)
output_buffer *buffer;
+ text_info *text;
{
- for (; *output_buffer_text_cursor (buffer);
- ++output_buffer_text_cursor (buffer))
+ for (; *text->format_spec; ++text->format_spec)
{
- int long_integer = 0;
+ bool long_integer = 0;
/* Ignore text. */
{
- const char *p = output_buffer_text_cursor (buffer);
- while (*p && *p != '%')
- ++p;
- wrap_text (buffer, output_buffer_text_cursor (buffer), p);
- output_buffer_text_cursor (buffer) = p;
+ const char *p = text->format_spec;
+ while (*p && *p != '%')
+ ++p;
+ wrap_text (buffer, text->format_spec, p);
+ text->format_spec = p;
}
- if (!*output_buffer_text_cursor (buffer))
- break;
+ if (*text->format_spec == '\0')
+ break;
/* We got a '%'. Let's see what happens. Record whether we're
parsing a long integer format specifier. */
- if (*++output_buffer_text_cursor (buffer) == 'l')
- {
- long_integer = 1;
- ++output_buffer_text_cursor (buffer);
- }
+ if (*++text->format_spec == 'l')
+ {
+ long_integer = true;
+ ++text->format_spec;
+ }
/* Handle %c, %d, %i, %ld, %li, %lo, %lu, %lx, %o, %s, %u,
%x, %.*s; %%. And nothing else. Front-ends should install
printers to grok language specific format specifiers. */
- switch (*output_buffer_text_cursor (buffer))
- {
- case 'c':
- output_add_character
- (buffer, va_arg (output_buffer_format_args (buffer), int));
- break;
-
- case 'd':
- case 'i':
- if (long_integer)
- output_long_decimal
- (buffer, va_arg (output_buffer_format_args (buffer), long int));
- else
- output_decimal
- (buffer, va_arg (output_buffer_format_args (buffer), int));
- break;
+ switch (*text->format_spec)
+ {
+ case 'c':
+ output_add_character (buffer, va_arg (*text->args_ptr, int));
+ break;
+
+ case 'd':
+ case 'i':
+ if (long_integer)
+ output_long_decimal (buffer, va_arg (*text->args_ptr, long int));
+ else
+ output_decimal (buffer, va_arg (*text->args_ptr, int));
+ break;
- case 'o':
- if (long_integer)
- output_long_octal (buffer,
- va_arg (output_buffer_format_args (buffer),
- unsigned long int));
- else
- output_octal (buffer,
- va_arg (output_buffer_format_args (buffer),
- unsigned int));
- break;
+ case 'o':
+ if (long_integer)
+ output_long_octal (buffer,
+ va_arg (*text->args_ptr, unsigned long int));
+ else
+ output_octal (buffer, va_arg (*text->args_ptr, unsigned int));
+ break;
- case 's':
- output_add_string (buffer,
- va_arg (output_buffer_format_args (buffer),
- const char *));
- break;
+ case 's':
+ output_add_string (buffer, va_arg (*text->args_ptr, const char *));
+ break;
- case 'u':
- if (long_integer)
- output_long_unsigned_decimal
- (buffer, va_arg (output_buffer_format_args (buffer),
- long unsigned int));
- else
- output_unsigned_decimal
- (buffer, va_arg (output_buffer_format_args (buffer),
- unsigned int));
- break;
-
- case 'x':
- if (long_integer)
- output_long_hexadecimal
- (buffer, va_arg (output_buffer_format_args (buffer),
- unsigned long int));
- else
- output_hexadecimal
- (buffer, va_arg (output_buffer_format_args (buffer),
- unsigned int));
- break;
+ case 'u':
+ if (long_integer)
+ output_long_unsigned_decimal
+ (buffer, va_arg (*text->args_ptr, long unsigned int));
+ else
+ output_unsigned_decimal
+ (buffer, va_arg (*text->args_ptr, unsigned int));
+ break;
+
+ case 'x':
+ if (long_integer)
+ output_long_hexadecimal
+ (buffer, va_arg (*text->args_ptr, unsigned long int));
+ else
+ output_hexadecimal
+ (buffer, va_arg (*text->args_ptr, unsigned int));
+ break;
- case '%':
- output_add_character (buffer, '%');
- break;
+ case '%':
+ output_add_character (buffer, '%');
+ break;
- case '.':
+ case 'H':
{
- int n;
- const char *s;
- /* We handle no precision specifier but `%.*s'. */
- if (*++output_buffer_text_cursor (buffer) != '*')
- abort ();
- else if (*++output_buffer_text_cursor (buffer) != 's')
- abort();
- n = va_arg (output_buffer_format_args (buffer), int);
- s = va_arg (output_buffer_format_args (buffer), const char *);
- output_append (buffer, s, s + n);
+ const location_t *locus = va_arg (*text->args_ptr, location_t *);
+ output_add_string (buffer, "file '");
+ output_add_string (buffer, locus->file);
+ output_add_string (buffer, "', line ");
+ output_decimal (buffer, locus->line);
}
break;
- default:
- if (!buffer->format_decoder || !(*buffer->format_decoder) (buffer))
- {
- /* Hmmm. The front-end failed to install a format translator
+ case '.':
+ {
+ int n;
+ const char *s;
+ /* We handle no precision specifier but `%.*s'. */
+ if (*++text->format_spec != '*')
+ abort ();
+ else if (*++text->format_spec != 's')
+ abort ();
+ n = va_arg (*text->args_ptr, int);
+ s = va_arg (*text->args_ptr, const char *);
+ output_append (buffer, s, s + n);
+ }
+ break;
+
+ default:
+ if (!buffer->format_decoder
+ || !(*buffer->format_decoder) (buffer, text))
+ {
+ /* Hmmm. The front-end failed to install a format translator
but called us with an unrecognized format. Sorry. */
- abort ();
- }
- }
+ abort ();
+ }
+ }
}
}
}
/* Return a malloc'd string containing MSG formatted a la
- printf. The caller is reponsible for freeing the memory. */
-
+ printf. The caller is responsible for freeing the memory. */
static char *
build_message_string VPARAMS ((const char *msg, ...))
{
-#ifndef ANSI_PROTOTYPES
- const char *msg;
-#endif
- va_list ap;
char *str;
- VA_START (ap, msg);
-
-#ifndef ANSI_PROTOTYPES
- msg = va_arg (ap, const char *);
-#endif
+ VA_OPEN (ap, msg);
+ VA_FIXEDARG (ap, const char *, msg);
str = vbuild_message_string (msg, ap);
- va_end (ap);
+ VA_CLOSE (ap);
return str;
}
-/* Return a malloc'd string describing a location. The caller is
- responsible for freeing the memory. */
-
-char *
-context_as_prefix (file, line, warn)
- const char *file;
- int line;
- int warn;
-{
- if (file)
- {
- if (warn)
- return build_message_string (_("%s:%d: warning: "), file, line);
- else
- return build_message_string ("%s:%d: ", file, line);
- }
- else
- {
- if (warn)
- return build_message_string (_("%s: warning: "), progname);
- else
- return build_message_string ("%s: ", progname);
- }
-}
-
-/* Same as context_as_prefix, but only the source FILE is given. */
-
+/* Same as diagnostic_build_prefix, but only the source FILE is given. */
char *
file_name_as_prefix (f)
const char *f;
return build_message_string ("%s: ", f);
}
-/* Format a MESSAGE into BUFFER. Automatically wrap lines. */
-
-static void
-output_do_printf (buffer, msg)
- output_buffer *buffer;
- const char *msg;
-{
- char *message = vbuild_message_string (msg,
- output_buffer_format_args (buffer));
-
- wrap_text (buffer, message, message + strlen (message));
- free (message);
-}
-
-
/* Format a message into BUFFER a la printf. */
-
void
output_printf VPARAMS ((struct output_buffer *buffer, const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- struct output_buffer *buffer;
- const char *msgid;
-#endif
- va_list ap;
- va_list *old_args;
+ text_info text;
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, output_buffer *, buffer);
+ VA_FIXEDARG (ap, const char *, msgid);
- VA_START (ap, msgid);
-#ifndef ANSI_PROTOTYPES
- buffer = va_arg (ap, output_buffer *);
- msgid = va_arg (ap, const char *);
-#endif
- old_args = output_buffer_ptr_to_format_args (buffer);
- output_buffer_ptr_to_format_args (buffer) = ≈
- output_do_printf (buffer, _(msgid));
- output_buffer_ptr_to_format_args (buffer) = old_args;
- va_end (ap);
+ text.args_ptr = ≈
+ text.format_spec = _(msgid);
+ output_format (buffer, &text);
+ VA_CLOSE (ap);
}
/* Print a message relevant to the given DECL. */
-
static void
-format_with_decl (buffer, decl)
+format_with_decl (buffer, text, decl)
output_buffer *buffer;
+ text_info *text;
tree decl;
{
const char *p;
-
+
/* Do magic to get around lack of varargs support for insertion
of arguments into existing list. We know that the decl is first;
we ass_u_me that it will be printed with "%s". */
- for (p = output_buffer_text_cursor (buffer); *p; ++p)
+ for (p = text->format_spec; *p; ++p)
{
if (*p == '%')
{
}
/* Print the left-hand substring. */
- maybe_wrap_text (buffer, output_buffer_text_cursor (buffer), p);
-
+ maybe_wrap_text (buffer, text->format_spec, p);
+
if (*p == '%') /* Print the name. */
{
- const char *n = (DECL_NAME (decl)
- ? (*decl_printable_name) (decl, 2)
- : _("((anonymous))"));
+ const char *const n = (DECL_NAME (decl)
+ ? (*lang_hooks.decl_printable_name) (decl, 2)
+ : _("((anonymous))"));
output_add_string (buffer, n);
while (*p)
{
if (*p) /* Print the rest of the message. */
{
- output_buffer_text_cursor (buffer) = p;
- output_format (buffer);
+ text->format_spec = p;
+ output_format (buffer, text);
+ }
+}
+
+/* Flush the content of BUFFER onto the attached stream. */
+static void
+output_flush (buffer)
+ output_buffer *buffer;
+{
+ output_buffer_to_stream (buffer);
+ output_clear_data (buffer);
+ fputc ('\n', output_buffer_attached_stream (buffer));
+ fflush (output_buffer_attached_stream (buffer));
+}
+
+/* Helper subroutine of output_verbatim and verbatim. Do the appropriate
+ settings needed by BUFFER for a verbatim formatting. */
+static void
+output_do_verbatim (buffer, text)
+ output_buffer *buffer;
+ text_info *text;
+{
+ diagnostic_prefixing_rule_t rule = output_prefixing_rule (buffer);
+ int line_cutoff = output_line_cutoff (buffer);
+
+ /* Set verbatim mode. */
+ output_prefixing_rule (buffer) = DIAGNOSTICS_SHOW_PREFIX_NEVER;
+ output_line_cutoff (buffer) = 0;
+ /* Do the actual formatting. */
+ output_format (buffer, text);
+ /* Restore previous settings. */
+ output_prefixing_rule (buffer) = rule;
+ output_line_cutoff (buffer) = line_cutoff;
+}
+
+/* Output MESSAGE verbatim into BUFFER. */
+void
+output_verbatim VPARAMS ((output_buffer *buffer, const char *msgid, ...))
+{
+ text_info text;
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, output_buffer *, buffer);
+ VA_FIXEDARG (ap, const char *, msgid);
+
+ text.format_spec = msgid;
+ text.args_ptr = ≈
+ output_do_verbatim (buffer, &text);
+ VA_CLOSE (ap);
+}
+
+\f
+/* Initialize the diagnostic message outputting machinery. */
+void
+diagnostic_initialize (context)
+ diagnostic_context *context;
+{
+ memset (context, 0, sizeof *context);
+ obstack_init (&context->buffer.obstack);
+
+ /* By default, diagnostics are sent to stderr. */
+ output_buffer_attached_stream (&context->buffer) = stderr;
+
+ /* By default, we emit prefixes once per message. */
+ diagnostic_prefixing_rule (context) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
+
+ diagnostic_starter (context) = default_diagnostic_starter;
+ diagnostic_finalizer (context) = default_diagnostic_finalizer;
+ context->warnings_are_errors_message = warnings_are_errors;
+}
+
+/* Returns true if the next format specifier in TEXT is a format specifier
+ for a location_t. If so, update the object pointed by LOCUS to reflect
+ the specified location in *TEXT->args_ptr. */
+static bool
+text_specifies_location (text, locus)
+ text_info *text;
+ location_t *locus;
+{
+ const char *p;
+ /* Skip any leading text. */
+ for (p = text->format_spec; *p && *p != '%'; ++p)
+ ;
+
+ /* Extract the location information if any. */
+ if (*p == '%' && *++p == 'H')
+ {
+ *locus = *va_arg (*text->args_ptr, location_t *);
+ text->format_spec = p + 1;
+ return true;
+ }
+
+ return false;
+}
+
+void
+diagnostic_set_info (diagnostic, msgid, args, file, line, kind)
+ diagnostic_info *diagnostic;
+ const char *msgid;
+ va_list *args;
+ const char *file;
+ int line;
+ diagnostic_t kind;
+{
+ diagnostic->message.format_spec = msgid;
+ diagnostic->message.args_ptr = args;
+ /* If the diagnostic message doesn't specify a location,
+ use FILE and LINE. */
+ if (!text_specifies_location (&diagnostic->message, &diagnostic->location))
+ {
+ diagnostic->location.file = file;
+ diagnostic->location.line = line;
}
+ diagnostic->kind = kind;
}
+/* Return a malloc'd string describing a location. The caller is
+ responsible for freeing the memory. */
+char *
+diagnostic_build_prefix (diagnostic)
+ diagnostic_info *diagnostic;
+{
+ static const char *const diagnostic_kind_text[] = {
+#define DEFINE_DIAGNOSTIC_KIND(K, T) (T),
+#include "diagnostic.def"
+#undef DEFINE_DIAGNOSTIC_KIND
+ "must-not-happen"
+ };
+ if (diagnostic->kind >= DK_LAST_DIAGNOSTIC_KIND)
+ abort();
+
+ return diagnostic->location.file
+ ? build_message_string ("%s:%d: %s",
+ diagnostic->location.file,
+ diagnostic->location.line,
+ _(diagnostic_kind_text[diagnostic->kind]))
+ : build_message_string ("%s: %s", progname,
+ _(diagnostic_kind_text[diagnostic->kind]));
+}
/* Report a diagnostic MESSAGE at the declaration DECL.
MSG is a format string which uses %s to substitute the declaration
name; subsequent substitutions are a la output_format. */
-
static void
-diagnostic_for_decl (decl, msgid, args_ptr, warn)
+diagnostic_for_decl (diagnostic, decl)
+ diagnostic_info *diagnostic;
tree decl;
- const char *msgid;
- va_list *args_ptr;
- int warn;
{
- output_state os;
+ if (global_dc->lock++)
+ error_recursion (global_dc);
- if (diagnostic_lock++)
- error_recursion ();
-
- if (count_error (warn))
+ if (diagnostic_count_diagnostic (global_dc, diagnostic->kind))
{
- os = output_buffer_state (diagnostic_buffer);
- report_error_function (DECL_SOURCE_FILE (decl));
+ diagnostic_report_current_function (global_dc);
output_set_prefix
- (diagnostic_buffer, context_as_prefix
- (DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl), warn));
- output_buffer_ptr_to_format_args (diagnostic_buffer) = args_ptr;
- output_buffer_text_cursor (diagnostic_buffer) = _(msgid);
- format_with_decl (diagnostic_buffer, decl);
- diagnostic_finish ((output_buffer *)global_dc);
- output_destroy_prefix (diagnostic_buffer);
-
- output_buffer_state (diagnostic_buffer) = os;
+ (&global_dc->buffer, diagnostic_build_prefix (diagnostic));
+ format_with_decl (&global_dc->buffer, &diagnostic->message, decl);
+ output_flush (&global_dc->buffer);
+ output_destroy_prefix (&global_dc->buffer);
}
- diagnostic_lock--;
+ global_dc->lock--;
}
-\f
-/* Count an error or warning. Return 1 if the message should be printed. */
-
-int
-count_error (warningp)
- int warningp;
+void
+diagnostic_flush_buffer (context)
+ diagnostic_context *context;
{
- if (warningp && !diagnostic_report_warnings_p ())
- return 0;
+ output_buffer_to_stream (&context->buffer);
+ fflush (output_buffer_attached_stream (&context->buffer));
+}
- if (warningp && !warnings_are_errors)
- warningcount++;
- else
+/* Count a diagnostic. Return true if the message should be printed. */
+bool
+diagnostic_count_diagnostic (context, kind)
+ diagnostic_context *context;
+ diagnostic_t kind;
+{
+ switch (kind)
{
- static int warning_message = 0;
+ default:
+ abort();
+ break;
+
+ case DK_FATAL: case DK_ICE: case DK_SORRY:
+ case DK_ANACHRONISM: case DK_NOTE:
+ ++diagnostic_kind_count (context, kind);
+ break;
+
+ case DK_WARNING:
+ if (!diagnostic_report_warnings_p ())
+ return false;
+ else if (!warnings_are_errors)
+ {
+ ++diagnostic_kind_count (context, DK_WARNING);
+ break;
+ }
+ /* else fall through. */
- if (warningp && !warning_message)
- {
- verbatim ("%s: warnings being treated as errors\n", progname);
- warning_message = 1;
- }
- errorcount++;
+ case DK_ERROR:
+ if (kind == DK_WARNING && context->warnings_are_errors_message)
+ {
+ output_verbatim (&context->buffer,
+ "%s: warnings being treated as errors\n", progname);
+ context->warnings_are_errors_message = false;
+ }
+ ++diagnostic_kind_count (context, DK_ERROR);
+ break;
}
- return 1;
+ return true;
}
/* Print a diagnostic MSGID on FILE. This is just fprintf, except it
runs its second argument through gettext. */
-
void
fnotice VPARAMS ((FILE *file, const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- FILE *file;
- const char *msgid;
-#endif
- va_list ap;
-
- VA_START (ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- file = va_arg (ap, FILE *);
- msgid = va_arg (ap, const char *);
-#endif
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, FILE *, file);
+ VA_FIXEDARG (ap, const char *, msgid);
vfprintf (file, _(msgid), ap);
- va_end (ap);
+ VA_CLOSE (ap);
}
/* Print a fatal I/O error message. Argument are like printf.
Also include a system error message based on `errno'. */
-
void
fatal_io_error VPARAMS ((const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- const char *msgid;
-#endif
- va_list ap;
- output_state os;
-
- os = output_buffer_state (diagnostic_buffer);
- VA_START (ap, msgid);
+ text_info text;
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, const char *, msgid);
-#ifndef ANSI_PROTOTYPES
- msgid = va_arg (ap, const char *);
-#endif
-
- output_printf (diagnostic_buffer, "%s: %s: ", progname, xstrerror (errno));
- output_buffer_ptr_to_format_args (diagnostic_buffer) = ≈
- output_buffer_text_cursor (diagnostic_buffer) = _(msgid);
- output_format (diagnostic_buffer);
- diagnostic_finish ((output_buffer *)global_dc);
- output_buffer_state (diagnostic_buffer) = os;
- va_end (ap);
+ text.format_spec = _(msgid);
+ text.args_ptr = ≈
+ output_printf (&global_dc->buffer, "%s: %s: ", progname, xstrerror (errno));
+ output_format (&global_dc->buffer, &text);
+ output_flush (&global_dc->buffer);
+ VA_CLOSE (ap);
exit (FATAL_EXIT_CODE);
}
/* Issue a pedantic warning MSGID. */
-
void
pedwarn VPARAMS ((const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- const char *msgid;
-#endif
- va_list ap;
- diagnostic_context dc;
-
- VA_START (ap, msgid);
+ diagnostic_info diagnostic;
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, const char *, msgid);
-#ifndef ANSI_PROTOTYPES
- msgid = va_arg (ap, const char *);
-#endif
-
- set_diagnostic_context
- (&dc, msgid, &ap, input_filename, lineno, !flag_pedantic_errors);
- report_diagnostic (&dc);
- va_end (ap);
+ diagnostic_set_info (&diagnostic, _(msgid), &ap, input_filename, lineno,
+ pedantic_error_kind ());
+ report_diagnostic (&diagnostic);
+ VA_CLOSE (ap);
}
-/* Issue a pedantic waring about DECL. */
-
+/* Issue a pedantic warning about DECL. */
void
pedwarn_with_decl VPARAMS ((tree decl, const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- tree decl;
- const char *msgid;
-#endif
- va_list ap;
+ diagnostic_info diagnostic;
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, tree, decl);
+ VA_FIXEDARG (ap, const char *, msgid);
- VA_START (ap, msgid);
+ diagnostic_set_info (&diagnostic, _(msgid), &ap,
+ DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl),
+ pedantic_error_kind ());
-#ifndef ANSI_PROTOTYPES
- decl = va_arg (ap, tree);
- msgid = va_arg (ap, const char *);
-#endif
/* We don't want -pedantic-errors to cause the compilation to fail from
"errors" in system header files. Sometimes fixincludes can't fix what's
broken (eg: unsigned char bitfields - fixing it may change the alignment
or kernel uses the original layout). There's no point in issuing a
warning either, it's just unnecessary noise. */
if (!DECL_IN_SYSTEM_HEADER (decl))
- diagnostic_for_decl (decl, msgid, &ap, !flag_pedantic_errors);
- va_end (ap);
+ diagnostic_for_decl (&diagnostic, decl);
+ VA_CLOSE (ap);
}
/* Same as above but within the context FILE and LINE. */
-
void
pedwarn_with_file_and_line VPARAMS ((const char *file, int line,
const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- const char *file;
- int line;
- const char *msgid;
-#endif
- va_list ap;
- diagnostic_context dc;
+ diagnostic_info diagnostic;
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, const char *, file);
+ VA_FIXEDARG (ap, int, line);
+ VA_FIXEDARG (ap, const char *, msgid);
- VA_START (ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- file = va_arg (ap, const char *);
- line = va_arg (ap, int);
- msgid = va_arg (ap, const char *);
-#endif
-
- set_diagnostic_context (&dc, msgid, &ap, file, line, !flag_pedantic_errors);
- report_diagnostic (&dc);
- va_end (ap);
+ diagnostic_set_info (&diagnostic, _(msgid), &ap, file, line,
+ pedantic_error_kind ());
+ report_diagnostic (&diagnostic);
+ VA_CLOSE (ap);
}
/* Just apologize with MSGID. */
-
void
sorry VPARAMS ((const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- const char *msgid;
-#endif
- va_list ap;
- output_state os;
+ diagnostic_info diagnostic;
- os = output_buffer_state (diagnostic_buffer);
- VA_START (ap, msgid);
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, const char *, msgid);
-#ifndef ANSI_PROTOTYPES
- msgid = va_arg (ap, const char *);
-#endif
++sorrycount;
+ diagnostic_set_info (&diagnostic, _(msgid), &ap,
+ input_filename, lineno, DK_SORRY);
+
output_set_prefix
- (diagnostic_buffer, context_as_prefix (input_filename, lineno, 0));
- output_printf (diagnostic_buffer, "sorry, not implemented: ");
- output_buffer_ptr_to_format_args (diagnostic_buffer) = ≈
- output_buffer_text_cursor (diagnostic_buffer) = _(msgid);
- output_format (diagnostic_buffer);
- diagnostic_finish ((output_buffer *)global_dc);
- output_buffer_state (diagnostic_buffer) = os;
- va_end (ap);
+ (&global_dc->buffer, diagnostic_build_prefix (&diagnostic));
+ output_format (&global_dc->buffer, &diagnostic.message);
+ output_flush (&global_dc->buffer);
+ VA_CLOSE (ap);
}
/* Called when the start of a function definition is parsed,
this function prints on stderr the name of the function. */
-
void
announce_function (decl)
tree decl;
{
- if (! quiet_flag)
+ if (!quiet_flag)
{
if (rtl_dump_and_exit)
verbatim ("%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));
else
- verbatim (" %s", (*decl_printable_name) (decl, 2));
+ verbatim (" %s", (*lang_hooks.decl_printable_name) (decl, 2));
fflush (stderr);
- output_needs_newline (diagnostic_buffer) = 1;
- record_last_error_function ();
+ output_needs_newline (&global_dc->buffer) = true;
+ diagnostic_set_last_function (global_dc);
}
}
/* The default function to print out name of current function that caused
an error. */
-
void
-default_print_error_function (context, file)
+lhd_print_error_function (context, file)
diagnostic_context *context;
const char *file;
{
- if (error_function_changed ())
+ if (diagnostic_last_function_changed (context))
{
- char *prefix = file ? build_message_string ("%s: ", file) : NULL;
- output_state os;
+ const char *old_prefix = output_prefix (&context->buffer);
+ char *new_prefix = file ? build_message_string ("%s: ", file) : NULL;
+
+ output_set_prefix (&context->buffer, new_prefix);
- os = output_buffer_state (context);
- output_set_prefix ((output_buffer *)context, prefix);
-
if (current_function_decl == NULL)
- output_add_string ((output_buffer *)context, _("At top level:"));
+ output_add_string (&context->buffer, _("At top level:"));
else
{
if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
- output_printf
- ((output_buffer *)context, "In member function `%s':",
- (*decl_printable_name) (current_function_decl, 2));
+ output_printf
+ (&context->buffer, "In member function `%s':",
+ (*lang_hooks.decl_printable_name) (current_function_decl, 2));
else
- output_printf
- ((output_buffer *)context, "In function `%s':",
- (*decl_printable_name) (current_function_decl, 2));
+ output_printf
+ (&context->buffer, "In function `%s':",
+ (*lang_hooks.decl_printable_name) (current_function_decl, 2));
}
- output_add_newline ((output_buffer *)context);
+ output_add_newline (&context->buffer);
- record_last_error_function ();
- output_buffer_to_stream ((output_buffer *)context);
- output_buffer_state (context) = os;
- free ((char*) prefix);
+ diagnostic_set_last_function (context);
+ output_buffer_to_stream (&context->buffer);
+ context->buffer.state.prefix = old_prefix;
+ free ((char*) new_prefix);
}
}
We ignore the FILE parameter, as it cannot be relied upon. */
void
-report_error_function (file)
- const char *file ATTRIBUTE_UNUSED;
+diagnostic_report_current_function (context)
+ diagnostic_context *context;
{
- report_problematic_module ((output_buffer *)global_dc);
- (*print_error_function) (global_dc, input_filename);
+ diagnostic_report_current_module (context);
+ (*lang_hooks.print_error_function) (context, input_filename);
}
void
error_with_file_and_line VPARAMS ((const char *file, int line,
const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- const char *file;
- int line;
- const char *msgid;
-#endif
- va_list ap;
- diagnostic_context dc;
+ diagnostic_info diagnostic;
- VA_START (ap, msgid);
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, const char *, file);
+ VA_FIXEDARG (ap, int, line);
+ VA_FIXEDARG (ap, const char *, msgid);
-#ifndef ANSI_PROTOTYPES
- file = va_arg (ap, const char *);
- line = va_arg (ap, int);
- msgid = va_arg (ap, const char *);
-#endif
-
- set_diagnostic_context (&dc, msgid, &ap, file, line, /* warn = */ 0);
- report_diagnostic (&dc);
- va_end (ap);
+ diagnostic_set_info (&diagnostic, msgid, &ap, file, line, DK_ERROR);
+ report_diagnostic (&diagnostic);
+ VA_CLOSE (ap);
}
void
error_with_decl VPARAMS ((tree decl, const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- tree decl;
- const char *msgid;
-#endif
- va_list ap;
+ diagnostic_info diagnostic;
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, tree, decl);
+ VA_FIXEDARG (ap, const char *, msgid);
- VA_START (ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- decl = va_arg (ap, tree);
- msgid = va_arg (ap, const char *);
-#endif
-
- diagnostic_for_decl (decl, msgid, &ap, /* warn = */ 0);
- va_end (ap);
+ diagnostic_set_info (&diagnostic, msgid, &ap,
+ DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl),
+ DK_ERROR);
+ diagnostic_for_decl (&diagnostic, decl);
+ VA_CLOSE (ap);
}
void
error VPARAMS ((const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- const char *msgid;
-#endif
- va_list ap;
- diagnostic_context dc;
-
- VA_START (ap, msgid);
+ diagnostic_info diagnostic;
-#ifndef ANSI_PROTOTYPES
- msgid = va_arg (ap, const char *);
-#endif
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, const char *, msgid);
- set_diagnostic_context
- (&dc, msgid, &ap, input_filename, lineno, /* warn = */ 0);
- report_diagnostic (&dc);
- va_end (ap);
+ diagnostic_set_info (&diagnostic, msgid, &ap, input_filename, lineno,
+ DK_ERROR);
+ report_diagnostic (&diagnostic);
+ VA_CLOSE (ap);
}
/* Likewise, except that the compilation is terminated after printing the
void
fatal_error VPARAMS ((const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- const char *msgid;
-#endif
- va_list ap;
- diagnostic_context dc;
-
- VA_START (ap, msgid);
+ diagnostic_info diagnostic;
-#ifndef ANSI_PROTOTYPES
- msgid = va_arg (ap, const char *);
-#endif
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, const char *, msgid);
- set_diagnostic_context
- (&dc, msgid, &ap, input_filename, lineno, /* warn = */ 0);
- report_diagnostic (&dc);
- va_end (ap);
+ diagnostic_set_info (&diagnostic, msgid, &ap, input_filename, lineno,
+ DK_FATAL);
+ report_diagnostic (&diagnostic);
+ VA_CLOSE (ap);
fnotice (stderr, "compilation terminated.\n");
exit (FATAL_EXIT_CODE);
}
-/* Report a compiler error at the current line number. Allow a front end to
- intercept the message. */
-
-static void (*internal_error_function) PARAMS ((const char *, va_list *));
-
-/* Set the function to call when a compiler error occurs. */
-
-void
-set_internal_error_function (f)
- void (*f) PARAMS ((const char *, va_list *));
-{
- internal_error_function = f;
-}
-
void
internal_error VPARAMS ((const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- const char *msgid;
-#endif
- va_list ap;
- diagnostic_context dc;
+ diagnostic_info diagnostic;
- VA_START (ap, msgid);
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, const char *, msgid);
-#ifndef ANSI_PROTOTYPES
- msgid = va_arg (ap, const char *);
-#endif
+ if (global_dc->lock)
+ error_recursion (global_dc);
+#ifndef ENABLE_CHECKING
if (errorcount > 0 || sorrycount > 0)
{
fnotice (stderr, "%s:%d: confused by earlier errors, bailing out\n",
input_filename, lineno);
exit (FATAL_EXIT_CODE);
}
+#endif
+
+ if (global_dc->internal_error != 0)
+ (*global_dc->internal_error) (_(msgid), &ap);
- if (internal_error_function != 0)
- (*internal_error_function) (_(msgid), &ap);
-
- set_diagnostic_context
- (&dc, msgid, &ap, input_filename, lineno, /* warn = */0);
- report_diagnostic (&dc);
- va_end (ap);
+ diagnostic_set_info (&diagnostic, msgid, &ap, input_filename, lineno,
+ DK_ICE);
+ report_diagnostic (&diagnostic);
+ VA_CLOSE (ap);
fnotice (stderr,
"Please submit a full bug report,\n\
with preprocessed source if appropriate.\n\
-See %s for instructions.\n", GCCBUGURL);
+See %s for instructions.\n", bug_report_url);
exit (FATAL_EXIT_CODE);
}
warning_with_file_and_line VPARAMS ((const char *file, int line,
const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- const char *file;
- int line;
- const char *msgid;
-#endif
- va_list ap;
- diagnostic_context dc;
-
- VA_START (ap, msgid);
+ diagnostic_info diagnostic;
-#ifndef ANSI_PROTOTYPES
- file = va_arg (ap, const char *);
- line = va_arg (ap, int);
- msgid = va_arg (ap, const char *);
-#endif
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, const char *, file);
+ VA_FIXEDARG (ap, int, line);
+ VA_FIXEDARG (ap, const char *, msgid);
- set_diagnostic_context (&dc, msgid, &ap, file, line, /* warn = */ 1);
- report_diagnostic (&dc);
- va_end (ap);
+ diagnostic_set_info (&diagnostic, msgid, &ap, file, line, DK_WARNING);
+ report_diagnostic (&diagnostic);
+ VA_CLOSE (ap);
}
void
warning_with_decl VPARAMS ((tree decl, const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- tree decl;
- const char *msgid;
-#endif
- va_list ap;
-
- VA_START (ap, msgid);
+ diagnostic_info diagnostic;
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, tree, decl);
+ VA_FIXEDARG (ap, const char *, msgid);
-#ifndef ANSI_PROTOTYPES
- decl = va_arg (ap, tree);
- msgid = va_arg (ap, const char *);
-#endif
-
- diagnostic_for_decl (decl, msgid, &ap, /* warn = */ 1);
- va_end (ap);
+ diagnostic_set_info (&diagnostic, msgid, &ap,
+ DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl),
+ DK_WARNING);
+ diagnostic_for_decl (&diagnostic, decl);
+ VA_CLOSE (ap);
}
void
warning VPARAMS ((const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- const char *msgid;
-#endif
- va_list ap;
- diagnostic_context dc;
-
- VA_START (ap, msgid);
+ diagnostic_info diagnostic;
-#ifndef ANSI_PROTOTYPES
- msgid = va_arg (ap, const char *);
-#endif
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, const char *, msgid);
- set_diagnostic_context
- (&dc, msgid, &ap, input_filename, lineno, /* warn = */ 1);
- report_diagnostic (&dc);
- va_end (ap);
+ diagnostic_set_info (&diagnostic, msgid, &ap, input_filename, lineno,
+ DK_WARNING);
+ report_diagnostic (&diagnostic);
+ VA_CLOSE (ap);
}
-/* Flush diagnostic_buffer content on stderr. */
-
-static void
-diagnostic_finish (buffer)
- output_buffer *buffer;
-{
- output_buffer_to_stream (buffer);
- clear_diagnostic_info (buffer);
- fputc ('\n', output_buffer_attached_stream (buffer));
- fflush (output_buffer_attached_stream (buffer));
-}
-
-/* Helper subroutine of output_verbatim and verbatim. Do the approriate
- settings needed by BUFFER for a verbatim formatting. */
-
-static void
-output_do_verbatim (buffer, msgid, args_ptr)
- output_buffer *buffer;
- const char *msgid;
- va_list *args_ptr;
-{
- output_state os;
-
- os = output_buffer_state (buffer);
- output_prefix (buffer) = NULL;
- diagnostic_prefixing_rule (buffer) = DIAGNOSTICS_SHOW_PREFIX_NEVER;
- output_buffer_text_cursor (buffer) = _(msgid);
- output_buffer_ptr_to_format_args (buffer) = args_ptr;
- output_set_maximum_length (buffer, 0);
- output_format (buffer);
- output_buffer_state (buffer) = os;
-}
-
-/* Output MESSAGE verbatim into BUFFER. */
-
-void
-output_verbatim VPARAMS ((output_buffer *buffer, const char *msgid, ...))
-{
-#ifndef ANSI_PROTOTYPES
- output_buffer *buffer;
- const char *msgid;
-#endif
- va_list ap;
-
- VA_START (ap, msgid);
-#ifndef ANSI_PROTOTYPES
- buffer = va_arg (ap, output_buffer *);
- msg = va_arg (ap, const char *);
-#endif
- output_do_verbatim (buffer, msgid, &ap);
- va_end (ap);
-}
/* Same as above but use diagnostic_buffer. */
void
verbatim VPARAMS ((const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- const char *msgid;
-#endif
- va_list ap;
+ text_info text;
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, const char *, msgid);
- VA_START (ap, msgid);
-#ifndef ANSI_PROTOTYPES
- msgid = va_arg (ap, const char *);
-#endif
- output_do_verbatim (diagnostic_buffer, msgid, &ap);
- output_buffer_to_stream (diagnostic_buffer);
- va_end (ap);
+ text.format_spec = _(msgid);
+ text.args_ptr = ≈
+ output_do_verbatim (&global_dc->buffer, &text);
+ output_buffer_to_stream (&global_dc->buffer);
+ VA_CLOSE (ap);
}
/* Report a diagnostic message (an error or a warning) as specified by
in the documentation of output_format. */
void
-report_diagnostic (dc)
- diagnostic_context *dc;
+diagnostic_report_diagnostic (context, diagnostic)
+ diagnostic_context *context;
+ diagnostic_info *diagnostic;
{
- output_state os;
-
- if (diagnostic_lock++)
- error_recursion ();
+ if (context->lock++)
+ error_recursion (context);
- if (count_error (diagnostic_is_warning (dc)))
+ if (diagnostic_count_diagnostic (context, diagnostic->kind))
{
- os = output_buffer_state (diagnostic_buffer);
- diagnostic_msg = diagnostic_message (dc);
- diagnostic_args = diagnostic_argument_list (dc);
- (*diagnostic_starter (dc)) (diagnostic_buffer, dc);
- output_format (diagnostic_buffer);
- (*diagnostic_finalizer (dc)) (diagnostic_buffer, dc);
- diagnostic_finish ((output_buffer *)global_dc);
- output_buffer_state (diagnostic_buffer) = os;
+ (*diagnostic_starter (context)) (context, diagnostic);
+ output_format (&context->buffer, &diagnostic->message);
+ (*diagnostic_finalizer (context)) (context, diagnostic);
+ output_flush (&context->buffer);
}
- diagnostic_lock--;
+ --context->lock;
}
/* Inform the user that an error occurred while trying to report some
This mustn't use internal_error, that will cause infinite recursion. */
static void
-error_recursion ()
+error_recursion (context)
+ diagnostic_context *context;
{
- if (diagnostic_lock < 3)
- diagnostic_finish ((output_buffer *)global_dc);
+ if (context->lock < 3)
+ output_flush (&context->buffer);
fnotice (stderr,
"Internal compiler error: Error reporting routines re-entered.\n");
fnotice (stderr,
"Please submit a full bug report,\n\
with preprocessed source if appropriate.\n\
-See %s for instructions.\n", GCCBUGURL);
+See %s for instructions.\n", bug_report_url);
exit (FATAL_EXIT_CODE);
}
int line;
const char *function;
{
- internal_error ("Internal compiler error in %s, at %s:%d",
- function, trim_filename (file), line);
-}
-
-/* Setup DC for reporting a diagnostic MESSAGE (an error or a WARNING),
- using arguments pointed to by ARGS_PTR, issued at a location specified
- by FILE and LINE. */
-
-void
-set_diagnostic_context (dc, msgid, args_ptr, file, line, warn)
- diagnostic_context *dc;
- const char *msgid;
- va_list *args_ptr;
- const char *file;
- int line;
- int warn;
-{
- memset (dc, 0, sizeof (diagnostic_context));
- diagnostic_message (dc) = _(msgid);
- diagnostic_argument_list (dc) = args_ptr;
- diagnostic_file_location (dc) = file;
- diagnostic_line_location (dc) = line;
- diagnostic_is_warning (dc) = warn;
- diagnostic_starter (dc) = diagnostic_starter (global_dc);
- diagnostic_finalizer (dc) = diagnostic_finalizer (global_dc);
+ internal_error ("in %s, at %s:%d", function, trim_filename (file), line);
}
void
-report_problematic_module (buffer)
- output_buffer *buffer;
+diagnostic_report_current_module (context)
+ diagnostic_context *context;
{
struct file_stack *p;
- if (output_needs_newline (buffer))
+ if (output_needs_newline (&context->buffer))
{
- output_add_newline (buffer);
- output_needs_newline (buffer) = 0;
+ output_add_newline (&context->buffer);
+ output_needs_newline (&context->buffer) = false;
}
if (input_file_stack && input_file_stack->next != 0
- && error_module_changed ())
+ && diagnostic_last_module_changed (context))
{
for (p = input_file_stack->next; p; p = p->next)
if (p == input_file_stack->next)
- output_verbatim
- (buffer, "In file included from %s:%d", p->name, p->line);
+ output_verbatim (&context->buffer,
+ "In file included from %s:%d", p->name, p->line);
else
- output_verbatim
- (buffer, ",\n from %s:%d", p->name, p->line);
- output_verbatim (buffer, ":\n");
- record_last_error_module ();
+ output_verbatim (&context->buffer,
+ ",\n from %s:%d", p->name, p->line);
+ output_verbatim (&context->buffer, ":\n");
+ diagnostic_set_last_module (context);
}
}
static void
-default_diagnostic_starter (buffer, dc)
- output_buffer *buffer;
- diagnostic_context *dc;
+default_diagnostic_starter (context, diagnostic)
+ diagnostic_context *context;
+ diagnostic_info *diagnostic;
{
- report_error_function (diagnostic_file_location (dc));
- output_set_prefix (buffer,
- context_as_prefix (diagnostic_file_location (dc),
- diagnostic_line_location (dc),
- diagnostic_is_warning (dc)));
+ diagnostic_report_current_function (context);
+ output_set_prefix (&context->buffer, diagnostic_build_prefix (diagnostic));
}
static void
-default_diagnostic_finalizer (buffer, dc)
- output_buffer *buffer;
- diagnostic_context *dc __attribute__((__unused__));
+default_diagnostic_finalizer (context, diagnostic)
+ diagnostic_context *context;
+ diagnostic_info *diagnostic __attribute__((unused));
+{
+ output_destroy_prefix (&context->buffer);
+}
+
+void
+inform VPARAMS ((const char *msgid, ...))
{
- output_destroy_prefix (buffer);
+ diagnostic_info diagnostic;
+
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, const char *, msgid);
+
+ diagnostic_set_info (&diagnostic, msgid, &ap, input_filename, lineno,
+ DK_NOTE);
+ report_diagnostic (&diagnostic);
+ VA_CLOSE (ap);
+}
+
+void
+warn_deprecated_use (node)
+ tree node;
+{
+ if (node == 0 || !warn_deprecated_decl)
+ return;
+
+ if (DECL_P (node))
+ warning ("`%s' is deprecated (declared at %s:%d)",
+ IDENTIFIER_POINTER (DECL_NAME (node)),
+ DECL_SOURCE_FILE (node), DECL_SOURCE_LINE (node));
+ else if (TYPE_P (node))
+ {
+ const char *what = NULL;
+ tree decl = TYPE_STUB_DECL (node);
+
+ if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
+ what = IDENTIFIER_POINTER (TYPE_NAME (node));
+ else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
+ && DECL_NAME (TYPE_NAME (node)))
+ what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)));
+
+ if (what)
+ {
+ if (decl)
+ warning ("`%s' is deprecated (declared at %s:%d)", what,
+ DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
+ else
+ warning ("`%s' is deprecated", what);
+ }
+ else if (decl)
+ warning ("type is deprecated (declared at %s:%d)",
+ DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
+ else
+ warning ("type is deprecated");
+ }
}
OSDN Git Service
