toplev.h (report_error_function): Remove.

	* toplev.h (report_error_function): Remove.

	* diagnostic.h (location_t): New datatype.
	(text_info): Likewise.
	(diagnostic_info): Likewise.
	(output_prefix): New macro.
	(diagnostic_last_function_changed): Likewise.
	(diagnostic_set_last_function): Likewise.
	(diagnostic_last_module_changed): Likewise.
	(diagnostic_set_last_module): Likewise.
	(report_diagnostic): Now macro.
	(diagnostic_set_info): Declare.

	* diagnostic.c (report_problematic_module): Rename to
	diagnostic_repor_current_module.
	(set_diagnostic_context): Remove.
	(count_error): Rename to diagnostic_error_count.
	(error_function_changed): Remove.
	(record_last_error_function): Likewise.
	(error_module_changed): Likewise.
	(record_last_error_module): Likewise.
	(context_as_prefix): Rename to diagnostic_build_prefix.
	(flush_diagnostic_buffer): Rename to diagnostic_flush_buffer.
	(diagnostic_set_info): New function.

	* objc/objc-act.c: #include diagnostic.h
	(error_with_ivar): Adjust call to count_error.
	(warn_with_method): Likewise.
	* objc/Make-lang.in (objc-act.o): Depend on diagnostic.h

cp/
2002-06-04  Gabriel Dos Reis  <gdr@codesourcery.com>

	* error.c (cp_diagnostic_starter): Adjust call.
	(maybe_print_instantiation_context): Change prototype to take a
	'diagnostic_info *'.
	(print_instantiation_full_context): Likewise.
	(print_instantiation_partial_context): Likewise.
	(cp_diagnostic_starter): Likewise.
	(cp_diagnostic_finalizer): Likewise.
	(cp_print_error_function): Likewise.
	(cp_printer): Take a secondary parameter as a 'text_info *'.
	Remove output_state savings.  Adjust calls.

f/
2002-06-04  Gabriel Dos Reis  <gdr@codesourcery.com>

	* bad.c (ffebad_start_): Adjust call to count_error.
	* Make-lang.in (f/bad.o): Depend on diagnostic.h
	* bad.c: #include diagnostic.h

From-SVN: r54291

gcc/ChangeLog

+2002-06-05  Gabriel Dos Reis  <gdr@codesourcery.com>
+
+	* toplev.h (report_error_function): Remove.
+
+	* diagnostic.h (location_t): New datatype.
+	(text_info): Likewise.
+	(diagnostic_info): Likewise.
+	(output_prefix): New macro.
+	(diagnostic_last_function_changed): Likewise.
+	(diagnostic_set_last_function): Likewise.
+	(diagnostic_last_module_changed): Likewise.
+	(diagnostic_set_last_module): Likewise.
+	(report_diagnostic): Now macro.
+	(diagnostic_set_info): Declare.
+
+	* diagnostic.c (report_problematic_module): Rename to
+	diagnostic_repor_current_module. 
+	(set_diagnostic_context): Remove.
+	(count_error): Rename to diagnostic_error_count.
+	(error_function_changed): Remove.
+	(record_last_error_function): Likewise.
+	(error_module_changed): Likewise.
+	(record_last_error_module): Likewise.
+	(context_as_prefix): Rename to diagnostic_build_prefix.
+	(flush_diagnostic_buffer): Rename to diagnostic_flush_buffer.
+	(diagnostic_set_info): New function.
+
+	* objc/objc-act.c: #include diagnostic.h
+	(error_with_ivar): Adjust call to count_error.
+	(warn_with_method): Likewise.
+	* objc/Make-lang.in (objc-act.o): Depend on diagnostic.h
+
 2002-06-05  Bob Wilson  <bob.wilson@acm.org>
 
 	* config/xtensa/xtensa.c (xtensa_build_va_list): Use

gcc/c-errors.c

@@ -32,13 +32,12 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 void
 pedwarn_c99 VPARAMS ((const char *msgid, ...))
 {
-  diagnostic_context dc;
-
+  diagnostic_info diagnostic;
   VA_OPEN (ap, msgid);
   VA_FIXEDARG (ap, const char *, msgid);
 
-  set_diagnostic_context (&dc, msgid, &ap, input_filename, lineno,
-                          !flag_isoc99 || !flag_pedantic_errors);
-  report_diagnostic (&dc);
+  diagnostic_set_info (&diagnostic, msgid, &ap, input_filename, lineno,
+                       flag_isoc99 ? pedantic_error_kind () : DK_WARNING);
+  report_diagnostic (&diagnostic);
   VA_CLOSE (ap);
 }

gcc/c-format.c

@@ -1025,7 +1025,7 @@ check_function_format (status, attrs, params)
 static void
 status_warning VPARAMS ((int *status, const char *msgid, ...))
 {
-  diagnostic_context dc;
+  diagnostic_info diagnostic ;
 
   VA_OPEN (ap, msgid);
   VA_FIXEDARG (ap, int *, status);
@@ -1036,9 +1036,9 @@ status_warning VPARAMS ((int *status, const char *msgid, ...))
   else
     {
       /* This duplicates the warning function behavior.  */
-      set_diagnostic_context
-	(&dc, msgid, &ap, input_filename, lineno, /* warn = */ 1);
-      report_diagnostic (&dc);
+      diagnostic_set_info (&diagnostic, _(msgid), &ap, input_filename, lineno,
+                           DK_WARNING);
+      report_diagnostic (&diagnostic);
     }
 
   VA_CLOSE (ap);

gcc/c-objc-common.c

@@ -35,7 +35,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "ggc.h"
 #include "langhooks.h"
 
-static int c_tree_printer PARAMS ((output_buffer *));
+static bool c_tree_printer PARAMS ((output_buffer *, text_info *));
 static tree inline_forbidden_p PARAMS ((tree *, int *, void *));
 static void expand_deferred_fns PARAMS ((void));
 static tree start_cdtor	PARAMS ((int));
@@ -389,13 +389,14 @@ c_objc_common_finish_file ()
    by the C++ front-end.
    Please notice when called, the `%' part was already skipped by the
    diagnostic machinery.  */
-static int
-c_tree_printer (buffer)
+static bool
+c_tree_printer (buffer, text)
      output_buffer *buffer;
+     text_info *text;
 {
-  tree t = va_arg (output_buffer_format_args (buffer), tree);
+  tree t = va_arg (*text->args_ptr, tree);
 
-  switch (*output_buffer_text_cursor (buffer))
+  switch (*text->format_spec)
     {
     case 'D':
     case 'F':
@@ -406,10 +407,10 @@ c_tree_printer (buffer)
           : "({anonymous})";
         output_add_string (buffer, n);
       }
-      return 1;
+      return true;
 
     default:
-      return 0;
+      return false;
     }
 }
 

gcc/cp/ChangeLog

+2002-06-04  Gabriel Dos Reis  <gdr@codesourcery.com>
+
+	* error.c (cp_diagnostic_starter): Adjust call.
+	(maybe_print_instantiation_context): Change prototype to take a
+	'diagnostic_info *'.
+	(print_instantiation_full_context): Likewise.
+	(print_instantiation_partial_context): Likewise.
+	(cp_diagnostic_starter): Likewise.
+	(cp_diagnostic_finalizer): Likewise.
+	(cp_print_error_function): Likewise.
+	(cp_printer): Take a secondary parameter as a 'text_info *'.
+	Remove output_state savings.  Adjust calls.
+
 2002-06-03  Geoffrey Keating  <geoffk@redhat.com>
 
 	* pt.c (inline_parm_levels): Mark for GC.

gcc/cp/error.c

@@ -105,18 +105,19 @@ static void dump_scope PARAMS ((tree, int));
 static void dump_template_parms PARAMS ((tree, int, int));
 
 static const char *function_category PARAMS ((tree));
-static void maybe_print_instantiation_context PARAMS ((output_buffer *));
-static void print_instantiation_full_context PARAMS ((output_buffer *));
-static void print_instantiation_partial_context PARAMS ((output_buffer *, tree,
+static void maybe_print_instantiation_context PARAMS ((diagnostic_context *));
+static void print_instantiation_full_context PARAMS ((diagnostic_context *));
+static void print_instantiation_partial_context PARAMS ((diagnostic_context *,
+                                                         tree,
                                                          const char *, int));
-static void cp_diagnostic_starter PARAMS ((output_buffer *,
-                                           diagnostic_context *));
-static void cp_diagnostic_finalizer PARAMS ((output_buffer *,
-                                             diagnostic_context *));
-static void cp_print_error_function PARAMS ((output_buffer *,
-                                             diagnostic_context *));
-
-static int cp_printer PARAMS ((output_buffer *));
+static void cp_diagnostic_starter PARAMS ((diagnostic_context *,
+                                           diagnostic_info *));
+static void cp_diagnostic_finalizer PARAMS ((diagnostic_context *,
+                                             diagnostic_info *));
+static void cp_print_error_function PARAMS ((diagnostic_context *,
+                                             diagnostic_info *));
+
+static bool cp_printer PARAMS ((output_buffer *, text_info *));
 static void print_non_consecutive_character PARAMS ((output_buffer *, int));
 static void print_integer PARAMS ((output_buffer *, HOST_WIDE_INT));
 static tree locate_error PARAMS ((const char *, va_list));
@@ -2379,65 +2380,57 @@ cxx_print_error_function (context, file)
      diagnostic_context *context;
      const char *file;
 {
-  output_state os;
-
   lhd_print_error_function (context, file);
-  os = diagnostic_state (context);
-  output_set_prefix ((output_buffer *)context, file);
-  maybe_print_instantiation_context ((output_buffer *)context);
-  diagnostic_state (context) = os;
+  output_set_prefix (&context->buffer, file);
+  maybe_print_instantiation_context (context);
 }
 
 static void
-cp_diagnostic_starter (buffer, dc)
-     output_buffer *buffer;
-     diagnostic_context *dc;
+cp_diagnostic_starter (context, diagnostic)
+     diagnostic_context *context;
+     diagnostic_info *diagnostic;
 {
-  report_problematic_module (buffer);
-  cp_print_error_function (buffer, dc);
-  maybe_print_instantiation_context (buffer);
-  output_set_prefix (buffer,
-                     context_as_prefix (diagnostic_file_location (dc),
-                                        diagnostic_line_location (dc),
-                                        diagnostic_is_warning (dc)));
+  diagnostic_report_current_module (context);
+  cp_print_error_function (context, diagnostic);
+  maybe_print_instantiation_context (context);
+  output_set_prefix (&context->buffer, diagnostic_build_prefix (diagnostic));
 }
 
 static void
-cp_diagnostic_finalizer (buffer, dc)
-     output_buffer *buffer;
-     diagnostic_context *dc __attribute__ ((__unused__));
+cp_diagnostic_finalizer (context, diagnostic)
+     diagnostic_context *context;
+     diagnostic_info *diagnostic __attribute__((unused));
 {
-  output_destroy_prefix (buffer);
+  output_destroy_prefix (&context->buffer);
 }
 
 /* Print current function onto BUFFER, in the process of reporting
    a diagnostic message.  Called from cp_diagnostic_starter.  */
 static void
-cp_print_error_function (buffer, dc)
-     output_buffer *buffer;
-     diagnostic_context *dc;
+cp_print_error_function (context, diagnostic)
+     diagnostic_context *context;
+     diagnostic_info *diagnostic;
 {
-  if (error_function_changed ())
+  if (diagnostic_last_function_changed (context))
     {
-      char *prefix = diagnostic_file_location (dc)
-        ? file_name_as_prefix (diagnostic_file_location (dc))
+      const char *old_prefix = output_prefix (&context->buffer);
+      char *new_prefix = diagnostic->location.file
+        ? file_name_as_prefix (diagnostic->location.file)
         : NULL;
-      output_state os;
 
-      os = output_buffer_state (buffer);
-      output_set_prefix (buffer, prefix);
+      output_set_prefix (&context->buffer, new_prefix);
 
       if (current_function_decl == NULL)
-        output_add_string (buffer, "At global scope:");
+        output_add_string (&context->buffer, "At global scope:");
       else
-        output_printf
-          (buffer, "In %s `%s':", function_category (current_function_decl),
-           cxx_printable_name (current_function_decl, 2));
-      output_add_newline (buffer);
-
-      record_last_error_function ();
-      output_destroy_prefix (buffer);
-      output_buffer_state (buffer) = os;
+        output_printf (&context->buffer, "In %s `%s':",
+                       function_category (current_function_decl),
+                       cxx_printable_name (current_function_decl, 2));
+      output_add_newline (&context->buffer);
+
+      diagnostic_set_last_function (context);
+      output_destroy_prefix (&context->buffer);
+      context->buffer.state.prefix = old_prefix;
     }
 }
 
@@ -2466,8 +2459,8 @@ function_category (fn)
 /* Report the full context of a current template instantiation,
    onto BUFFER.  */
 static void
-print_instantiation_full_context (buffer)
-     output_buffer *buffer;
+print_instantiation_full_context (context)
+     diagnostic_context *context;
 {
   tree p = current_instantiation ();
   int line = lineno;
@@ -2486,7 +2479,8 @@ print_instantiation_full_context (buffer)
 	  if (current_function_decl == TINST_DECL (p))
 	    /* Avoid redundancy with the the "In function" line.  */;
 	  else
-	    output_verbatim (buffer, "%s: In instantiation of `%s':\n", file,
+	    output_verbatim (&context->buffer,
+                             "%s: In instantiation of `%s':\n", file,
                              decl_as_string (TINST_DECL (p),
                                              TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
 
@@ -2496,13 +2490,13 @@ print_instantiation_full_context (buffer)
 	}
     }
 
-  print_instantiation_partial_context (buffer, p, file, line);
+  print_instantiation_partial_context (context, p, file, line);
 }
 
 /* Same as above but less verbose.  */
 static void
-print_instantiation_partial_context (buffer, t, file, line)
-     output_buffer *buffer;
+print_instantiation_partial_context (context, t, file, line)
+     diagnostic_context *context;
      tree t;
      const char *file;
      int line;
@@ -2510,24 +2504,24 @@ print_instantiation_partial_context (buffer, t, file, line)
   for (; t; t = TREE_CHAIN (t))
     {
       output_verbatim
-        (buffer, "%s:%d:   instantiated from `%s'\n", file, line,
+        (&context->buffer, "%s:%d:   instantiated from `%s'\n", file, line,
          decl_as_string (TINST_DECL (t), TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
       line = TINST_LINE (t);
       file = TINST_FILE (t);
     }
-  output_verbatim (buffer, "%s:%d:   instantiated from here\n", file, line);
+  output_verbatim (&context->buffer, "%s:%d:   instantiated from here\n", file, line);
 }
 
 /* Called from cp_thing to print the template context for an error.  */
 static void
-maybe_print_instantiation_context (buffer)
-     output_buffer *buffer;
+maybe_print_instantiation_context (context)
+     diagnostic_context *context;
 {
   if (!problematic_instantiation_changed () || current_instantiation () == 0)
     return;
 
   record_last_problematic_instantiation ();
-  print_instantiation_full_context (buffer);
+  print_instantiation_full_context (context);
 }
 
 /* Report the bare minimum context of a template instantiation.  */
@@ -2535,8 +2529,8 @@ void
 print_instantiation_context ()
 {
   print_instantiation_partial_context
-    (diagnostic_buffer, current_instantiation (), input_filename, lineno);
-  flush_diagnostic_buffer ();
+    (global_dc, current_instantiation (), input_filename, lineno);
+  diagnostic_flush_buffer (global_dc);
 }
 
 /* Called from output_format -- during diagnostic message processing --
@@ -2552,26 +2546,27 @@ print_instantiation_context ()
    %Q	assignment operator.
    %T   type.
    %V   cv-qualifier.  */
-static int
-cp_printer (buffer)
+static bool
+cp_printer (buffer, text)
      output_buffer *buffer;
+     text_info *text;
 {
   int verbose = 0;
   const char *result;
-#define next_tree    va_arg (output_buffer_format_args (buffer), tree)
-#define next_tcode   va_arg (output_buffer_format_args (buffer), enum tree_code)
-#define next_lang    va_arg (output_buffer_format_args (buffer), enum languages)
-#define next_int     va_arg (output_buffer_format_args (buffer), int)
-
-  if (*output_buffer_text_cursor (buffer) == '+')
-    ++output_buffer_text_cursor (buffer);
-  if (*output_buffer_text_cursor (buffer) == '#')
+#define next_tree    va_arg (*text->args_ptr, tree)
+#define next_tcode   va_arg (*text->args_ptr, enum tree_code)
+#define next_lang    va_arg (*text->args_ptr, enum languages)
+#define next_int     va_arg (*text->args_ptr, int)
+
+  if (*text->format_spec == '+')
+    ++text->format_spec;
+  if (*text->format_spec == '#')
     {
       verbose = 1;
-      ++output_buffer_text_cursor (buffer);
+      ++text->format_spec;
     }
 
-  switch (*output_buffer_text_cursor (buffer))
+  switch (*text->format_spec)
     {
     case 'A': result = args_to_string (next_tree, verbose);	break;
     case 'C': result = code_to_string (next_tcode, verbose);	break;
@@ -2586,11 +2581,11 @@ cp_printer (buffer)
     case 'V': result = cv_to_string (next_tree, verbose);	break;
  
     default:
-      return 0;
+      return false;
     }
 
   output_add_string (buffer, result);
-  return 1;
+  return true;
 #undef next_tree
 #undef next_tcode
 #undef next_lang
@@ -2684,7 +2679,7 @@ void
 cp_error_at VPARAMS ((const char *msgid, ...))
 {
   tree here;
-  diagnostic_context dc;
+  diagnostic_info diagnostic;
 
   VA_OPEN (ap, msgid);
   VA_FIXEDARG (ap, const char *, msgid);
@@ -2694,10 +2689,9 @@ cp_error_at VPARAMS ((const char *msgid, ...))
   VA_OPEN (ap, msgid);
   VA_FIXEDARG (ap, const char *, msgid);
 
-  set_diagnostic_context (&dc, msgid, &ap,
-			  cp_file_of (here),
-			  cp_line_of (here), /* warning = */ 0);
-  report_diagnostic (&dc);
+  diagnostic_set_info (&diagnostic, msgid, &ap,
+                       cp_file_of (here), cp_line_of (here), DK_WARNING);
+  report_diagnostic (&diagnostic);
   VA_CLOSE (ap);
 }
 
@@ -2705,7 +2699,7 @@ void
 cp_warning_at VPARAMS ((const char *msgid, ...))
 {
   tree here;
-  diagnostic_context dc;
+  diagnostic_info diagnostic;
 
   VA_OPEN (ap, msgid);
   VA_FIXEDARG (ap, const char *, msgid);
@@ -2715,10 +2709,9 @@ cp_warning_at VPARAMS ((const char *msgid, ...))
   VA_OPEN (ap, msgid);
   VA_FIXEDARG (ap, const char *, msgid);
 
-  set_diagnostic_context (&dc, msgid, &ap,
-			  cp_file_of (here),
-			  cp_line_of (here), /* warning = */ 1);
-  report_diagnostic (&dc);
+  diagnostic_set_info (&diagnostic, msgid, &ap,
+                       cp_file_of (here), cp_line_of (here), DK_WARNING);
+  report_diagnostic (&diagnostic);
   VA_CLOSE (ap);
 }
 
@@ -2726,7 +2719,7 @@ void
 cp_pedwarn_at VPARAMS ((const char *msgid, ...))
 {
   tree here;
-  diagnostic_context dc;
+  diagnostic_info diagnostic;
 
   VA_OPEN (ap, msgid);
   VA_FIXEDARG (ap, const char *, msgid);
@@ -2736,10 +2729,9 @@ cp_pedwarn_at VPARAMS ((const char *msgid, ...))
   VA_OPEN (ap, msgid);
   VA_FIXEDARG (ap, const char *, msgid);
 
-  set_diagnostic_context (&dc, msgid, &ap,
-			  cp_file_of (here),
-			  cp_line_of (here),
-			  /* warning = */ !flag_pedantic_errors);
-  report_diagnostic (&dc);
+  diagnostic_set_info (&diagnostic, msgid, &ap,
+                       cp_file_of (here), cp_line_of (here),
+                       pedantic_error_kind());
+  report_diagnostic (&diagnostic);
   VA_CLOSE (ap);
 }

gcc/diagnostic.c

-/* Language-independent diagnostic subroutines for the GNU C compiler
+/* 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>
 
@@ -50,30 +50,22 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 
 #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 output_flush PARAMS ((output_buffer *));
-static void output_do_verbatim PARAMS ((output_buffer *,
-					const char *, va_list *));
+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));
@@ -91,12 +83,12 @@ static void maybe_wrap_text PARAMS ((output_buffer *, const char *,
 				     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;
 
 extern int rtl_dump_and_exit;
 extern int warnings_are_errors;
@@ -105,92 +97,9 @@ extern int warnings_are_errors;
 static diagnostic_context global_diagnostic_context;
 diagnostic_context *global_dc = &global_diagnostic_context;
 
-/* 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;
-
-/* Prevent recursion into the error handler.  */
-static int diagnostic_lock;
-
 
-/* 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-wrapping mode.  */
-
-int
-output_is_line_wrapping (buffer)
-     output_buffer *buffer;
-{
-  return output_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;
@@ -198,14 +107,14 @@ set_real_maximum_length (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 unnecessarily the line-length cut-off.  */
-  if (! output_is_line_wrapping (buffer)
+  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 (output_line_cutoff (buffer) - prefix_length < 32)
@@ -217,7 +126,6 @@ set_real_maximum_length (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;
@@ -228,15 +136,14 @@ output_set_maximum_length (buffer, length)
 }
 
 /* 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;
 }
 
@@ -254,20 +161,18 @@ output_last_position (buffer)
 }
 
 /* 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;
@@ -277,20 +182,16 @@ output_clear_message_text (buffer)
 }
 
 /* Zero out any formatting data used so far by BUFFER.  */
-
 static void
 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) = 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;
@@ -308,7 +209,6 @@ init_output_buffer (buffer, prefix, maximum_length)
 }
 
 /* Reinitialize BUFFER.  */
-
 void
 output_clear (buffer)
      output_buffer *buffer;
@@ -319,7 +219,6 @@ output_clear (buffer)
 
 /* Finishes constructing a NULL-terminated character string representing
    the BUFFERed message.  */
-
 const char *
 output_finalize_message (buffer)
      output_buffer *buffer;
@@ -328,16 +227,8 @@ output_finalize_message (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;
@@ -346,12 +237,11 @@ output_space_left (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 (output_prefixing_rule (buffer))
 	{
@@ -370,9 +260,9 @@ output_emit_prefix (buffer)
 
 	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;
+	    int prefix_length = strlen (buffer->state.prefix);
+	    output_append_r (buffer, buffer->state.prefix, prefix_length);
+	    prefix_was_emitted_for (buffer) = true;
 	  }
 	  break;
 	}
@@ -380,7 +270,6 @@ output_emit_prefix (buffer)
 }
 
 /* Have BUFFER start a new line.  */
-
 void
 output_add_newline (buffer)
      output_buffer *buffer;
@@ -390,7 +279,6 @@ output_add_newline (buffer)
 }
 
 /* Appends a character to BUFFER.  */
-
 void
 output_add_character (buffer, c)
      output_buffer *buffer;
@@ -403,7 +291,6 @@ output_add_character (buffer, c)
 }
 
 /* Adds a space to BUFFER.  */
-
 void
 output_add_space (buffer)
      output_buffer *buffer;
@@ -419,7 +306,6 @@ output_add_space (buffer)
 
 /* These functions format an INTEGER into BUFFER as suggested by their
    names.  */
-
 void
 output_decimal (buffer, i)
      output_buffer *buffer;
@@ -486,7 +372,6 @@ output_long_hexadecimal (buffer, i)
 
 /* Append to BUFFER a string specified by its STARTING character
    and LENGTH.  */
-
 static void
 output_append_r (buffer, start, length)
      output_buffer *buffer;
@@ -498,10 +383,9 @@ output_append_r (buffer, start, length)
 }
 
 /* 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;
@@ -531,14 +415,13 @@ output_indent (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);
+  bool is_wrapping = output_is_line_wrapping (buffer);
 
   while (start != end)
     {
@@ -567,7 +450,6 @@ wrap_text (buffer, start, end)
 }
 
 /* Same as wrap_text but wrap text only when in line-wrapping mode.  */
-
 static void
 maybe_wrap_text (buffer, start, end)
      output_buffer *buffer;
@@ -583,7 +465,6 @@ maybe_wrap_text (buffer, start, end)
 
 /* Append a STRING to BUFFER; the STRING might be line-wrapped if in
    appropriate mode.  */
-
 void
 output_add_string (buffer, str)
      output_buffer *buffer;
@@ -604,9 +485,8 @@ output_buffer_to_stream (buffer)
   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.
@@ -616,93 +496,80 @@ output_buffer_to_stream (buffer)
    %s: string.
    %%: `%'.
    %*.s: a substring the length of which is specified by an integer.  */
-
 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);
+	const char *p = text->format_spec;
 	while (*p && *p != '%')
 	  ++p;
-	wrap_text (buffer, output_buffer_text_cursor (buffer), p);
-	output_buffer_text_cursor (buffer) = p;
+	wrap_text (buffer, text->format_spec, p);
+        text->format_spec = p;
       }
 
-      if (!*output_buffer_text_cursor (buffer))
+      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')
+      if (*++text->format_spec == 'l')
 	{
-	  long_integer = 1;
-	  ++output_buffer_text_cursor (buffer);
+	  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))
+      switch (*text->format_spec)
 	{
 	case 'c':
-	  output_add_character
-	    (buffer, va_arg (output_buffer_format_args (buffer), int));
+	  output_add_character (buffer, va_arg (*text->args_ptr, int));
 	  break;
 
 	case 'd':
 	case 'i':
 	  if (long_integer)
-	    output_long_decimal
-	      (buffer, va_arg (output_buffer_format_args (buffer), long int));
+	    output_long_decimal (buffer, va_arg (*text->args_ptr, long int));
 	  else
-	    output_decimal
-	      (buffer, va_arg (output_buffer_format_args (buffer), int));
+	    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));
+			       va_arg (*text->args_ptr, unsigned long int));
 	  else
-	    output_octal (buffer,
-			  va_arg (output_buffer_format_args (buffer),
-				  unsigned int));
+	    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 *));
+	  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));
+	      (buffer, va_arg (*text->args_ptr, long unsigned int));
 	  else
 	    output_unsigned_decimal
-	      (buffer, va_arg (output_buffer_format_args (buffer),
-			       unsigned int));
+	      (buffer, va_arg (*text->args_ptr, unsigned int));
 	  break;
 
 	case 'x':
 	  if (long_integer)
 	    output_long_hexadecimal
-	      (buffer, va_arg (output_buffer_format_args (buffer),
-			       unsigned long int));
+	      (buffer, va_arg (*text->args_ptr, unsigned long int));
 	  else
 	    output_hexadecimal
-	      (buffer, va_arg (output_buffer_format_args (buffer),
-			       unsigned int));
+              (buffer, va_arg (*text->args_ptr, unsigned int));
 	  break;
 
 	case '%':
@@ -714,18 +581,19 @@ output_format (buffer)
 	    int n;
 	    const char *s;
 	    /* We handle no precision specifier but `%.*s'.  */
-	    if (*++output_buffer_text_cursor (buffer) != '*')
+	    if (*++text->format_spec != '*')
 	      abort ();
-	    else if (*++output_buffer_text_cursor (buffer) != 's')
+	    else if (*++text->format_spec != 's')
 	      abort ();
-	    n = va_arg (output_buffer_format_args (buffer), int);
-	    s = va_arg (output_buffer_format_args (buffer), const char *);
+	    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))
+	  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.  */
@@ -748,7 +616,6 @@ vbuild_message_string (msg, ap)
 
 /*  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 *msg, ...))
 {
@@ -764,33 +631,7 @@ build_message_string VPARAMS ((const char *msg, ...))
   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 diagnsotic_build_prefix, but only the source FILE is given.  */
 char *
 file_name_as_prefix (f)
      const char *f;
@@ -798,44 +639,26 @@ file_name_as_prefix (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, ...))
 {
-  va_list *old_args;
-
+  text_info text;
   VA_OPEN (ap, msgid);
   VA_FIXEDARG (ap, output_buffer *, buffer);
   VA_FIXEDARG (ap, const char *, msgid);
 
-  old_args = output_buffer_ptr_to_format_args (buffer);
-  output_buffer_ptr_to_format_args (buffer) = &ap;
-  output_do_printf (buffer, _(msgid));
-  output_buffer_ptr_to_format_args (buffer) = old_args;
+  text.args_ptr = &ap;
+  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;
@@ -843,7 +666,7 @@ format_with_decl (buffer, decl)
   /* 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 == '%')
 	{
@@ -857,7 +680,7 @@ format_with_decl (buffer, decl)
     }
 
   /* 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.  */
     {
@@ -875,48 +698,12 @@ format_with_decl (buffer, decl)
 
   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);
     }
 }
 
-
-/* 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)
-     tree decl;
-     const char *msgid;
-     va_list *args_ptr;
-     int warn;
-{
-  output_state os;
-
-  if (diagnostic_lock++)
-    error_recursion ();
-
-  if (count_error (warn))
-    {
-      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);
-      output_flush (&global_dc->buffer);
-      output_destroy_prefix (diagnostic_buffer);
-
-      output_buffer_state (diagnostic_buffer) = os;
-    }
-  diagnostic_lock--;
-}
-
 /* Flush the content of BUFFER onto the attached stream.  */
-
 static void
 output_flush (buffer)
      output_buffer *buffer;
@@ -929,67 +716,161 @@ output_flush (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, msgid, args_ptr)
+output_do_verbatim (buffer, text)
      output_buffer *buffer;
-     const char *msgid;
-     va_list *args_ptr;
+     text_info *text;
 {
-  output_state os;
+  diagnostic_prefixing_rule_t rule = output_prefixing_rule (buffer);
+  int line_cutoff = output_line_cutoff (buffer);
 
-  os = output_buffer_state (buffer);
-  output_prefix (buffer) = NULL;
+  /* Set verbatim mode.  */
   output_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_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);
 
-  output_do_verbatim (buffer, msgid, &ap);
+  text.format_spec = msgid;
+  text.args_ptr = &ap;
+  output_do_verbatim (buffer, &text);
   VA_CLOSE (ap);
 }
+
 
-/* Count an error or warning.  Return 1 if the message should be printed.  */
+/* Initialize the diagnostic message outputting machinery.  */
+void
+diagnostic_initialize (context)
+     diagnostic_context *context;
+{
+  memset (context, 0, sizeof *context);
+  obstack_init (&context->buffer.obstack);
 
-int
-count_error (warningp)
-     int warningp;
+  /* 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;
+}
+
+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;
+  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;
+{
+  if (diagnostic->location.file)
+    {
+      if (diagnostic->kind == DK_WARNING)
+	return build_message_string (_("%s:%d: warning: "),
+                                     diagnostic->location.file,
+                                     diagnostic->location.line);
+      else
+	return build_message_string ("%s:%d: ",
+                                     diagnostic->location.file,
+                                     diagnostic->location.line);
+    }
+  else
+    {
+      if (diagnostic->kind == DK_WARNING)
+	return build_message_string (_("%s: warning: "), progname);
+      else
+	return build_message_string ("%s: ", progname);
+    }
+}
+
+/* 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 (diagnostic, decl)
+     diagnostic_info *diagnostic;
+     tree decl;
 {
-  if (warningp && !diagnostic_report_warnings_p ())
-    return 0;
+  if (global_dc->lock++)
+    error_recursion (global_dc);
 
-  if (warningp && !warnings_are_errors)
-    warningcount++;
+  if (diagnostic_count_error (global_dc, diagnostic->kind))
+    {
+      diagnostic_report_current_function (global_dc);
+      output_set_prefix
+	(&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);
+    }
+  global_dc->lock--;
+}
+
+void
+diagnostic_flush_buffer (context)
+     diagnostic_context *context;
+{
+  output_buffer_to_stream (&context->buffer);
+  fflush (output_buffer_attached_stream (&context->buffer));
+}
+
+/* Count an error or warning.  Return true if the message should be
+   printed.  */
+bool
+diagnostic_count_error (context, kind)
+    diagnostic_context *context;
+    diagnostic_t kind;
+{
+  if (kind == DK_WARNING && !diagnostic_report_warnings_p ())
+    return false;
+
+  if (kind == DK_WARNING && !warnings_are_errors)
+    ++diagnostic_kind_count (context, DK_WARNING);
   else
     {
-      static int warning_message = 0;
+      static bool warning_message = false;
 
-      if (warningp && !warning_message)
+      if (kind == DK_WARNING && !warning_message)
 	{
-	  verbatim ("%s: warnings being treated as errors\n", progname);
-	  warning_message = 1;
+	  output_verbatim (&context->buffer,
+                           "%s: warnings being treated as errors\n", progname);
+	  warning_message = true;
 	}
-      errorcount++;
+      ++diagnostic_kind_count (context, DK_ERROR);
     }
 
-  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, ...))
 {
@@ -1004,52 +885,49 @@ fnotice VPARAMS ((FILE *file, const char *msgid, ...))
 
 /* 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, ...))
 {
-  output_state os;
-
+  text_info text;
   VA_OPEN (ap, msgid);
   VA_FIXEDARG (ap, const char *, msgid);
 
-  os = output_buffer_state (diagnostic_buffer);
-
-  output_printf (diagnostic_buffer, "%s: %s: ", progname, xstrerror (errno));
-  output_buffer_ptr_to_format_args (diagnostic_buffer) = &ap;
-  output_buffer_text_cursor (diagnostic_buffer) = _(msgid);
-  output_format (diagnostic_buffer);
+  text.format_spec = _(msgid);
+  text.args_ptr = &ap;
+  output_printf (&global_dc->buffer, "%s: %s: ", progname, xstrerror (errno));
+  output_format (&global_dc->buffer, &text);
   output_flush (&global_dc->buffer);
-  output_buffer_state (diagnostic_buffer) = os;
   VA_CLOSE (ap);
   exit (FATAL_EXIT_CODE);
 }
 
 /* Issue a pedantic warning MSGID.  */
-
 void
 pedwarn VPARAMS ((const char *msgid, ...))
 {
-  diagnostic_context dc;
-
+  diagnostic_info diagnostic;
   VA_OPEN (ap, msgid);
   VA_FIXEDARG (ap, const char *, msgid);
 
-  set_diagnostic_context
-    (&dc, msgid, &ap, input_filename, lineno, !flag_pedantic_errors);
-  report_diagnostic (&dc);
+  diagnostic_set_info (&diagnostic, _(msgid), &ap, input_filename, lineno,
+                       pedantic_error_kind ());
+  report_diagnostic (&diagnostic);
   VA_CLOSE (ap);
 }
 
 /* Issue a pedantic warning about DECL.  */
-
 void
 pedwarn_with_decl VPARAMS ((tree decl, const char *msgid, ...))
 {
+  diagnostic_info diagnostic;
   VA_OPEN (ap, msgid);
   VA_FIXEDARG (ap, tree, decl);
   VA_FIXEDARG (ap, const char *, msgid);
 
+  diagnostic_set_info (&diagnostic, _(msgid), &ap,
+                       DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl),
+                       pedantic_error_kind ());
+
   /* 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
@@ -1057,106 +935,99 @@ pedwarn_with_decl VPARAMS ((tree decl, const char *msgid, ...))
      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);
+    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, ...))
 {
-  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);
 
-  set_diagnostic_context (&dc, msgid, &ap, file, line, !flag_pedantic_errors);
-  report_diagnostic (&dc);
+  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, ...))
 {
-  output_state os;
+  diagnostic_info diagnostic;
 
   VA_OPEN (ap, msgid);
   VA_FIXEDARG (ap, const char *, msgid);
 
   ++sorrycount;
-  os = output_buffer_state (diagnostic_buffer);
+  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) = &ap;
-  output_buffer_text_cursor (diagnostic_buffer) = _(msgid);
-  output_format (diagnostic_buffer);
+    (&global_dc->buffer, diagnostic_build_prefix (&diagnostic));
+  output_printf (&global_dc->buffer, "sorry, not implemented: ");
+  output_format (&global_dc->buffer, &diagnostic.message);
   output_flush (&global_dc->buffer);
-  output_buffer_state (diagnostic_buffer) = os;
   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", (*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
 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;
 
-      os = diagnostic_state (context);
-      output_set_prefix ((output_buffer *) context, prefix);
+      output_set_prefix (&context->buffer, new_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':",
+	      (&context->buffer, "In member function `%s':",
 	       (*lang_hooks.decl_printable_name) (current_function_decl, 2));
 	  else
 	    output_printf
-	      ((output_buffer *) context, "In function `%s':",
+	      (&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);
-      diagnostic_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);
     }
 }
 
@@ -1165,37 +1036,41 @@ lhd_print_error_function (context, file)
   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);
-  (*lang_hooks.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, ...))
 {
-  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);
 
-  set_diagnostic_context (&dc, msgid, &ap, file, line, /* warn = */ 0);
-  report_diagnostic (&dc);
+  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, ...))
 {
+  diagnostic_info diagnostic;
   VA_OPEN (ap, msgid);
   VA_FIXEDARG (ap, tree, decl);
   VA_FIXEDARG (ap, const char *, msgid);
 
-  diagnostic_for_decl (decl, msgid, &ap, /* warn = */ 0);
+  diagnostic_set_info (&diagnostic, msgid, &ap,
+                       DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl),
+                       DK_ERROR);
+  diagnostic_for_decl (&diagnostic, decl);
   VA_CLOSE (ap);
 }
 
@@ -1205,14 +1080,14 @@ error_with_decl VPARAMS ((tree decl, const char *msgid, ...))
 void
 error VPARAMS ((const char *msgid, ...))
 {
-  diagnostic_context dc;
+  diagnostic_info diagnostic;
 
   VA_OPEN (ap, msgid);
   VA_FIXEDARG (ap, const char *, msgid);
 
-  set_diagnostic_context
-    (&dc, msgid, &ap, input_filename, lineno, /* warn = */ 0);
-  report_diagnostic (&dc);
+  diagnostic_set_info (&diagnostic, msgid, &ap, input_filename, lineno,
+                       DK_ERROR);
+  report_diagnostic (&diagnostic);
   VA_CLOSE (ap);
 }
 
@@ -1222,14 +1097,14 @@ error VPARAMS ((const char *msgid, ...))
 void
 fatal_error VPARAMS ((const char *msgid, ...))
 {
-  diagnostic_context dc;
+  diagnostic_info diagnostic;
 
   VA_OPEN (ap, msgid);
   VA_FIXEDARG (ap, const char *, msgid);
 
-  set_diagnostic_context
-    (&dc, msgid, &ap, input_filename, lineno, /* warn = */ 0);
-  report_diagnostic (&dc);
+  diagnostic_set_info (&diagnostic, msgid, &ap, input_filename, lineno,
+                       DK_FATAL);
+  report_diagnostic (&diagnostic);
   VA_CLOSE (ap);
 
   fnotice (stderr, "compilation terminated.\n");
@@ -1239,13 +1114,13 @@ fatal_error VPARAMS ((const char *msgid, ...))
 void
 internal_error VPARAMS ((const char *msgid, ...))
 {
-  diagnostic_context dc;
+  diagnostic_info diagnostic;
 
   VA_OPEN (ap, msgid);
   VA_FIXEDARG (ap, const char *, msgid);
 
-  if (diagnostic_lock)
-    error_recursion ();
+  if (global_dc->lock)
+    error_recursion (global_dc);
 
 #ifndef ENABLE_CHECKING
   if (errorcount > 0 || sorrycount > 0)
@@ -1259,9 +1134,9 @@ internal_error VPARAMS ((const char *msgid, ...))
   if (global_dc->internal_error != 0)
     (*global_dc->internal_error) (_(msgid), &ap);
 
-  set_diagnostic_context
-    (&dc, msgid, &ap, input_filename, lineno, /* warn = */0);
-  report_diagnostic (&dc);
+  diagnostic_set_info (&diagnostic, msgid, &ap, input_filename, lineno,
+                       DK_ICE);
+  report_diagnostic (&diagnostic);
   VA_CLOSE (ap);
 
   fnotice (stderr,
@@ -1275,40 +1150,44 @@ void
 warning_with_file_and_line VPARAMS ((const char *file, int line,
 				     const char *msgid, ...))
 {
-  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);
 
-  set_diagnostic_context (&dc, msgid, &ap, file, line, /* warn = */ 1);
-  report_diagnostic (&dc);
+  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, ...))
 {
+  diagnostic_info diagnostic;
   VA_OPEN (ap, msgid);
   VA_FIXEDARG (ap, tree, decl);
   VA_FIXEDARG (ap, const char *, msgid);
 
-  diagnostic_for_decl (decl, msgid, &ap, /* warn = */ 1);
+  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, ...))
 {
-  diagnostic_context dc;
+  diagnostic_info diagnostic;
 
   VA_OPEN (ap, msgid);
   VA_FIXEDARG (ap, const char *, msgid);
 
-  set_diagnostic_context
-    (&dc, msgid, &ap, input_filename, lineno, /* warn = */ 1);
-  report_diagnostic (&dc);
+  diagnostic_set_info (&diagnostic, msgid, &ap, input_filename, lineno,
+                       DK_WARNING);
+  report_diagnostic (&diagnostic);
   VA_CLOSE (ap);
 }
 
@@ -1318,11 +1197,14 @@ warning VPARAMS ((const char *msgid, ...))
 void
 verbatim VPARAMS ((const char *msgid, ...))
 {
+  text_info text;
   VA_OPEN (ap, msgid);
   VA_FIXEDARG (ap, const char *, msgid);
 
-  output_do_verbatim (diagnostic_buffer, msgid, &ap);
-  output_buffer_to_stream (diagnostic_buffer);
+  text.format_spec = _(msgid);
+  text.args_ptr = &ap;
+  output_do_verbatim (&global_dc->buffer, &text);
+  output_buffer_to_stream (&global_dc->buffer);
   VA_CLOSE (ap);
 }
 
@@ -1333,27 +1215,22 @@ verbatim VPARAMS ((const char *msgid, ...))
    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_error (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);
-      output_flush (&global_dc->buffer);
-      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
@@ -1362,10 +1239,11 @@ report_diagnostic (dc)
    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)
-    output_flush (&global_dc->buffer);
+  if (context->lock < 3)
+    output_flush (&context->buffer);
 
   fnotice (stderr,
 	   "Internal compiler error: Error reporting routines re-entered.\n");
@@ -1434,74 +1312,48 @@ fancy_abort (file, line, function)
 		  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);
-}
-
 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 (buffer);
+  output_destroy_prefix (&context->buffer);
 }
 
 void

gcc/diagnostic.h

@@ -24,13 +24,15 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 
 #include "obstack.h"
 
-/*  Forward declarations.  */
-typedef struct output_buffer output_buffer;
-typedef struct diagnostic_context diagnostic_context;
-typedef void (*diagnostic_starter_fn) PARAMS ((output_buffer *,
-                                               diagnostic_context *));
-typedef diagnostic_starter_fn diagnostic_finalizer_fn;
+/* The type of a text to be formatted according a format specification
+   along with a list of things.  */
+typedef struct
+{
+  const char *format_spec;
+  va_list *args_ptr;
+} text_info;
 
+/* Contants used to discreminate diagnostics.  */
 typedef enum
 {
 #define DEFINE_DIAGNOSTIC_KIND(K, M) K,  
@@ -39,6 +41,27 @@ typedef enum
   DK_LAST_DIAGNOSTIC_KIND
 } diagnostic_t;
 
+/* The data structure used to record the location of a diagnostic.  */
+typedef struct
+{
+  /* The name of the source file involved in the diagnostic.  */     
+  const char *file;
+
+  /* The line-location in the source file.  */
+  int line;
+} location_t;
+
+/* A diagnostic is described by the MESSAGE to send, the FILE and LINE of
+   its context and its KIND (ice, error, warning, note, ...)  See complete
+   list in diagnostic.def.  */
+typedef struct
+{
+  text_info message;
+  location_t location;
+  /* The kind of diagnostic it is about.  */
+  diagnostic_t kind;
+} diagnostic_info;
+
 #define pedantic_error_kind() (flag_pedantic_errors ? DK_ERROR : DK_WARNING)
 
 /* How often diagnostics are prefixed by their locations:
@@ -53,11 +76,6 @@ typedef enum
   DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE = 0x2
 } diagnostic_prefixing_rule_t;
 
-/* The type of front-end specific hook that formats trees into an
-   output_buffer.  A language specific printer returns a truth value if
-   everything goes well.  */
-typedef int (*printer_fn) PARAMS ((output_buffer *));
-
 /* This data structure encapsulates an output_buffer's state.  */
 typedef struct
 {
@@ -83,15 +101,14 @@ typedef struct
 
   /* Current prefixing rule.  */
   diagnostic_prefixing_rule_t prefixing_rule;
-
-  /* The current char to output.  Updated by front-end (*format_map) when
-     it is called to report front-end printer for a specified format.  */  
-  const char *cursor;
-
-  /* A pointer to the variable argument-list for formatting.  */  
-  va_list *format_args;
 } output_state;
 
+/* The type of a hook that formats client-specific data (trees mostly) into
+   an output_buffer.  A client-supplied formatter returns true if everything
+   goes well.  */
+typedef struct output_buffer output_buffer;
+typedef bool (*printer_fn) PARAMS ((output_buffer *, text_info *));
+
 /* The output buffer datatype.  This is best seen as an abstract datatype
    whose fields should not be accessed directly by clients.  */
 struct output_buffer
@@ -112,35 +129,23 @@ struct output_buffer
      floating-point value.  */
   char digit_buffer[128];
 
-/* If non-NULL, this function formats data in the BUFFER. When called,
-   output_buffer_text_cursor (BUFFER) points to a format code.
-   FORMAT_DECODER should call output_add_string (and related functions)
-   to add data to the BUFFER.  FORMAT_DECODER can read arguments from
-   output_buffer_format_args (BUFFER) using VA_ARG.  If the BUFFER needs
-   additional characters from the format string, it should advance
-   the output_buffer_text_cursor (BUFFER) as it goes.  When FORMAT_DECODER
-   returns, output_buffer_text_cursor (BUFFER) should point to the last
-   character processed.  */
-
+  /* If non-NULL, this function formats a TEXT into the BUFFER. When called,
+     TEXT->format_spec points to a format code.  FORMAT_DECODER should call
+     output_add_string (and related functions) to add data to the BUFFER.
+     FORMAT_DECODER can read arguments from *TEXT->args_pts using VA_ARG.
+     If the BUFFER needs additional characters from the format string, it
+     should advance the TEXT->format_spec as it goes.  When FORMAT_DECODER
+     returns, TEXT->format_spec should point to the last character processed.
+  */
   printer_fn format_decoder;
-};
+} ;
 
-/* Current state of an output_buffer.  */
-#define output_buffer_state(BUFFER) (BUFFER)->state
+#define output_prefix(BUFFER) (BUFFER)->state.prefix
 
 /* The stream attached to the output_buffer, where the formatted
    diagnostics will ultimately go.  Works only on `output_buffer *'.  */
 #define output_buffer_attached_stream(BUFFER) (BUFFER)->stream
 
-/* This points to the beginning of the rest of the diagnostic message
-   to be formatted.  Accepts only `output_buffer *'s.  */
-#define output_buffer_text_cursor(BUFFER) (BUFFER)->state.cursor
-
-/* The rest of the `variable argument list' not yet processed.
-   This macro works on both `output_state *' and `output_buffer *'.  */
-#define output_buffer_format_args(BUFFER) \
-   *(((output_state *)(BUFFER))->format_args)
-
 /* In line-wrapping mode, whether we should start a new line.  */
 #define output_needs_newline(BUFFER) (BUFFER)->state.need_newline_p
 
@@ -161,6 +166,15 @@ struct output_buffer
    Zero means don't wrap lines.  */
 #define output_line_cutoff(BUFFER)  (BUFFER)->state.ideal_maximum_length
 
+/* True if BUFFER is in line-wrapping mode.  */
+#define output_is_line_wrapping(BUFFER) (output_line_cutoff (BUFFER) > 0)
+
+/*  Forward declarations.  */
+typedef struct diagnostic_context diagnostic_context;
+typedef void (*diagnostic_starter_fn) PARAMS ((diagnostic_context *,
+                                               diagnostic_info *));
+typedef diagnostic_starter_fn diagnostic_finalizer_fn;
+
 /* This data structure bundles altogether any information relevant to
    the context of a diagnostic message.  */
 struct diagnostic_context
@@ -170,22 +184,6 @@ struct diagnostic_context
      output_buffer.  */
   output_buffer buffer;
 
-  /* The diagnostic message to output.  */
-  const char *message;
-
-  /* A pointer to a variable list of the arguments necessary for the
-     purpose of message formatting.  */
-  va_list *args_ptr;
-
-  /* The name of the source file involved in the diagnostic.  */     
-  const char *file;
-
-  /* The line-location in the source file.  */
-  int line;
-
-  /* Is this message a warning?  */
-  int warn;
-
   /* The number of times we have issued diagnostics.  */
   int diagnostic_count[DK_LAST_DIAGNOSTIC_KIND];
 
@@ -196,34 +194,28 @@ struct diagnostic_context
                       from "/home/gdr/src/nifty_printer.h:56:
                       ...
   */
-  void (*begin_diagnostic) PARAMS ((output_buffer *, diagnostic_context *));
+  diagnostic_starter_fn begin_diagnostic;
 
   /* This function is called after the diagnostic message is printed.  */
-  void (*end_diagnostic) PARAMS ((output_buffer *, diagnostic_context *));
+  diagnostic_finalizer_fn end_diagnostic;
 
   /* Client hook to report an internal error.  */
   void (*internal_error) PARAMS ((const char *, va_list *));
 
+  /* Function of last diagnostic message; more generally, function such that
+     if next diagnostic message is in it then we don't have to mention the
+     function name.  */
+  tree last_function;
+
+  /* Used to detect when input_file_stack has changed since last described.  */
+  int last_module;
+
+  int lock;
+  
   /* Hook for front-end extensions.  */
   void *x_data;
 };
 
-/* The diagnostic message being formatted.  */
-#define diagnostic_message(DC) (DC)->message
-
-/* A pointer to the variable argument list used in a call
-   to a diagonstic routine.  */   
-#define diagnostic_argument_list(DC) (DC)->args_ptr
-
-/* The program file to which the diagnostic is referring to.  */
-#define diagnostic_file_location(DC) (DC)->file
-
-/* The program source line referred to in the diagnostic message.  */
-#define diagnostic_line_location(DC) (DC)->line
-
-/* Tell whether the diagnostic message is to be treated as a warning.  */
-#define diagnostic_is_warning(DC) (DC)->warn
-
 /* Client supplied function to announce a diagnostic.  */
 #define diagnostic_starter(DC) (DC)->begin_diagnostic
 
@@ -244,10 +236,25 @@ struct diagnostic_context
    Zero means don't wrap lines.  */
 #define diagnostic_line_cutoff(DC) output_line_cutoff (&(DC)->buffer)
 
-/* Same as output_buffer_state, but works on 'diagnostic_context *'.  */
-#define diagnostic_state(DC)  output_buffer_state (&(DC)->buffer)
+/* True if the last function in which a diagnostic was reported is
+   different from the current one.  */
+#define diagnostic_last_function_changed(DC) \
+  ((DC)->last_function != current_function_decl)
+
+/* Remember the current function as being the last one in which we report
+   a diagnostic.  */
+#define diagnostic_set_last_function(DC) \
+  (DC)->last_function = current_function_decl
+
+/* True if the last module or file in which a diagnostic was reported is
+   different from the current one.  */
+#define diagnostic_last_module_changed(DC) \
+  ((DC)->last_module != input_file_stack_tick)
 
-#define diagnostic_buffer (&global_dc->buffer)
+/* Remember the current module or file as being the last one in which we
+   report a diagnostic.  */
+#define diagnostic_set_last_module(DC) \
+  (DC)->last_module = input_file_stack_tick
 
 /* This diagnostic_context is used by front-ends that directly output
    diagnostic messages without going through `error', `warning',
@@ -270,18 +277,27 @@ extern diagnostic_context *global_dc;
   (!inhibit_warnings					\
    && !(in_system_header && !warn_system_headers))
 
+#define report_diagnostic(D) diagnostic_report_diagnostic (global_dc, D)
 
-/* Prototypes */
-extern void set_diagnostic_context	PARAMS ((diagnostic_context *,
-						 const char *, va_list *,
-						 const char *, int, int));
-extern void report_diagnostic		PARAMS ((diagnostic_context *));
+/* Dignostic related functions.  */
 extern void diagnostic_initialize	PARAMS ((diagnostic_context *));
+extern void diagnostic_report_current_module PARAMS ((diagnostic_context *));
+extern void diagnostic_report_current_function PARAMS ((diagnostic_context *));
+extern void diagnostic_flush_buffer	PARAMS ((diagnostic_context *));
+extern bool diagnostic_count_error      PARAMS ((diagnostic_context *,
+                                                 diagnostic_t));
+extern void diagnostic_report_diagnostic PARAMS ((diagnostic_context *,
+                                                 diagnostic_info *));
+extern void diagnostic_set_info         PARAMS ((diagnostic_info *,
+                                                 const char *, va_list *,
+                                                 const char *, int,
+                                                 diagnostic_t));
+extern char *diagnostic_build_prefix    PARAMS ((diagnostic_info *));
+
+/* Pure text formatting support functions.  */
 extern void init_output_buffer		PARAMS ((output_buffer *,
 						 const char *, int));
-extern void flush_diagnostic_buffer	PARAMS ((void));
 extern void output_clear		PARAMS ((output_buffer *));
-extern const char *output_get_prefix	PARAMS ((const output_buffer *));
 extern const char *output_last_position PARAMS ((const output_buffer *));
 extern void output_set_prefix		PARAMS ((output_buffer *,
 						 const char *));
@@ -301,17 +317,10 @@ extern const char *output_finalize_message PARAMS ((output_buffer *));
 extern void output_clear_message_text	PARAMS ((output_buffer *));
 extern void output_printf		PARAMS ((output_buffer *, const char *,
 						 ...)) ATTRIBUTE_PRINTF_2;
-extern int output_is_line_wrapping	PARAMS ((output_buffer *));
 extern void output_verbatim		PARAMS ((output_buffer *, const char *,
 						 ...)) ATTRIBUTE_PRINTF_2;
 extern void verbatim			PARAMS ((const char *, ...))
      ATTRIBUTE_PRINTF_1;
-extern char *context_as_prefix		PARAMS ((const char *, int, int));
 extern char *file_name_as_prefix	PARAMS ((const char *));
-extern int error_module_changed         PARAMS ((void));
-extern void record_last_error_module	PARAMS ((void));
-extern int error_function_changed	PARAMS ((void));
-extern void record_last_error_function	PARAMS ((void));
-extern void report_problematic_module	PARAMS ((output_buffer *));     
 
 #endif /* ! GCC_DIAGNOSTIC_H */

gcc/f/ChangeLog

+2002-06-04  Gabriel Dos Reis  <gdr@codesourcery.com>
+
+	* bad.c (ffebad_start_): Adjust call to count_error.
+	* Make-lang.in (f/bad.o): Depend on diagnostic.h
+	* bad.c: #include diagnostic.h
+
 2002-06-03  Geoffrey Keating  <geoffk@redhat.com>
 
 	* Make-lang.in (f/com.o): Depend on debug.h.

gcc/f/Make-lang.in

@@ -352,7 +352,8 @@ f/bad.o: f/bad.c f/proj.h $(CONFIG_H) $(SYSTEM_H) f/bad.h f/bad.def f/where.h \
  glimits.h f/top.h f/malloc.h flags.h f/com.h f/com-rt.def $(TREE_H) f/bld.h \
  f/bld-op.def f/bit.h f/info.h f/info-b.def f/info-k.def f/info-w.def \
  f/target.h f/lex.h f/type.h f/intrin.h f/intrin.def f/lab.h f/symbol.h \
- f/symbol.def f/equiv.h f/storag.h f/global.h f/name.h toplev.h intl.h
+ f/symbol.def f/equiv.h f/storag.h f/global.h f/name.h toplev.h intl.h \
+ diagnostic.h
 f/bit.o: f/bit.c f/proj.h $(CONFIG_H) $(SYSTEM_H) glimits.h f/bit.h \
  f/malloc.h
 f/bld.o: f/bld.c f/proj.h $(CONFIG_H) $(SYSTEM_H) f/bld.h f/bld-op.def f/bit.h \

gcc/f/bad.c

@@ -43,6 +43,7 @@ the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "toplev.h"
 #include "where.h"
 #include "intl.h"
+#include "diagnostic.h"
 
 /* Externals defined here. */
 
@@ -202,7 +203,7 @@ ffebad_start_ (bool lex_override, ffebad errnum, ffebadSeverity sev,
       if ((ffebad_severity_ != FFEBAD_severityPEDANTIC)
 	  || !flag_pedantic_errors)
 	{
-	  if (count_error (1) == 0)
+	  if (!diagnostic_count_error (global_dc, DK_WARNING))
 	    {			/* User wants no warnings. */
 	      ffebad_is_temp_inhibited_ = TRUE;
 	      return FALSE;
@@ -214,7 +215,7 @@ ffebad_start_ (bool lex_override, ffebad errnum, ffebadSeverity sev,
     case FFEBAD_severityWEIRD:
     case FFEBAD_severitySEVERE:
     case FFEBAD_severityDISASTER:
-      count_error (0);
+      diagnostic_count_error (global_dc, DK_ERROR);
       break;
 
     default:
@@ -420,7 +421,7 @@ ffebad_finish ()
 	{
 	  if (bi != 0)
 	    fputc ('\n', stderr);
-	  report_error_function (fn);
+	  diagnostic_report_current_function (global_dc);
 	  fprintf (stderr,
 		   /* the trailing space on the <file>:<line>: line
 		      fools emacs19 compilation mode into finding the

gcc/objc/Make-lang.in

@@ -90,7 +90,7 @@ $(srcdir)/objc/objc-parse.y: $(srcdir)/c-parse.in
 
 objc-act.o : $(srcdir)/objc/objc-act.c \
    $(CONFIG_H) $(TREE_H) $(RTL_H) $(SYSTEM_H) $(EXPR_H) $(TARGET_H) \
-   $(C_COMMON_H) $(srcdir)/c-tree.h \
+   $(C_COMMON_H) $(srcdir)/c-tree.h $(srcdir)/diagnostic.h \
    $(srcdir)/toplev.h $(srcdir)/flags.h $(srcdir)/objc/objc-act.h \
    $(srcdir)/input.h $(srcdir)/function.h $(srcdir)/output.h $(srcdir)/debug.h \
    $(srcdir)/langhooks.h $(LANGHOOKS_DEF_H) gtype-objc.h

gcc/objc/objc-act.c

@@ -56,6 +56,7 @@ Boston, MA 02111-1307, USA.  */
 #include "ggc.h"
 #include "debug.h"
 #include "target.h"
+#include "diagnostic.h"
 
 /* This is the default way of generating a method name.  */
 /* I am not sure it is really correct.
@@ -3415,9 +3416,9 @@ error_with_ivar (message, decl, rawdecl)
      tree decl;
      tree rawdecl;
 {
-  count_error (0);
+  diagnostic_count_error (global_dc, DK_ERROR);
 
-  report_error_function (DECL_SOURCE_FILE (decl));
+  diagnostic_report_current_function (global_dc);
 
   error_with_file_and_line (DECL_SOURCE_FILE (decl),
 			    DECL_SOURCE_LINE (decl),
@@ -6894,10 +6895,10 @@ warn_with_method (message, mtype, method)
      int mtype;
      tree method;
 {
-  if (count_error (1) == 0)
+  if (!diagnostic_count_error (global_dc, DK_WARNING))
     return;
 
-  report_error_function (DECL_SOURCE_FILE (method));
+  diagnostic_report_current_function (global_dc);
 
   /* Add a readable method name to the warning.  */
   warning_with_file_and_line (DECL_SOURCE_FILE (method),

gcc/rtl-error.c

@@ -32,7 +32,8 @@ Boston, MA 02111-1307, USA.  */
 #include "diagnostic.h"
 
 static void file_and_line_for_asm PARAMS ((rtx, const char **, int *));
-static void diagnostic_for_asm PARAMS ((rtx, const char *, va_list *, int));
+static void diagnostic_for_asm PARAMS ((rtx, const char *, va_list *,
+                                        diagnostic_t));
 
 /* Figure file and line of the given INSN.  */
 static void
@@ -74,18 +75,18 @@ file_and_line_for_asm (insn, pfile, pline)
    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
-diagnostic_for_asm (insn, msg, args_ptr, warn)
+diagnostic_for_asm (insn, msg, args_ptr, kind)
      rtx insn;
      const char *msg;
      va_list *args_ptr;
-     int warn;
+     diagnostic_t kind;
 {
-  diagnostic_context dc;
+  diagnostic_info diagnostic;
 
-  set_diagnostic_context (&dc, msg, args_ptr, NULL, 0, warn);
-  file_and_line_for_asm (insn, &diagnostic_file_location (&dc),
-			 &diagnostic_line_location (&dc));
-  report_diagnostic (&dc);
+  diagnostic_set_info (&diagnostic, msg, args_ptr, NULL, 0, kind);
+  file_and_line_for_asm (insn, &diagnostic.location.file,
+                         &diagnostic.location.line);
+  report_diagnostic (&diagnostic);
 }
 
 void
@@ -95,7 +96,7 @@ error_for_asm VPARAMS ((rtx insn, const char *msgid, ...))
   VA_FIXEDARG (ap, rtx, insn);
   VA_FIXEDARG (ap, const char *, msgid);
 
-  diagnostic_for_asm (insn, msgid, &ap, /* warn = */ 0);
+  diagnostic_for_asm (insn, msgid, &ap, DK_ERROR);
   VA_CLOSE (ap);
 }
 
@@ -106,7 +107,7 @@ warning_for_asm VPARAMS ((rtx insn, const char *msgid, ...))
   VA_FIXEDARG (ap, rtx, insn);
   VA_FIXEDARG (ap, const char *, msgid);
 
-  diagnostic_for_asm (insn, msgid, &ap, /* warn = */ 1);
+  diagnostic_for_asm (insn, msgid, &ap, DK_WARNING);
   VA_CLOSE (ap);
 }
 

gcc/toplev.h

@@ -29,7 +29,6 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 extern int toplev_main			PARAMS ((int, char **));
 extern int read_integral_parameter	PARAMS ((const char *, const char *,
 						const int));
-extern int count_error			PARAMS ((int));
 extern void strip_off_ending		PARAMS ((char *, int));
 extern void print_time			PARAMS ((const char *, long));
 extern const char *trim_filename	PARAMS ((const char *));
@@ -67,7 +66,6 @@ extern void warning_with_file_and_line	PARAMS ((const char *, int,
 extern void error_with_file_and_line	PARAMS ((const char *, int,
 						 const char *, ...));
 extern void sorry			PARAMS ((const char *, ...));
-extern void report_error_function	PARAMS ((const char *));
 
 extern void rest_of_decl_compilation	PARAMS ((union tree_node *,
 						const char *, int, int));