/* Language-independent diagnostic subroutines for the GNU C compiler
- Copyright (C) 1999, 2000 Free Software Foundation, Inc.
+ 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 independant aspect of diagnostic
+/* This file implements the language independent aspect of diagnostic
message module. */
#include "config.h"
#undef FLOAT /* This is for hpux. They should change hpux. */
#undef FFS /* Some systems define this in param.h. */
#include "system.h"
-
#include "tree.h"
-#include "rtl.h"
#include "tm_p.h"
#include "flags.h"
#include "input.h"
-#include "insn-attr.h"
-#include "insn-codes.h"
-#include "insn-config.h"
#include "toplev.h"
#include "intl.h"
#include "diagnostic.h"
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
-#define diagnostic_args diagnostic_buffer->format_args
-#define diagnostic_msg diagnostic_buffer->cursor
-
#define output_formatted_integer(BUFFER, FORMAT, INTEGER) \
do { \
- sprintf (digit_buffer, FORMAT, INTEGER); \
- output_add_string (BUFFER, digit_buffer); \
+ sprintf ((BUFFER)->digit_buffer, FORMAT, INTEGER); \
+ output_add_string (BUFFER, (BUFFER)->digit_buffer); \
} while (0)
-/* This data structure serves to save/restore an output_buffer state. */
-typedef struct
-{
- const char *prefix;
- int maximum_length;
- int ideal_maximum_length;
- int emitted_prefix_p;
- int prefixing_rule;
- const char *cursor;
- va_list format_args;
-} output_state;
-
+#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
-/* Prototypes. */
-static int doing_line_wrapping PARAMS ((void));
+#define diagnostic_args output_buffer_ptr_to_format_args (diagnostic_buffer)
+#define diagnostic_msg output_buffer_text_cursor (diagnostic_buffer)
-static void finish_diagnostic PARAMS ((void));
+/* Prototypes. */
+static void diagnostic_finish PARAMS ((output_buffer *));
static void output_do_verbatim PARAMS ((output_buffer *,
- const char *, va_list));
-static void output_to_stream PARAMS ((output_buffer *, FILE *));
+ const char *, va_list *));
+static void output_buffer_to_stream PARAMS ((output_buffer *));
static void output_format PARAMS ((output_buffer *));
+static void output_indent PARAMS ((output_buffer *));
-static char *vbuild_message_string PARAMS ((const char *, va_list));
+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 char *context_as_prefix PARAMS ((const char *, int, int));
-static void output_do_printf PARAMS ((output_buffer *, const char *));
-static void line_wrapper_printf PARAMS ((FILE *, const char *, ...))
- ATTRIBUTE_PRINTF_2;
-static void vline_wrapper_message_with_location PARAMS ((const char *, int,
- int, const char *,
- va_list));
-static void notice PARAMS ((const char *s, ...)) ATTRIBUTE_PRINTF_1;
-static void v_message_with_file_and_line PARAMS ((const char *, int, int,
- const char *, va_list));
-static void v_message_with_decl PARAMS ((tree, int, const char *, va_list));
-static void file_and_line_for_asm PARAMS ((rtx, const char **, int *));
-static void v_error_with_file_and_line PARAMS ((const char *, int,
- const char *, va_list));
-static void v_error_with_decl PARAMS ((tree, const char *, va_list));
-static void v_error_for_asm PARAMS ((rtx, const char *, va_list));
-static void vfatal PARAMS ((const char *, va_list)) ATTRIBUTE_NORETURN;
-static void v_warning_with_file_and_line PARAMS ((const char *, int,
- const char *, va_list));
-static void v_warning_with_decl PARAMS ((tree, const char *, va_list));
-static void v_warning_for_asm PARAMS ((rtx, const char *, va_list));
-static void v_pedwarn_with_decl PARAMS ((tree, const char *, va_list));
-static void v_pedwarn_with_file_and_line PARAMS ((const char *, int,
- const char *, va_list));
-static void vsorry PARAMS ((const char *, va_list));
-static void report_file_and_line PARAMS ((const char *, int, int));
-static void vnotice PARAMS ((FILE *, const char *, va_list));
+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 set_real_maximum_length PARAMS ((output_buffer *));
-static void save_output_state PARAMS ((const output_buffer *, output_state *));
-static void restore_output_state PARAMS ((const output_state *,
- 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 *,
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 *));
-extern int rtl_dump_and_exit;
-extern int inhibit_warnings;
-extern int warnings_are_errors;
-extern int warningcount;
-extern int errorcount;
+static void default_diagnostic_starter PARAMS ((output_buffer *,
+ diagnostic_context *));
+static void default_diagnostic_finalizer PARAMS ((output_buffer *,
+ diagnostic_context *));
-/* Front-end specific tree formatter, if non-NULL. */
-printer_fn lang_printer = NULL;
+static void error_recursion PARAMS ((void)) ATTRIBUTE_NORETURN;
-/* This must be large enough to hold any printed integer or
- floating-point value. */
-static char digit_buffer[128];
+extern int rtl_dump_and_exit;
+extern int warnings_are_errors;
-/* An output_buffer surrogate for stderr. */
-static output_buffer global_output_buffer;
-output_buffer *diagnostic_buffer = &global_output_buffer;
+/* A diagnostic_context surrogate for stderr. */
+static diagnostic_context global_diagnostic_context;
+diagnostic_context *global_dc = &global_diagnostic_context;
-static int need_error_newline;
+/* 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
static int last_error_tick;
/* Called by report_error_function to print out function name.
- * Default may be overridden by language front-ends. */
+ Default may be overridden by language front-ends. */
-void (*print_error_function) PARAMS ((const char *)) =
- default_print_error_function;
+void (*print_error_function) PARAMS ((diagnostic_context *, const char *))
+ = default_print_error_function;
-/* Maximum characters per line in automatic line wrapping mode.
- Zero means don't wrap lines. */
+/* Prevent recursion into the error handler. */
+static int diagnostic_lock;
-int diagnostic_message_length_per_line;
-
-/* Used to control every diagnostic message formatting. Front-ends should
- call set_message_prefixing_rule to set up their politics. */
-static int current_prefixing_rule;
\f
-/* Initialize the diagnostic message outputting machinery. */
+/* 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
-initialize_diagnostics ()
+record_last_error_module ()
+{
+ last_error_tick = input_file_stack_tick;
+}
+
+/* Same as error_module_changed, but for function. */
+
+int
+error_function_changed ()
{
- /* By default, we don't line-wrap messages. */
- diagnostic_message_length_per_line = 0;
- set_message_prefixing_rule (DIAGNOSTICS_SHOW_PREFIX_ONCE);
- /* Proceed to actual initialization. */
- default_initialize_buffer (diagnostic_buffer);
+ return last_error_function != current_function_decl;
}
-/* Predicate. Return 1 if we're in automatic line wrapping mode. */
+/* Same as record_last_error_module, but for function. */
-static int
-doing_line_wrapping ()
+void
+record_last_error_function ()
{
- return diagnostic_message_length_per_line > 0;
+ last_error_function = current_function_decl;
}
+/* Initialize the diagnostic message outputting machinery. */
+
void
-set_message_prefixing_rule (rule)
- int rule;
+diagnostic_initialize (context)
+ diagnostic_context *context;
{
- current_prefixing_rule = rule;
+ 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. */
+/* Returns true if BUFFER is in line-wrapping mode. */
+
int
output_is_line_wrapping (buffer)
output_buffer *buffer;
{
- return buffer->ideal_maximum_length > 0;
+ return diagnostic_line_cutoff (buffer) > 0;
}
/* Return BUFFER's prefix. */
+
const char *
output_get_prefix (buffer)
const output_buffer *buffer;
{
- return buffer->prefix;
+ 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. */
- if (! output_is_line_wrapping (buffer))
- buffer->maximum_length = buffer->ideal_maximum_length;
+ /* 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 unnecessarily 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);
else
{
- int prefix_length = buffer->prefix ? strlen (buffer->prefix) : 0;
+ int prefix_length =
+ output_prefix (buffer) ? strlen (output_prefix (buffer)) : 0;
/* If the prefix is ridiculously too long, output at least
32 characters. */
- if (buffer->ideal_maximum_length - prefix_length < 32)
- buffer->maximum_length = buffer->ideal_maximum_length + 32;
+ if (diagnostic_line_cutoff (buffer) - prefix_length < 32)
+ line_wrap_cutoff (buffer) = diagnostic_line_cutoff (buffer) + 32;
else
- buffer->maximum_length = buffer->ideal_maximum_length;
+ line_wrap_cutoff (buffer) = diagnostic_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;
{
- buffer->ideal_maximum_length = length;
+ diagnostic_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;
{
- buffer->prefix = prefix;
+ output_prefix (buffer) = prefix;
set_real_maximum_length (buffer);
- buffer->emitted_prefix_p = 0;
+ prefix_was_emitted_for (buffer) = 0;
+ output_indentation (buffer) = 0;
+}
+
+/* Return a pointer to the last character emitted in the output
+ BUFFER area. A NULL pointer means no character available. */
+const char *
+output_last_position (buffer)
+ 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. */
+/* Free BUFFER's prefix, a previously malloc'd string. */
void
output_destroy_prefix (buffer)
output_buffer *buffer;
{
- if (buffer->prefix)
+ if (output_prefix (buffer) != NULL)
{
- free ((char *) buffer->prefix);
- buffer->prefix = NULL;
+ free ((char *) output_prefix (buffer));
+ output_prefix (buffer) = NULL;
}
}
-/* Construct an output BUFFER with PREFIX and of MAXIMUM_LENGTH
- characters per line. */
+/* Zero out any text output so far in BUFFER. */
+
void
-init_output_buffer (buffer, prefix, maximum_length)
+output_clear_message_text (buffer)
output_buffer *buffer;
- const char *prefix;
- int maximum_length;
{
- obstack_init (&buffer->obstack);
- buffer->ideal_maximum_length = maximum_length;
- buffer->line_length = 0;
- output_set_prefix (buffer, prefix);
- buffer->emitted_prefix_p = 0;
- buffer->prefixing_rule = current_prefixing_rule;
-
- buffer->cursor = NULL;
+ obstack_free (&buffer->obstack, obstack_base (&buffer->obstack));
+ output_text_length (buffer) = 0;
}
-/* Initialize BUFFER with a NULL prefix and current diagnostic message
- length cutoff. */
-void
-default_initialize_buffer (buffer)
+/* Zero out any diagnostic data used so far by BUFFER. */
+
+static void
+clear_diagnostic_info (buffer)
output_buffer *buffer;
{
- init_output_buffer (buffer, NULL, diagnostic_message_length_per_line);
+ output_buffer_text_cursor (buffer) = NULL;
+ output_buffer_ptr_to_format_args (buffer) = NULL;
+ prefix_was_emitted_for (buffer) = 0;
+ output_indentation (buffer) = 0;
}
-/* Recompute diagnostic_buffer's attributes to reflect any change
- in diagnostic formatting global options. */
+/* Construct an output BUFFER with PREFIX and of MAXIMUM_LENGTH
+ characters per line. */
+
void
-reshape_diagnostic_buffer ()
+init_output_buffer (buffer, prefix, maximum_length)
+ output_buffer *buffer;
+ const char *prefix;
+ int maximum_length;
{
- diagnostic_buffer->ideal_maximum_length = diagnostic_message_length_per_line;
- diagnostic_buffer->prefixing_rule = current_prefixing_rule;
- set_real_maximum_length (diagnostic_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_set_prefix (buffer, prefix);
+ output_text_length (buffer) = 0;
+ clear_diagnostic_info (buffer);
}
/* Reinitialize BUFFER. */
+
void
output_clear (buffer)
output_buffer *buffer;
{
- obstack_free (&buffer->obstack, obstack_base (&buffer->obstack));
- buffer->line_length = 0;
- buffer->cursor = NULL;
- buffer->emitted_prefix_p = 0;
+ output_clear_message_text (buffer);
+ clear_diagnostic_info (buffer);
}
-/* Finishes to construct a NULL-terminated character string representing
+/* Finishes constructing a NULL-terminated character string representing
the BUFFERed message. */
+
const char *
-output_finish (buffer)
+output_finalize_message (buffer)
output_buffer *buffer;
{
obstack_1grow (&buffer->obstack, '\0');
- return (const char *) obstack_finish (&buffer->obstack);
+ 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;
{
- return buffer->maximum_length - buffer->line_length;
+ return line_wrap_cutoff (buffer) - output_text_length (buffer);
}
/* Write out BUFFER's prefix. */
+
void
output_emit_prefix (buffer)
output_buffer *buffer;
{
- if (buffer->prefix)
+ if (output_prefix (buffer) != NULL)
{
- switch (buffer->prefixing_rule)
+ switch (diagnostic_prefixing_rule (buffer))
{
default:
case DIAGNOSTICS_SHOW_PREFIX_NEVER:
break;
case DIAGNOSTICS_SHOW_PREFIX_ONCE:
- if (buffer->emitted_prefix_p)
- break;
- else
- buffer->emitted_prefix_p = 1;
+ if (prefix_was_emitted_for (buffer))
+ {
+ output_indent (buffer);
+ break;
+ }
+ output_indentation (buffer) += 3;
/* Fall through. */
case DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE:
- buffer->line_length += strlen (buffer->prefix);
- obstack_grow
- (&buffer->obstack, buffer->prefix, buffer->line_length);
+ {
+ int prefix_length = strlen (output_prefix (buffer));
+ output_append_r (buffer, output_prefix (buffer), prefix_length);
+ prefix_was_emitted_for (buffer) = 1;
+ }
break;
}
}
}
/* Have BUFFER start a new line. */
+
void
output_add_newline (buffer)
output_buffer *buffer;
{
obstack_1grow (&buffer->obstack, '\n');
- buffer->line_length = 0;
+ output_text_length (buffer) = 0;
}
/* Appends a character to BUFFER. */
+
void
output_add_character (buffer, c)
output_buffer *buffer;
if (output_is_line_wrapping (buffer) && output_space_left (buffer) <= 0)
output_add_newline (buffer);
obstack_1grow (&buffer->obstack, c);
- ++buffer->line_length;
+ ++output_text_length (buffer);
}
/* Adds a space to BUFFER. */
+
void
output_add_space (buffer)
output_buffer *buffer;
return;
}
obstack_1grow (&buffer->obstack, ' ');
- ++buffer->line_length;
+ ++output_text_length (buffer);
}
/* These functions format an INTEGER into BUFFER as suggested by their
names. */
+
void
output_decimal (buffer, i)
output_buffer *buffer;
/* Append to BUFFER a string specified by its STARTING character
and LENGTH. */
+
static void
output_append_r (buffer, start, length)
output_buffer *buffer;
int length;
{
obstack_grow (&buffer->obstack, start, length);
- buffer->line_length += length;
+ output_text_length (buffer) += length;
}
/* Append a string deliminated by START and END to BUFFER. No wrapping is
- done. However, if beginning a new line then emit BUFFER->PREFIX and
- skip any leading whitespace if appropriate. The caller must ensure
+ done. However, if beginning a new line then emit output_prefix (BUFFER)
+ 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;
const char *end;
{
/* Emit prefix and skip whitespace if we're starting a new line. */
- if (buffer->line_length == 0)
+ if (is_starting_newline (buffer))
{
output_emit_prefix (buffer);
if (output_is_line_wrapping (buffer))
output_append_r (buffer, start, end - start);
}
+static void
+output_indent (buffer)
+ output_buffer *buffer;
+{
+ int n = output_indentation (buffer);
+ int i;
+
+ for (i = 0; i < n; ++i)
+ output_add_character (buffer, ' ');
+}
+
/* 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);
+
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 (p - start >= output_space_left (buffer))
+ if (is_wrapping && p - start >= output_space_left (buffer))
output_add_newline (buffer);
output_append (buffer, start, p);
start = p;
}
/* 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 maybe be line-wrapped if in
+/* Append a STRING to BUFFER; the STRING might be line-wrapped if in
appropriate mode. */
void
maybe_wrap_text (buffer, str, str + (str ? strlen (str) : 0));
}
-/* Flush the content of BUFFER onto FILE and reinitialize BUFFER. */
+/* Flush the content of BUFFER onto the attached stream,
+ and reinitialize. */
static void
-output_to_stream (buffer, file)
+output_buffer_to_stream (buffer)
output_buffer *buffer;
- FILE *file;
{
- const char *text = output_finish (buffer);
- fputs (text, file);
- output_clear (buffer);
+ const char *text = output_finalize_message (buffer);
+ fputs (text, output_buffer_attached_stream (buffer));
+ output_clear_message_text (buffer);
}
-/* Format a message pointed to by BUFFER->CURSOR using BUFFER->CURSOR
- as appropriate. The following format specifiers are recognized as
- being language independent:
+/* 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:
%d, %i: (signed) integer in base ten.
%u: unsigned integer in base ten.
- %o: (signed) integer in base eight.
- %x: (signged) integer in base sixteen.
+ %o: unsigned integer in base eight.
+ %x: unsigned integer in base sixteen.
%ld, %li, %lo, %lu, %lx: long versions of the above.
%c: character.
%s: string.
%%: `%'.
%*.s: a substring the length of which is specified by an integer. */
+
static void
output_format (buffer)
output_buffer *buffer;
{
- for (; *buffer->cursor; ++buffer->cursor)
+ for (; *output_buffer_text_cursor (buffer);
+ ++output_buffer_text_cursor (buffer))
{
int long_integer = 0;
+
/* Ignore text. */
{
- const char *p = buffer->cursor;
+ const char *p = output_buffer_text_cursor (buffer);
while (*p && *p != '%')
++p;
- maybe_wrap_text (buffer, buffer->cursor, p);
- buffer->cursor = p;
+ wrap_text (buffer, output_buffer_text_cursor (buffer), p);
+ output_buffer_text_cursor (buffer) = p;
}
- if (!*buffer->cursor)
+
+ if (!*output_buffer_text_cursor (buffer))
break;
/* We got a '%'. Let's see what happens. Record whether we're
parsing a long integer format specifier. */
- if (*++buffer->cursor == 'l')
+ if (*++output_buffer_text_cursor (buffer) == 'l')
{
long_integer = 1;
- ++buffer->cursor;
+ ++output_buffer_text_cursor (buffer);
}
/* 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 (*buffer->cursor)
+ switch (*output_buffer_text_cursor (buffer))
{
case 'c':
output_add_character
- (buffer, va_arg (buffer->format_args, int));
+ (buffer, va_arg (output_buffer_format_args (buffer), int));
break;
case 'd':
case 'i':
if (long_integer)
output_long_decimal
- (buffer, va_arg (buffer->format_args, long int));
+ (buffer, va_arg (output_buffer_format_args (buffer), long int));
else
- output_decimal (buffer, va_arg (buffer->format_args, int));
+ output_decimal
+ (buffer, va_arg (output_buffer_format_args (buffer), int));
break;
case 'o':
if (long_integer)
- output_long_octal
- (buffer, va_arg (buffer->format_args, unsigned long int));
+ output_long_octal (buffer,
+ va_arg (output_buffer_format_args (buffer),
+ unsigned long int));
else
- output_octal (buffer, va_arg (buffer->format_args, unsigned int));
+ output_octal (buffer,
+ va_arg (output_buffer_format_args (buffer),
+ unsigned int));
break;
case 's':
- output_add_string
- (buffer, va_arg (buffer->format_args, const char *));
+ output_add_string (buffer,
+ va_arg (output_buffer_format_args (buffer),
+ const char *));
break;
case 'u':
if (long_integer)
output_long_unsigned_decimal
- (buffer, va_arg (buffer->format_args, long unsigned int));
+ (buffer, va_arg (output_buffer_format_args (buffer),
+ long unsigned int));
else
output_unsigned_decimal
- (buffer, va_arg (buffer->format_args, unsigned int));
+ (buffer, va_arg (output_buffer_format_args (buffer),
+ unsigned int));
+ break;
case 'x':
if (long_integer)
output_long_hexadecimal
- (buffer, va_arg (buffer->format_args, unsigned long int));
+ (buffer, va_arg (output_buffer_format_args (buffer),
+ unsigned long int));
else
output_hexadecimal
- (buffer, va_arg (buffer->format_args, unsigned int));
+ (buffer, va_arg (output_buffer_format_args (buffer),
+ unsigned int));
break;
case '%':
int n;
const char *s;
/* We handle no precision specifier but `%.*s'. */
- if (*++buffer->cursor != '*')
+ if (*++output_buffer_text_cursor (buffer) != '*')
+ abort ();
+ else if (*++output_buffer_text_cursor (buffer) != 's')
abort ();
- else if (*++buffer->cursor != 's')
- abort();
- n = va_arg (buffer->format_args, int);
- s = va_arg (buffer->format_args, const char *);
+ 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);
}
break;
default:
- if (!lang_printer || !(*lang_printer) (buffer))
+ if (!buffer->format_decoder || !(*buffer->format_decoder) (buffer))
{
/* Hmmm. The front-end failed to install a format translator
but called us with an unrecognized format. Sorry. */
- abort();
+ abort ();
}
}
}
}
static char *
-vbuild_message_string (msgid, ap)
- const char *msgid;
+vbuild_message_string (msg, ap)
+ const char *msg;
va_list ap;
{
char *str;
- vasprintf (&str, msgid, ap);
+ vasprintf (&str, msg, ap);
return str;
}
-/* Return a malloc'd string containing MSGID formatted a la
- printf. The caller is reponsible for freeing the memory. */
+/* Return a malloc'd string containing MSG formatted a la
+ printf. The caller is responsible for freeing the memory. */
static char *
-build_message_string VPARAMS ((const char *msgid, ...))
+build_message_string VPARAMS ((const char *msg, ...))
{
-#ifndef ANSI_PROTOTYPES
- const char *msgid;
-#endif
- va_list ap;
char *str;
- VA_START (ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- msgid = va_arg (ap, const char *);
-#endif
+ VA_OPEN (ap, msg);
+ VA_FIXEDARG (ap, const char *, msg);
- str = vbuild_message_string (msgid, ap);
+ 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. */
-static char *
+char *
context_as_prefix (file, line, warn)
const char *file;
int line;
if (file)
{
if (warn)
- return build_message_string ("%s:%d: warning: ", file, line);
+ 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);
+ 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. */
+
+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, msgid)
+output_do_printf (buffer, msg)
output_buffer *buffer;
- const char *msgid;
+ const char *msg;
{
- char *message = vbuild_message_string (msgid, buffer->format_args);
+ char *message = vbuild_message_string (msg,
+ output_buffer_format_args (buffer));
- output_add_string (buffer, message);
+ wrap_text (buffer, message, message + strlen (message));
free (message);
}
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;
-
- VA_START (ap, msgid);
-#ifndef ANSI_PROTOTYPES
- buffer = va_arg (ap, struct output_buffer *);
- msgid = va_arg (ap, const char *);
-#endif
- va_copy (old_args, buffer->format_args);
-
- va_copy (buffer->format_args, ap);
- output_do_printf (buffer, msgid);
- va_end (buffer->format_args);
-
- va_copy (buffer->format_args, old_args);
-}
-
-
-/* Format a MESSAGE into FILE. Do line wrapping, starting new lines
- with PREFIX. */
-
-static void
-line_wrapper_printf VPARAMS ((FILE *file, const char *msgid, ...))
-{
-#ifndef ANSI_PROTOTYPES
- FILE *file;
- const char *msgid;
-#endif
- output_buffer buffer;
-
- default_initialize_buffer (&buffer);
- VA_START (buffer.format_args, msgid);
-
-#ifndef ANSI_PROTOTYPES
- file = va_arg (buffer.format_args, FILE *);
- msgid = va_arg (buffer.format_args, const char *);
-#endif
-
- output_do_printf (&buffer, msgid);
- output_to_stream (&buffer, file);
-
- va_end (buffer.format_args);
-}
-
-
-static void
-vline_wrapper_message_with_location (file, line, warn, msgid, ap)
- const char *file;
- int line;
- int warn;
- const char *msgid;
- va_list ap;
-{
- output_buffer buffer;
-
- init_output_buffer (&buffer, context_as_prefix (file, line, warn),
- diagnostic_message_length_per_line);
- va_copy (buffer.format_args, ap);
- output_do_printf (&buffer, msgid);
- output_to_stream (&buffer, stderr);
-
- output_destroy_prefix (&buffer);
- fputc ('\n', stderr);
-}
-
-
-/* Print the message MSGID in FILE. */
-
-static void
-vnotice (file, msgid, ap)
- FILE *file;
- const char *msgid;
- va_list ap;
-{
- vfprintf (file, _(msgid), ap);
-}
-
-/* Print MSGID on stderr. */
-
-static void
-notice VPARAMS ((const char *msgid, ...))
-{
-#ifndef ANSI_PROTOTYPES
- char *msgid;
-#endif
- va_list ap;
-
- VA_START (ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- msgid = va_arg (ap, char *);
-#endif
-
- vnotice (stderr, msgid, ap);
- va_end (ap);
-}
-
-/* Report FILE and LINE (or program name), and optionally just WARN. */
-
-static void
-report_file_and_line (file, line, warn)
- const char *file;
- int line;
- int warn;
-{
- if (file)
- fprintf (stderr, "%s:%d: ", file, line);
- else
- fprintf (stderr, "%s: ", progname);
-
- if (warn)
- notice ("warning: ");
-}
+ va_list *old_args;
-/* Print a message relevant to line LINE of file FILE. */
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, output_buffer *, buffer);
+ VA_FIXEDARG (ap, const char *, msgid);
-static void
-v_message_with_file_and_line (file, line, warn, msgid, ap)
- const char *file;
- int line;
- int warn;
- const char *msgid;
- va_list ap;
-{
- report_file_and_line (file, line, warn);
- vnotice (stderr, msgid, ap);
- fputc ('\n', stderr);
+ 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_CLOSE (ap);
}
/* Print a message relevant to the given DECL. */
static void
-v_message_with_decl (decl, warn, msgid, ap)
+format_with_decl (buffer, decl)
+ output_buffer *buffer;
tree decl;
- int warn;
- const char *msgid;
- va_list ap;
{
const char *p;
- output_buffer buffer;
-
- if (doing_line_wrapping ())
- {
- init_output_buffer
- (&buffer, context_as_prefix
- (DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl), warn),
- diagnostic_message_length_per_line);
- }
- else
- report_file_and_line (DECL_SOURCE_FILE (decl),
- DECL_SOURCE_LINE (decl), warn);
-
+
/* 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 = _(msgid); *p; ++p)
+ for (p = output_buffer_text_cursor (buffer); *p; ++p)
{
if (*p == '%')
{
}
}
- if (p > _(msgid)) /* Print the left-hand substring. */
- {
- if (doing_line_wrapping ())
- output_printf (&buffer, "%.*s", (int)(p - _(msgid)), _(msgid));
- else
- fprintf (stderr, "%.*s", (int)(p - _(msgid)), _(msgid));
- }
-
+ /* Print the left-hand substring. */
+ maybe_wrap_text (buffer, output_buffer_text_cursor (buffer), p);
+
if (*p == '%') /* Print the name. */
{
- const char *n = (DECL_NAME (decl)
- ? (*decl_printable_name) (decl, 2)
- : _("((anonymous))"));
- if (doing_line_wrapping ())
- output_add_string (&buffer, n);
- else
- fputs (n, stderr);
+ const char *const n = (DECL_NAME (decl)
+ ? (*decl_printable_name) (decl, 2)
+ : _("((anonymous))"));
+ output_add_string (buffer, n);
while (*p)
{
++p;
if (*p) /* Print the rest of the message. */
{
- if (doing_line_wrapping ())
- {
- va_copy (buffer.format_args, ap);
- output_do_printf (&buffer, p);
- va_copy (ap, buffer.format_args);
- }
- else
- vfprintf (stderr, p, ap);
- }
-
- if (doing_line_wrapping())
- {
- output_to_stream (&buffer, stderr);
- output_destroy_prefix (&buffer);
+ output_buffer_text_cursor (buffer) = p;
+ output_format (buffer);
}
-
- fputc ('\n', stderr);
}
-/* Figure file and line of the given INSN. */
+
+/* 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
-file_and_line_for_asm (insn, pfile, pline)
- rtx insn;
- const char **pfile;
- int *pline;
-{
- rtx body = PATTERN (insn);
- rtx asmop;
-
- /* Find the (or one of the) ASM_OPERANDS in the insn. */
- if (GET_CODE (body) == SET && GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
- asmop = SET_SRC (body);
- else if (GET_CODE (body) == ASM_OPERANDS)
- asmop = body;
- else if (GET_CODE (body) == PARALLEL
- && GET_CODE (XVECEXP (body, 0, 0)) == SET)
- asmop = SET_SRC (XVECEXP (body, 0, 0));
- else if (GET_CODE (body) == PARALLEL
- && GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
- asmop = XVECEXP (body, 0, 0);
- else
- asmop = NULL;
+diagnostic_for_decl (decl, msgid, args_ptr, warn)
+ tree decl;
+ const char *msgid;
+ va_list *args_ptr;
+ int warn;
+{
+ output_state os;
- if (asmop)
- {
- *pfile = ASM_OPERANDS_SOURCE_FILE (asmop);
- *pline = ASM_OPERANDS_SOURCE_LINE (asmop);
- }
- else
+ if (diagnostic_lock++)
+ error_recursion ();
+
+ if (count_error (warn))
{
- *pfile = input_filename;
- *pline = lineno;
+ os = output_buffer_state (diagnostic_buffer);
+ report_error_function (DECL_SOURCE_FILE (decl));
+ 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;
}
+ diagnostic_lock--;
}
-/* Report an error at line LINE of file FILE. */
+\f
+/* Count an error or warning. Return 1 if the message should be printed. */
-static void
-v_error_with_file_and_line (file, line, msgid, ap)
- const char *file;
- int line;
- const char *msgid;
- va_list ap;
+int
+count_error (warningp)
+ int warningp;
{
- count_error (0);
- report_error_function (file);
- if (doing_line_wrapping ())
- vline_wrapper_message_with_location (file, line, 0, msgid, ap);
+ if (warningp && !diagnostic_report_warnings_p ())
+ return 0;
+
+ if (warningp && !warnings_are_errors)
+ warningcount++;
else
- v_message_with_file_and_line (file, line, 0, msgid, ap);
-}
+ {
+ static int warning_message = 0;
-/* Report an error at the declaration DECL.
- MSGID is a format string which uses %s to substitute the declaration
- name; subsequent substitutions are a la printf. */
+ if (warningp && !warning_message)
+ {
+ verbatim ("%s: warnings being treated as errors\n", progname);
+ warning_message = 1;
+ }
+ errorcount++;
+ }
-static void
-v_error_with_decl (decl, msgid, ap)
- tree decl;
- const char *msgid;
- va_list ap;
-{
- count_error (0);
- report_error_function (DECL_SOURCE_FILE (decl));
- v_message_with_decl (decl, 0, msgid, ap);
+ return 1;
}
+/* Print a diagnostic MSGID on FILE. This is just fprintf, except it
+ runs its second argument through gettext. */
-/* Report an error at the line number of the insn INSN.
- This is used only when INSN is an `asm' with operands,
- and each ASM_OPERANDS records its own source file and line. */
-
-static void
-v_error_for_asm (insn, msgid, ap)
- rtx insn;
- const char *msgid;
- va_list ap;
+void
+fnotice VPARAMS ((FILE *file, const char *msgid, ...))
{
- const char *file;
- int line;
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, FILE *, file);
+ VA_FIXEDARG (ap, const char *, msgid);
- count_error (0);
- file_and_line_for_asm (insn, &file, &line);
- report_error_function (file);
- v_message_with_file_and_line (file, line, 0, msgid, ap);
+ vfprintf (file, _(msgid), ap);
+ VA_CLOSE (ap);
}
-/* Report an error at the current line number. */
+/* Print a fatal I/O error message. Argument are like printf.
+ Also include a system error message based on `errno'. */
void
-verror (msgid, ap)
- const char *msgid;
- va_list ap;
+fatal_io_error VPARAMS ((const char *msgid, ...))
{
- v_error_with_file_and_line (input_filename, lineno, msgid, ap);
-}
+ output_state os;
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, const char *, msgid);
-/* Report a fatal error at the current line number. Allow a front end to
- intercept the message. */
-
-static void (*fatal_function) PARAMS ((const char *, va_list));
+ os = output_buffer_state (diagnostic_buffer);
-static void
-vfatal (msgid, ap)
- const char *msgid;
- va_list ap;
-{
- if (fatal_function != 0)
- (*fatal_function) (_(msgid), ap);
-
- verror (msgid, ap);
+ 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_CLOSE (ap);
exit (FATAL_EXIT_CODE);
}
-/* Report a warning at line LINE of file FILE. */
-
-static void
-v_warning_with_file_and_line (file, line, msgid, ap)
- const char *file;
- int line;
- const char *msgid;
- va_list ap;
-{
- if (count_error (1))
- {
- report_error_function (file);
- if (doing_line_wrapping ())
- vline_wrapper_message_with_location (file, line, 1, msgid, ap);
- else
- v_message_with_file_and_line (file, line, 1, msgid, ap);
- }
-}
-
-
-/* Report a warning at the declaration DECL.
- MSGID is a format string which uses %s to substitute the declaration
- name; subsequent substitutions are a la printf. */
+/* Issue a pedantic warning MSGID. */
-static void
-v_warning_with_decl (decl, msgid, ap)
- tree decl;
- const char *msgid;
- va_list ap;
+void
+pedwarn VPARAMS ((const char *msgid, ...))
{
- if (count_error (1))
- {
- report_error_function (DECL_SOURCE_FILE (decl));
- v_message_with_decl (decl, 1, msgid, ap);
- }
-}
-
-
-/* Report a warning at the line number of the insn INSN.
- This is used only when INSN is an `asm' with operands,
- and each ASM_OPERANDS records its own source file and line. */
+ diagnostic_context dc;
-static void
-v_warning_for_asm (insn, msgid, ap)
- rtx insn;
- const char *msgid;
- va_list ap;
-{
- if (count_error (1))
- {
- const char *file;
- int line;
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, const char *, msgid);
- file_and_line_for_asm (insn, &file, &line);
- report_error_function (file);
- v_message_with_file_and_line (file, line, 1, msgid, ap);
- }
+ set_diagnostic_context
+ (&dc, msgid, &ap, input_filename, lineno, !flag_pedantic_errors);
+ report_diagnostic (&dc);
+ VA_CLOSE (ap);
}
-
-/* Report a warning at the current line number. */
-
-void
-vwarning (msgid, ap)
- const char *msgid;
- va_list ap;
-{
- v_warning_with_file_and_line (input_filename, lineno, msgid, ap);
-}
-
-/* These functions issue either warnings or errors depending on
- -pedantic-errors. */
+/* Issue a pedantic waring about DECL. */
void
-vpedwarn (msgid, ap)
- const char *msgid;
- va_list ap;
+pedwarn_with_decl VPARAMS ((tree decl, const char *msgid, ...))
{
- if (flag_pedantic_errors)
- verror (msgid, ap);
- else
- vwarning (msgid, ap);
-}
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, tree, decl);
+ VA_FIXEDARG (ap, const char *, msgid);
-
-static void
-v_pedwarn_with_decl (decl, msgid, ap)
- tree decl;
- const char *msgid;
- va_list ap;
-{
/* 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
which will cause programs to mysteriously fail because the C library
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))
- {
- if (flag_pedantic_errors)
- v_error_with_decl (decl, msgid, ap);
- else
- v_warning_with_decl (decl, msgid, ap);
- }
+ if (!DECL_IN_SYSTEM_HEADER (decl))
+ diagnostic_for_decl (decl, msgid, &ap, !flag_pedantic_errors);
+ VA_CLOSE (ap);
}
+/* Same as above but within the context FILE and LINE. */
-static void
-v_pedwarn_with_file_and_line (file, line, msgid, ap)
- const char *file;
- int line;
- const char *msgid;
- va_list ap;
-{
- if (flag_pedantic_errors)
- v_error_with_file_and_line (file, line, msgid, ap);
- else
- v_warning_with_file_and_line (file, line, msgid, ap);
-}
-
-
-/* Apologize for not implementing some feature. */
-
-static void
-vsorry (msgid, ap)
- const char *msgid;
- va_list ap;
-{
- sorrycount++;
- if (input_filename)
- fprintf (stderr, "%s:%d: ", input_filename, lineno);
- else
- fprintf (stderr, "%s: ", progname);
- notice ("sorry, not implemented: ");
- vnotice (stderr, msgid, ap);
- fputc ('\n', stderr);
-}
-
-\f
-/* Count an error or warning. Return 1 if the message should be printed. */
-
-int
-count_error (warningp)
- int warningp;
-{
- if (warningp && inhibit_warnings)
- return 0;
-
- if (warningp && !warnings_are_errors)
- warningcount++;
- else
- {
- static int warning_message = 0;
-
- if (warningp && !warning_message)
- {
- verbatim ("%s: warnings being treated as errors\n", progname);
- warning_message = 1;
- }
- errorcount++;
- }
-
- return 1;
-}
-
-/* Print a diagnistic MSGID on FILE. */
-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
-
- vnotice (file, msgid, ap);
- va_end (ap);
-}
-
-
-/* Print a fatal error message. NAME is the text.
- Also include a system error message based on `errno'. */
-
-void
-pfatal_with_name (name)
- const char *name;
-{
- fprintf (stderr, "%s: ", progname);
- perror (name);
- exit (FATAL_EXIT_CODE);
-}
-
-void
-fatal_io_error (name)
- const char *name;
-{
- notice ("%s: %s: I/O error\n", progname, name);
- 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;
-
- VA_START (ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- msgid = va_arg (ap, const char *);
-#endif
-
- vpedwarn (msgid, ap);
- va_end (ap);
-}
-
-/* Issue a pedantic waring about DECL. */
-void
-pedwarn_with_decl VPARAMS ((tree decl, const char *msgid, ...))
-{
-#ifndef ANSI_PROTOTYPES
- tree decl;
- const char *msgid;
-#endif
- va_list ap;
-
- VA_START (ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- decl = va_arg (ap, tree);
- msgid = va_arg (ap, const char *);
-#endif
-
- v_pedwarn_with_decl (decl, msgid, ap);
- va_end (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;
-
- VA_START (ap, msgid);
+ diagnostic_context dc;
-#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);
- v_pedwarn_with_file_and_line (file, line, msgid, ap);
- va_end (ap);
+ set_diagnostic_context (&dc, msgid, &ap, file, line, !flag_pedantic_errors);
+ report_diagnostic (&dc);
+ 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;
- 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;
+ os = output_buffer_state (diagnostic_buffer);
- vsorry (msgid, ap);
- va_end (ap);
+ 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_CLOSE (ap);
}
/* Called when the start of a function definition is parsed,
if (! quiet_flag)
{
if (rtl_dump_and_exit)
- fprintf (stderr, "%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));
+ verbatim ("%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));
else
- {
- if (doing_line_wrapping ())
- line_wrapper_printf
- (stderr, " %s", (*decl_printable_name) (decl, 2));
- else
- fprintf (stderr, " %s", (*decl_printable_name) (decl, 2));
- }
+ verbatim (" %s", (*decl_printable_name) (decl, 2));
fflush (stderr);
- need_error_newline = 1;
- last_error_function = current_function_decl;
+ output_needs_newline (diagnostic_buffer) = 1;
+ record_last_error_function ();
}
}
an error. */
void
-default_print_error_function (file)
- const char *file;
+default_print_error_function (context, file)
+ diagnostic_context *context;
+ const char *file;
{
- if (last_error_function != current_function_decl)
+ if (error_function_changed ())
{
- char *prefix = NULL;
- output_buffer buffer;
-
- if (file)
- prefix = build_message_string ("%s: ", file);
+ char *prefix = file ? build_message_string ("%s: ", file) : NULL;
+ output_state os;
- if (doing_line_wrapping ())
- init_output_buffer
- (&buffer, prefix, diagnostic_message_length_per_line);
- else
- {
- if (file)
- fprintf (stderr, "%s: ", file);
- }
+ os = output_buffer_state (context);
+ output_set_prefix ((output_buffer *) context, prefix);
if (current_function_decl == NULL)
- {
- if (doing_line_wrapping ())
- output_printf (&buffer, "At top level:\n");
- else
- notice ("At top level:\n");
- }
+ output_add_string ((output_buffer *) context, _("At top level:"));
else
{
if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
- {
- if (doing_line_wrapping ())
- output_printf
- (&buffer, "In method `%s':\n",
- (*decl_printable_name) (current_function_decl, 2));
- else
- notice ("In method `%s':\n",
- (*decl_printable_name) (current_function_decl, 2));
- }
+ output_printf
+ ((output_buffer *) context, "In member function `%s':",
+ (*decl_printable_name) (current_function_decl, 2));
else
- {
- if (doing_line_wrapping ())
- output_printf
- (&buffer, "In function `%s':\n",
- (*decl_printable_name) (current_function_decl, 2));
- else
- notice ("In function `%s':\n",
- (*decl_printable_name) (current_function_decl, 2));
- }
+ output_printf
+ ((output_buffer *) context, "In function `%s':",
+ (*decl_printable_name) (current_function_decl, 2));
}
+ output_add_newline ((output_buffer *) context);
- last_error_function = current_function_decl;
-
- if (doing_line_wrapping ())
- output_to_stream (&buffer, stderr);
-
+ record_last_error_function ();
+ output_buffer_to_stream ((output_buffer *) context);
+ output_buffer_state (context) = os;
free ((char*) prefix);
}
}
report_error_function (file)
const char *file ATTRIBUTE_UNUSED;
{
- struct file_stack *p;
-
- if (need_error_newline)
- {
- verbatim ("\n");
- need_error_newline = 0;
- }
-
- if (input_file_stack && input_file_stack->next != 0
- && input_file_stack_tick != last_error_tick)
- {
- for (p = input_file_stack->next; p; p = p->next)
- if (p == input_file_stack->next)
- verbatim ("In file included from %s:%d", p->name, p->line);
- else
- verbatim (",\n from %s:%d", p->name, p->line);
- verbatim (":\n");
- last_error_tick = input_file_stack_tick;
- }
-
- (*print_error_function) (input_filename);
+ report_problematic_module ((output_buffer *) global_dc);
+ (*print_error_function) (global_dc, 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;
- 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
-
- v_error_with_file_and_line (file, line, msgid, ap);
- va_end (ap);
+ set_diagnostic_context (&dc, msgid, &ap, file, line, /* warn = */ 0);
+ report_diagnostic (&dc);
+ 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;
-
- VA_START (ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- decl = va_arg (ap, tree);
- msgid = va_arg (ap, const char *);
-#endif
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, tree, decl);
+ VA_FIXEDARG (ap, const char *, msgid);
- v_error_with_decl (decl, msgid, ap);
- va_end (ap);
+ diagnostic_for_decl (decl, msgid, &ap, /* warn = */ 0);
+ VA_CLOSE (ap);
}
-void
-error_for_asm VPARAMS ((rtx insn, const char *msgid, ...))
-{
-#ifndef ANSI_PROTOTYPES
- rtx insn;
- const char *msgid;
-#endif
- va_list ap;
- VA_START (ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- insn = va_arg (ap, rtx);
- msgid = va_arg (ap, const char *);
-#endif
-
- v_error_for_asm (insn, msgid, ap);
- va_end (ap);
-}
+/* Report an error message. The arguments are like that of printf. */
void
error VPARAMS ((const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- const char *msgid;
-#endif
- va_list ap;
+ diagnostic_context dc;
- VA_START (ap, msgid);
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, const char *, msgid);
-#ifndef ANSI_PROTOTYPES
- msgid = va_arg (ap, const char *);
-#endif
-
- verror (msgid, ap);
- va_end (ap);
+ set_diagnostic_context
+ (&dc, msgid, &ap, input_filename, lineno, /* warn = */ 0);
+ report_diagnostic (&dc);
+ VA_CLOSE (ap);
}
-/* Set the function to call when a fatal error occurs. */
+/* Likewise, except that the compilation is terminated after printing the
+ error message. */
void
-set_fatal_function (f)
- void (*f) PARAMS ((const char *, va_list));
+fatal_error VPARAMS ((const char *msgid, ...))
{
- fatal_function = f;
-}
+ diagnostic_context dc;
-void
-fatal VPARAMS ((const char *msgid, ...))
-{
-#ifndef ANSI_PROTOTYPES
- const char *msgid;
-#endif
- va_list ap;
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, const char *, msgid);
- VA_START (ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- msgid = va_arg (ap, const char *);
-#endif
+ set_diagnostic_context
+ (&dc, msgid, &ap, input_filename, lineno, /* warn = */ 0);
+ report_diagnostic (&dc);
+ VA_CLOSE (ap);
- vfatal (msgid, ap);
- va_end (ap);
+ fnotice (stderr, "compilation terminated.\n");
+ exit (FATAL_EXIT_CODE);
}
-void
-_fatal_insn (msgid, insn, file, line, function)
- const char *msgid;
- rtx insn;
- const char *file;
- int line;
- const char *function;
-{
- error ("%s", msgid);
- debug_rtx (insn);
- fancy_abort (file, line, function);
-}
+/* 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
-_fatal_insn_not_found (insn, file, line, function)
- rtx insn;
- const char *file;
- int line;
- const char *function;
+set_internal_error_function (f)
+ void (*f) PARAMS ((const char *, va_list *));
{
- if (INSN_CODE (insn) < 0)
- _fatal_insn ("Unrecognizable insn:", insn, file, line, function);
- else
- _fatal_insn ("Insn does not satisfy its constraints:",
- insn, file, line, function);
+ internal_error_function = f;
}
void
-warning_with_file_and_line VPARAMS ((const char *file, int line,
- const char *msgid, ...))
+internal_error VPARAMS ((const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- const char *file;
- int line;
- const char *msgid;
-#endif
- va_list ap;
+ diagnostic_context dc;
+
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, const char *, msgid);
- VA_START (ap, msgid);
+ if (diagnostic_lock)
+ error_recursion ();
-#ifndef ANSI_PROTOTYPES
- file = va_arg (ap, const char *);
- line = va_arg (ap, int);
- msgid = va_arg (ap, const char *);
+#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
- v_warning_with_file_and_line (file, line, msgid, ap);
- va_end (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_CLOSE (ap);
+
+ fnotice (stderr,
+"Please submit a full bug report,\n\
+with preprocessed source if appropriate.\n\
+See %s for instructions.\n", GCCBUGURL);
+ exit (FATAL_EXIT_CODE);
}
void
-warning_with_decl VPARAMS ((tree decl, const char *msgid, ...))
+warning_with_file_and_line VPARAMS ((const char *file, int line,
+ const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- tree decl;
- const char *msgid;
-#endif
- va_list ap;
+ diagnostic_context dc;
- 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
- decl = va_arg (ap, tree);
- msgid = va_arg (ap, const char *);
-#endif
-
- v_warning_with_decl (decl, msgid, ap);
- va_end (ap);
+ set_diagnostic_context (&dc, msgid, &ap, file, line, /* warn = */ 1);
+ report_diagnostic (&dc);
+ VA_CLOSE (ap);
}
void
-warning_for_asm VPARAMS ((rtx insn, const char *msgid, ...))
+warning_with_decl VPARAMS ((tree decl, const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- rtx insn;
- const char *msgid;
-#endif
- va_list ap;
-
- VA_START (ap, msgid);
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, tree, decl);
+ VA_FIXEDARG (ap, const char *, msgid);
-#ifndef ANSI_PROTOTYPES
- insn = va_arg (ap, rtx);
- msgid = va_arg (ap, const char *);
-#endif
-
- v_warning_for_asm (insn, msgid, ap);
- va_end (ap);
+ diagnostic_for_decl (decl, msgid, &ap, /* warn = */ 1);
+ 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);
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, const char *, msgid);
-#ifndef ANSI_PROTOTYPES
- msgid = va_arg (ap, const char *);
-#endif
-
- vwarning (msgid, ap);
- va_end (ap);
+ set_diagnostic_context
+ (&dc, msgid, &ap, input_filename, lineno, /* warn = */ 1);
+ report_diagnostic (&dc);
+ VA_CLOSE (ap);
}
-/* Save BUFFER's STATE. */
-static void
-save_output_state (buffer, state)
- const output_buffer *buffer;
- output_state *state;
-{
- state->prefix = buffer->prefix;
- state->maximum_length = buffer->maximum_length;
- state->ideal_maximum_length = buffer->ideal_maximum_length;
- state->emitted_prefix_p = buffer->emitted_prefix_p;
- state->prefixing_rule = buffer->prefixing_rule;
- state->cursor = buffer->cursor;
- va_copy (state->format_args, buffer->format_args);
-}
+/* Flush diagnostic_buffer content on stderr. */
-/* Restore BUFFER's previously saved STATE. */
static void
-restore_output_state (state, buffer)
- const output_state *state;
+diagnostic_finish (buffer)
output_buffer *buffer;
{
- buffer->prefix = state->prefix;
- buffer->maximum_length = state->maximum_length;
- buffer->ideal_maximum_length = state->ideal_maximum_length;
- buffer->emitted_prefix_p = state->emitted_prefix_p;
- buffer->prefixing_rule = state->prefixing_rule;
- buffer->cursor = state->cursor;
- va_copy (buffer->format_args, state->format_args);
-}
-
-/* Flush diagnostic_buffer content on stderr. */
-static void
-finish_diagnostic ()
-{
- output_to_stream (diagnostic_buffer, stderr);
- fputc ('\n', stderr);
- fflush (stderr);
+ 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
+/* Helper subroutine of output_verbatim and verbatim. Do the appropriate
settings needed by BUFFER for a verbatim formatting. */
+
static void
-output_do_verbatim (buffer, msg, args)
+output_do_verbatim (buffer, msgid, args_ptr)
output_buffer *buffer;
- const char *msg;
- va_list args;
+ const char *msgid;
+ va_list *args_ptr;
{
output_state os;
- save_output_state (buffer, &os);
- buffer->prefix = NULL;
- buffer->prefixing_rule = DIAGNOSTICS_SHOW_PREFIX_NEVER;
- buffer->cursor = msg;
- va_copy (buffer->format_args, args);
+ 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);
- va_end (buffer->format_args);
- restore_output_state (&os, buffer);
+ output_buffer_state (buffer) = os;
}
/* Output MESSAGE verbatim into BUFFER. */
+
void
-output_verbatim VPARAMS ((output_buffer *buffer, const char *msg, ...))
+output_verbatim VPARAMS ((output_buffer *buffer, const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- output_buffer *buffer;
- const char *msg;
-#endif
- va_list ap;
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, output_buffer *, buffer);
+ VA_FIXEDARG (ap, const char *, msgid);
- VA_START (ap, msg);
-#ifndef ANSI_PROTOTYPES
- buffer = va_arg (ap, output_buffer *);
- msg = va_arg (ap, const char *);
-#endif
- output_do_verbatim (buffer, msg, ap);
- va_end (ap);
+ output_do_verbatim (buffer, msgid, &ap);
+ VA_CLOSE (ap);
}
/* Same as above but use diagnostic_buffer. */
+
+void
+verbatim VPARAMS ((const char *msgid, ...))
+{
+ VA_OPEN (ap, msgid);
+ VA_FIXEDARG (ap, const char *, msgid);
+
+ output_do_verbatim (diagnostic_buffer, msgid, &ap);
+ output_buffer_to_stream (diagnostic_buffer);
+ VA_CLOSE (ap);
+}
+
+/* Report a diagnostic message (an error or a warning) as specified by
+ DC. This function is *the* subroutine in terms of which front-ends
+ should implement their specific diagnostic handling modules. The
+ front-end independent format specifiers are exactly those described
+ in the documentation of output_format. */
+
void
-verbatim VPARAMS ((const char *msg, ...))
+report_diagnostic (dc)
+ diagnostic_context *dc;
{
-#ifndef ANSI_PROTOTYPES
- const char *msg;
+ output_state os;
+
+ if (diagnostic_lock++)
+ error_recursion ();
+
+ if (count_error (diagnostic_is_warning (dc)))
+ {
+ 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_lock--;
+}
+
+/* Inform the user that an error occurred while trying to report some
+ other error. This indicates catastrophic internal inconsistencies,
+ so give up now. But do try to flush out the previous error.
+ This mustn't use internal_error, that will cause infinite recursion. */
+
+static void
+error_recursion ()
+{
+ if (diagnostic_lock < 3)
+ diagnostic_finish ((output_buffer *) global_dc);
+
+ 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);
+ exit (FATAL_EXIT_CODE);
+}
+
+/* Given a partial pathname as input, return another pathname that
+ shares no directory elements with the pathname of __FILE__. This
+ is used by fancy_abort() to print `Internal compiler error in expr.c'
+ instead of `Internal compiler error in ../../GCC/gcc/expr.c'. */
+
+const char *
+trim_filename (name)
+ const char *name;
+{
+ static const char this_file[] = __FILE__;
+ const char *p = name, *q = this_file;
+
+ /* First skip any "../" in each filename. This allows us to give a proper
+ reference to a file in a subdirectory. */
+ while (p[0] == '.' && p[1] == '.'
+ && (p[2] == DIR_SEPARATOR
+#ifdef DIR_SEPARATOR_2
+ || p[2] == DIR_SEPARATOR_2
#endif
- va_list ap;
+ ))
+ p += 3;
- VA_START (ap, msg);
-#ifndef ANSI_PROTOTYPES
- msg = va_arg (ap, const char *);
+ while (q[0] == '.' && q[1] == '.'
+ && (q[2] == DIR_SEPARATOR
+#ifdef DIR_SEPARATOR_2
+ || p[2] == DIR_SEPARATOR_2
#endif
- output_do_verbatim (diagnostic_buffer, msg, ap);
- output_to_stream (diagnostic_buffer, stderr);
- va_end (ap);
+ ))
+ q += 3;
+
+ /* Now skip any parts the two filenames have in common. */
+ while (*p == *q && *p != 0 && *q != 0)
+ p++, q++;
+
+ /* Now go backwards until the previous directory separator. */
+ while (p > name && p[-1] != DIR_SEPARATOR
+#ifdef DIR_SEPARATOR_2
+ && p[-1] != DIR_SEPARATOR_2
+#endif
+ )
+ p--;
+
+ return p;
}
-/* Report a diagnostic MESSAGE (an error or a WARNING) involving
- entities in ARGUMENTS. FILE and LINE indicate where the diagnostic
- occurs. This function is *the* subroutine in terms of which front-ends
- should implement their specific diagnostic handling modules.
- The front-end independent format specifiers are exactly those described
- in the documentation of output_format. */
+/* Report an internal compiler error in a friendly manner and without
+ dumping core. */
+
void
-report_diagnostic (msg, args, file, line, warn)
- const char *msg;
- va_list args;
+fancy_abort (file, line, function)
+ const char *file;
+ 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;
{
- output_state os;
+ 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);
+}
- save_output_state (diagnostic_buffer, &os);
- diagnostic_msg = msg;
- va_copy (diagnostic_args, args);
- if (count_error (warn))
+void
+report_problematic_module (buffer)
+ output_buffer *buffer;
+{
+ struct file_stack *p;
+
+ if (output_needs_newline (buffer))
{
- report_error_function (file);
- output_set_prefix
- (diagnostic_buffer, context_as_prefix (file, line, warn));
- output_format (diagnostic_buffer);
- finish_diagnostic();
- output_destroy_prefix (diagnostic_buffer);
+ output_add_newline (buffer);
+ output_needs_newline (buffer) = 0;
+ }
+
+ if (input_file_stack && input_file_stack->next != 0
+ && error_module_changed ())
+ {
+ 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);
+ else
+ output_verbatim
+ (buffer, ",\n from %s:%d", p->name, p->line);
+ output_verbatim (buffer, ":\n");
+ record_last_error_module ();
+ }
+}
+
+static void
+default_diagnostic_starter (buffer, dc)
+ output_buffer *buffer;
+ diagnostic_context *dc;
+{
+ 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)));
+}
+
+static void
+default_diagnostic_finalizer (buffer, dc)
+ output_buffer *buffer;
+ diagnostic_context *dc __attribute__((__unused__));
+{
+ output_destroy_prefix (buffer);
+}
+
+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");
}
- va_end (diagnostic_args);
- restore_output_state (&os, diagnostic_buffer);
}
OSDN Git Service
