/* Language-independent diagnostic subroutines for the GNU Compiler Collection
Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
- 2009 Free Software Foundation, Inc.
+ 2009, 2010 Free Software Foundation, Inc.
Contributed by Gabriel Dos Reis <gdr@codesourcery.com>
This file is part of GCC.
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 "coretypes.h"
-#include "tm.h"
-#include "tree.h"
#include "version.h"
-#include "tm_p.h"
-#include "flags.h"
#include "input.h"
-#include "toplev.h"
#include "intl.h"
#include "diagnostic.h"
-#include "langhooks.h"
-#include "langhooks-def.h"
-#include "opts.h"
-#include "plugin.h"
-#define pedantic_warning_kind() (flag_pedantic_errors ? DK_ERROR : DK_WARNING)
-#define permissive_error_kind() (flag_permissive ? DK_WARNING : DK_ERROR)
+#define pedantic_warning_kind(DC) \
+ ((DC)->pedantic_errors ? DK_ERROR : DK_WARNING)
+#define permissive_error_kind(DC) ((DC)->permissive ? DK_WARNING : DK_ERROR)
+#define permissive_error_option(DC) ((DC)->opt_permissive)
/* Prototypes. */
static char *build_message_string (const char *, ...) ATTRIBUTE_PRINTF_1;
-static void default_diagnostic_starter (diagnostic_context *,
- diagnostic_info *);
-static void default_diagnostic_finalizer (diagnostic_context *,
- diagnostic_info *);
-
static void error_recursion (diagnostic_context *) ATTRIBUTE_NORETURN;
static void diagnostic_action_after_output (diagnostic_context *,
diagnostic_info *);
static void real_abort (void) ATTRIBUTE_NORETURN;
+/* Name of program invoked, sans directories. */
+
+const char *progname;
+
/* A diagnostic_context surrogate for stderr. */
static diagnostic_context global_diagnostic_context;
diagnostic_context *global_dc = &global_diagnostic_context;
\f
/* Initialize the diagnostic message outputting machinery. */
void
-diagnostic_initialize (diagnostic_context *context)
+diagnostic_initialize (diagnostic_context *context, int n_opts)
{
+ int i;
+
/* Allocate a basic pretty-printer. Clients will replace this a
much more elaborated pretty-printer if they wish. */
context->printer = XNEW (pretty_printer);
context->printer->wrapping.rule = DIAGNOSTICS_SHOW_PREFIX_ONCE;
memset (context->diagnostic_count, 0, sizeof context->diagnostic_count);
- context->issue_warnings_are_errors_message = true;
+ context->some_warnings_are_errors = false;
context->warning_as_error_requested = false;
- memset (context->classify_diagnostic, DK_UNSPECIFIED,
- sizeof context->classify_diagnostic);
+ context->n_opts = n_opts;
+ context->classify_diagnostic = XNEWVEC (diagnostic_t, n_opts);
+ for (i = 0; i < n_opts; i++)
+ context->classify_diagnostic[i] = DK_UNSPECIFIED;
context->show_option_requested = false;
context->abort_on_error = false;
+ context->show_column = false;
+ context->pedantic_errors = false;
+ context->permissive = false;
+ context->opt_permissive = 0;
+ context->fatal_errors = false;
+ context->inhibit_warnings = false;
+ context->warn_system_headers = false;
context->internal_error = NULL;
diagnostic_starter (context) = default_diagnostic_starter;
diagnostic_finalizer (context) = default_diagnostic_finalizer;
+ context->option_enabled = NULL;
+ context->option_name = NULL;
context->last_module = 0;
- context->last_function = NULL;
+ context->x_data = NULL;
context->lock = 0;
+ context->inhibit_notes_p = false;
+}
+
+/* Do any cleaning up required after the last diagnostic is emitted. */
+
+void
+diagnostic_finish (diagnostic_context *context)
+{
+ /* Some of the errors may actually have been warnings. */
+ if (context->some_warnings_are_errors)
+ {
+ /* -Werror was given. */
+ if (context->warning_as_error_requested)
+ pp_verbatim (context->printer,
+ _("%s: all warnings being treated as errors\n"),
+ progname);
+ /* At least one -Werror= was given. */
+ else
+ pp_verbatim (context->printer,
+ _("%s: some warnings being treated as errors\n"),
+ progname);
+ pp_flush (context->printer);
+ }
}
/* Initialize DIAGNOSTIC, where the message MSG has already been
/* Return a malloc'd string describing a location. The caller is
responsible for freeing the memory. */
char *
-diagnostic_build_prefix (diagnostic_info *diagnostic)
+diagnostic_build_prefix (diagnostic_context *context,
+ diagnostic_info *diagnostic)
{
static const char *const diagnostic_kind_text[] = {
#define DEFINE_DIAGNOSTIC_KIND(K, T) (T),
return
(s.file == NULL
? build_message_string ("%s: %s", progname, text)
- : flag_show_column
+ : context->show_column
? build_message_string ("%s:%d:%d: %s", s.file, s.line, s.column, text)
: build_message_string ("%s:%d: %s", s.file, s.line, text));
}
case DK_SORRY:
if (context->abort_on_error)
real_abort ();
- if (flag_fatal_errors)
+ if (context->fatal_errors)
{
fnotice (stderr, "compilation terminated due to -Wfatal-errors.\n");
+ diagnostic_finish (context);
exit (FATAL_EXIT_CODE);
}
break;
case DK_FATAL:
if (context->abort_on_error)
real_abort ();
-
+ diagnostic_finish (context);
fnotice (stderr, "compilation terminated.\n");
exit (FATAL_EXIT_CODE);
}
}
-/* Prints out, if necessary, the name of the current function
- that caused an error. Called from all error and warning functions. */
-void
-diagnostic_report_current_function (diagnostic_context *context,
- diagnostic_info *diagnostic)
-{
- diagnostic_report_current_module (context);
- lang_hooks.print_error_function (context, input_filename, diagnostic);
-}
-
void
diagnostic_report_current_module (diagnostic_context *context)
{
if (! MAIN_FILE_P (map))
{
map = INCLUDED_FROM (line_table, map);
- if (flag_show_column)
+ if (context->show_column)
pp_verbatim (context->printer,
"In file included from %s:%d:%d",
map->to_file,
}
}
-static void
+void
default_diagnostic_starter (diagnostic_context *context,
diagnostic_info *diagnostic)
{
- diagnostic_report_current_function (context, diagnostic);
- pp_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
+ diagnostic_report_current_module (context);
+ pp_set_prefix (context->printer, diagnostic_build_prefix (context,
+ diagnostic));
}
-static void
+void
default_diagnostic_finalizer (diagnostic_context *context,
diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
{
diagnostic_t
diagnostic_classify_diagnostic (diagnostic_context *context,
int option_index,
- diagnostic_t new_kind)
+ diagnostic_t new_kind,
+ location_t where)
{
diagnostic_t old_kind;
if (option_index <= 0
- || option_index >= N_OPTS
+ || option_index >= context->n_opts
|| new_kind >= DK_LAST_DIAGNOSTIC_KIND)
return DK_UNSPECIFIED;
old_kind = context->classify_diagnostic[option_index];
- context->classify_diagnostic[option_index] = new_kind;
+
+ /* Handle pragmas separately, since we need to keep track of *where*
+ the pragmas were. */
+ if (where != UNKNOWN_LOCATION)
+ {
+ int i;
+
+ for (i = context->n_classification_history - 1; i >= 0; i --)
+ if (context->classification_history[i].option == option_index)
+ {
+ old_kind = context->classification_history[i].kind;
+ break;
+ }
+
+ i = context->n_classification_history;
+ context->classification_history =
+ (diagnostic_classification_change_t *) xrealloc (context->classification_history, (i + 1)
+ * sizeof (diagnostic_classification_change_t));
+ context->classification_history[i].location = where;
+ context->classification_history[i].option = option_index;
+ context->classification_history[i].kind = new_kind;
+ context->n_classification_history ++;
+ }
+ else
+ context->classify_diagnostic[option_index] = new_kind;
+
return old_kind;
}
+/* Save all diagnostic classifications in a stack. */
+void
+diagnostic_push_diagnostics (diagnostic_context *context, location_t where ATTRIBUTE_UNUSED)
+{
+ context->push_list = (int *) xrealloc (context->push_list, (context->n_push + 1) * sizeof (int));
+ context->push_list[context->n_push ++] = context->n_classification_history;
+}
+
+/* Restore the topmost classification set off the stack. If the stack
+ is empty, revert to the state based on command line parameters. */
+void
+diagnostic_pop_diagnostics (diagnostic_context *context, location_t where)
+{
+ int jump_to;
+ int i;
+
+ if (context->n_push)
+ jump_to = context->push_list [-- context->n_push];
+ else
+ jump_to = 0;
+
+ i = context->n_classification_history;
+ context->classification_history =
+ (diagnostic_classification_change_t *) xrealloc (context->classification_history, (i + 1)
+ * sizeof (diagnostic_classification_change_t));
+ context->classification_history[i].location = where;
+ context->classification_history[i].option = jump_to;
+ context->classification_history[i].kind = DK_POP;
+ context->n_classification_history ++;
+}
+
/* 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.
+ in the documentation of output_format.
Return true if a diagnostic was printed, false otherwise. */
bool
diagnostic_info *diagnostic)
{
location_t location = diagnostic->location;
- bool maybe_print_warnings_as_errors_message = false;
+ diagnostic_t orig_diag_kind = diagnostic->kind;
const char *saved_format_spec;
/* Give preference to being able to inhibit warnings, before they
get reclassified to something else. */
if ((diagnostic->kind == DK_WARNING || diagnostic->kind == DK_PEDWARN)
- && !diagnostic_report_warnings_p (location))
+ && !diagnostic_report_warnings_p (context, location))
return false;
- if (diagnostic->kind == DK_NOTE && flag_compare_debug)
+ if (diagnostic->kind == DK_PEDWARN)
+ {
+ diagnostic->kind = pedantic_warning_kind (context);
+ /* We do this to avoid giving the message for -pedantic-errors. */
+ orig_diag_kind = diagnostic->kind;
+ }
+
+ if (diagnostic->kind == DK_NOTE && context->inhibit_notes_p)
return false;
- if (diagnostic->kind == DK_PEDWARN)
- diagnostic->kind = pedantic_warning_kind ();
-
if (context->lock > 0)
{
/* If we're reporting an ICE in the middle of some other error,
&& diagnostic->kind == DK_WARNING)
{
diagnostic->kind = DK_ERROR;
- maybe_print_warnings_as_errors_message = true;
}
-
+
if (diagnostic->option_index)
{
+ diagnostic_t diag_class = DK_UNSPECIFIED;
+
/* This tests if the user provided the appropriate -Wfoo or
-Wno-foo option. */
- if (! option_enabled (diagnostic->option_index))
+ if (! context->option_enabled (diagnostic->option_index))
return false;
+
+ /* This tests for #pragma diagnostic changes. */
+ if (context->n_classification_history > 0)
+ {
+ int i;
+ /* FIXME: Stupid search. Optimize later. */
+ for (i = context->n_classification_history - 1; i >= 0; i --)
+ {
+ if (context->classification_history[i].location <= location)
+ {
+ if (context->classification_history[i].kind == (int) DK_POP)
+ {
+ i = context->classification_history[i].option;
+ continue;
+ }
+ if (context->classification_history[i].option == diagnostic->option_index)
+ {
+ diag_class = context->classification_history[i].kind;
+ if (diag_class != DK_UNSPECIFIED)
+ diagnostic->kind = diag_class;
+ break;
+ }
+ }
+ }
+ }
/* This tests if the user provided the appropriate -Werror=foo
option. */
- if (context->classify_diagnostic[diagnostic->option_index] != DK_UNSPECIFIED)
+ if (diag_class == DK_UNSPECIFIED
+ && context->classify_diagnostic[diagnostic->option_index] != DK_UNSPECIFIED)
{
diagnostic->kind = context->classify_diagnostic[diagnostic->option_index];
- maybe_print_warnings_as_errors_message = false;
}
/* This allows for future extensions, like temporarily disabling
warnings for ranges of source code. */
return false;
}
- /* If we changed the kind due to -Werror, and didn't override it, we
- need to print this message. */
- if (context->issue_warnings_are_errors_message
- && maybe_print_warnings_as_errors_message)
- {
- pp_verbatim (context->printer,
- "%s: warnings being treated as errors\n", progname);
- context->issue_warnings_are_errors_message = false;
- }
+ if (orig_diag_kind == DK_WARNING && diagnostic->kind == DK_ERROR)
+ context->some_warnings_are_errors = true;
context->lock++;
- if (diagnostic->kind == DK_ICE && plugins_active_p ())
- {
- fnotice (stderr, "*** WARNING *** there are active plugins, do not report"
- " this as a bug unless you can reproduce it without enabling"
- " any plugins.\n");
- dump_active_plugins (stderr);
- }
-
- if (diagnostic->kind == DK_ICE)
+ if (diagnostic->kind == DK_ICE)
{
#ifndef ENABLE_CHECKING
/* When not checking, ICEs are converted to fatal errors when an
}
#endif
if (context->internal_error)
- (*context->internal_error) (diagnostic->message.format_spec,
+ (*context->internal_error) (context,
+ diagnostic->message.format_spec,
diagnostic->message.args_ptr);
}
++diagnostic_kind_count (context, diagnostic->kind);
-
+
saved_format_spec = diagnostic->message.format_spec;
- if (context->show_option_requested && diagnostic->option_index)
- diagnostic->message.format_spec
- = ACONCAT ((diagnostic->message.format_spec,
- " [", cl_options[diagnostic->option_index].opt_text, "]", NULL));
-
+ if (context->show_option_requested)
+ {
+ char *option_text;
+
+ option_text = context->option_name (context, diagnostic->option_index,
+ orig_diag_kind, diagnostic->kind);
+
+ if (option_text)
+ {
+ diagnostic->message.format_spec
+ = ACONCAT ((diagnostic->message.format_spec,
+ " ",
+ "[", option_text, "]",
+ NULL));
+ free (option_text);
+ }
+ }
diagnostic->message.locus = &diagnostic->location;
- diagnostic->message.abstract_origin = &diagnostic->abstract_origin;
- diagnostic->abstract_origin = NULL;
+ diagnostic->message.x_data = &diagnostic->x_data;
+ diagnostic->x_data = NULL;
pp_format (context->printer, &diagnostic->message);
(*diagnostic_starter (context)) (context, diagnostic);
pp_output_formatted_text (context->printer);
pp_flush (context->printer);
diagnostic_action_after_output (context, diagnostic);
diagnostic->message.format_spec = saved_format_spec;
- diagnostic->abstract_origin = NULL;
+ diagnostic->x_data = NULL;
context->lock--;
text.args_ptr = ≈
text.format_spec = _(gmsgid);
text.locus = NULL;
- text.abstract_origin = NULL;
+ text.x_data = NULL;
pp_format_verbatim (global_dc->printer, &text);
pp_flush (global_dc->printer);
va_end (ap);
}
bool
-emit_diagnostic (diagnostic_t kind, location_t location, int opt,
+emit_diagnostic (diagnostic_t kind, location_t location, int opt,
const char *gmsgid, ...)
{
diagnostic_info diagnostic;
if (kind == DK_PERMERROR)
{
diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
- permissive_error_kind ());
- diagnostic.option_index = OPT_fpermissive;
+ permissive_error_kind (global_dc));
+ diagnostic.option_index = permissive_error_option (global_dc);
}
else {
diagnostic_set_info (&diagnostic, gmsgid, &ap, location, kind);
va_end (ap);
}
+/* An informative note at LOCATION. Use this for additional details on an
+ error message. */
+void
+inform_n (location_t location, int n, const char *singular_gmsgid,
+ const char *plural_gmsgid, ...)
+{
+ diagnostic_info diagnostic;
+ va_list ap;
+
+ va_start (ap, plural_gmsgid);
+ diagnostic_set_info_translated (&diagnostic,
+ ngettext (singular_gmsgid, plural_gmsgid, n),
+ &ap, location, DK_NOTE);
+ report_diagnostic (&diagnostic);
+ va_end (ap);
+}
+
/* A warning at INPUT_LOCATION. Use this for code which is correct according
- to the relevant language specification but is likely to be buggy anyway.
+ to the relevant language specification but is likely to be buggy anyway.
Returns true if the warning was printed, false if it was inhibited. */
bool
warning (int opt, const char *gmsgid, ...)
va_start (ap, gmsgid);
diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
- permissive_error_kind ());
- diagnostic.option_index = OPT_fpermissive;
+ permissive_error_kind (global_dc));
+ diagnostic.option_index = permissive_error_option (global_dc);
va_end (ap);
return report_diagnostic (&diagnostic);
}
va_end (ap);
}
+/* A hard error: the code is definitely ill-formed, and an object file
+ will not be produced. */
+void
+error_n (location_t location, int n, const char *singular_gmsgid,
+ const char *plural_gmsgid, ...)
+{
+ diagnostic_info diagnostic;
+ va_list ap;
+
+ va_start (ap, plural_gmsgid);
+ diagnostic_set_info_translated (&diagnostic,
+ ngettext (singular_gmsgid, plural_gmsgid, n),
+ &ap, location, DK_ERROR);
+ report_diagnostic (&diagnostic);
+ va_end (ap);
+}
+
/* Same as ebove, but use location LOC instead of input_location. */
void
error_at (location_t loc, const char *gmsgid, ...)
va_end (ap);
}
+/* Return true if an error or a "sorry" has been seen. Various
+ processing is disabled after errors. */
+bool
+seen_error (void)
+{
+ return errorcount || sorrycount;
+}
+
/* An error which is severe enough that we make no attempt to
continue. Do not use this for internal consistency checks; that's
internal_error. Use of this function should be rare. */