SET MXWARNS = 0 to be interpreted as unlimited.

[pspp] / src / libpspp / message.c

diff --git a/src/libpspp/message.c b/src/libpspp/message.c
index b3025156ef0dd33703068e03b1847316a903eecb..4ba8a8f7aca966e5add8671fa31dbd178abfc387 100644 (file)
--- a/src/libpspp/message.c
+++ b/src/libpspp/message.c
@@ -1,5 +1,5 @@
 /* PSPP - a program for statistical analysis.
-   Copyright (C) 1997-9, 2000, 2006, 2009 Free Software Foundation, Inc.
+   Copyright (C) 1997-9, 2000, 2006, 2009, 2010 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -26,14 +26,16 @@
 #include <string.h>
 #include <unistd.h>
 
+#include <libpspp/str.h>
 #include <libpspp/version.h>
+#include <data/settings.h>
 
-#include "progname.h"
-#include "xalloc.h"
-#include "xvasprintf.h"
+#include "gl/progname.h"
+#include "gl/xalloc.h"
+#include "gl/xvasprintf.h"
 
-/* Current command name as set by msg_set_command_name(). */
-static char *command_name;
+#include "gettext.h"
+#define _(msgid) gettext (msgid)
 
 /* Message handler as set by msg_init(). */
 static void (*msg_handler)  (const struct msg *);
@@ -73,11 +75,12 @@ void
 msg_done (void)
 {
 }
-
+\f
+/* Working with messages. */
 
 /* Duplicate a message */
 struct msg *
-msg_dup(const struct msg *m)
+msg_dup (const struct msg *m)
 {
   struct msg *new_msg;
 
@@ -102,6 +105,149 @@ msg_destroy (struct msg *m)
   free (m);
 }
 
+char *
+msg_to_string (const struct msg *m, const char *command_name)
+{
+  const char *label;
+  struct string s;
+
+  ds_init_empty (&s);
+
+  if (m->category != MSG_C_GENERAL
+      && (m->where.file_name || m->where.line_number != -1))
+    {
+      if (m->where.file_name)
+        ds_put_format (&s, "%s:", m->where.file_name);
+      if (m->where.line_number != -1)
+        ds_put_format (&s, "%d:", m->where.line_number);
+      ds_put_char (&s, ' ');
+    }
+
+  switch (m->severity)
+    {
+    case MSG_S_ERROR:
+      label = _("error");
+      break;
+    case MSG_S_WARNING:
+      label = _("warning");
+      break;
+    case MSG_S_NOTE:
+    default:
+      label = _("note");
+      break;
+    }
+  ds_put_format (&s, "%s: ", label);
+
+  if (m->category == MSG_C_SYNTAX && command_name != NULL)
+    ds_put_format (&s, "%s: ", command_name);
+
+  ds_put_cstr (&s, m->text);
+
+  return ds_cstr (&s);
+}
+\f
+
+/* Number of messages reported, by severity level. */
+static int counts[MSG_N_SEVERITIES];
+
+/* True after the maximum number of errors or warnings has been exceeded. */
+static bool too_many_errors;
+
+/* True after the maximum number of notes has been exceeded. */
+static bool too_many_notes;
+
+/* True iff warnings have been explicitly disabled (MXWARNS = 0) */
+static bool warnings_off = false;
+
+/* Checks whether we've had so many errors that it's time to quit
+   processing this syntax file. */
+bool
+msg_ui_too_many_errors (void)
+{
+  return too_many_errors;
+}
+
+void
+msg_ui_disable_warnings (bool x)
+{
+  warnings_off = x;
+}
+
+
+void
+msg_ui_reset_counts (void)
+{
+  int i;
+
+  for (i = 0; i < MSG_N_SEVERITIES; i++)
+    counts[i] = 0;
+  too_many_errors = false;
+  too_many_notes = false;
+}
+
+bool
+msg_ui_any_errors (void)
+{
+  return counts[MSG_S_ERROR] > 0;
+}
+
+static void
+submit_note (char *s)
+{
+  struct msg m;
+
+  m.category = MSG_C_GENERAL;
+  m.severity = MSG_S_NOTE;
+  m.where.file_name = NULL;
+  m.where.line_number = -1;
+  m.text = s;
+  msg_handler (&m);
+  free (s);
+}
+
+
+
+static void
+process_msg (const struct msg *m)
+{
+  int n_msgs, max_msgs;
+
+
+  if (too_many_errors
+      || (too_many_notes && m->severity == MSG_S_NOTE)
+      || (warnings_off && m->severity == MSG_S_WARNING) )
+    return;
+
+  msg_handler (m);
+
+  counts[m->severity]++;
+  max_msgs = settings_get_max_messages (m->severity);
+  n_msgs = counts[m->severity];
+  if (m->severity == MSG_S_WARNING)
+    n_msgs += counts[MSG_S_ERROR];
+  if (n_msgs > max_msgs)
+    {
+      if (m->severity == MSG_S_NOTE)
+        {
+          too_many_notes = true;
+          submit_note (xasprintf (_("Notes (%d) exceed limit (%d).  "
+                                    "Suppressing further notes."),
+                                  n_msgs, max_msgs));
+        }
+      else
+        {
+          too_many_errors = true;
+          if (m->severity == MSG_S_WARNING)
+            submit_note (xasprintf (_("Warnings (%d) exceed limit (%d).  Syntax processing will be halted."),
+                                    n_msgs, max_msgs));
+          else
+            submit_note (xasprintf (_("Errors (%d) exceed limit (%d).  Syntax processing will be halted."),
+                                    n_msgs, max_msgs));
+        }
+    }
+}
+
+
 /* Emits M as an error message.
    Frees allocated data in M. */
 void
@@ -116,7 +262,8 @@ msg_emit (struct msg *m)
     }
 
   if (!messages_disabled)
-     msg_handler (m);
+     process_msg (m);
+
   free (m->text);
 }
 
@@ -140,22 +287,6 @@ msg_enable (void)
 \f
 /* Private functions. */
 
-/* Sets COMMAND_NAME as the command name included in some kinds
-   of error messages. */
-void
-msg_set_command_name (const char *command_name_)
-{
-  free (command_name);
-  command_name = command_name_ ? xstrdup (command_name_) : NULL;
-}
-
-/* Returns the current command name, or NULL if none. */
-const char *
-msg_get_command_name (void)
-{
-  return command_name;
-}
-
 void
 request_bug_report_and_abort (const char *msg)
 {
@@ -182,3 +313,4 @@ request_bug_report_and_abort (const char *msg)
 
   _exit (EXIT_FAILURE);
 }
+