pintos-os.org Git - pspp/blob - src/libpspp/message.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 1997-9, 2000, 2006, 2009, 2010,
   3    2011, 2013 Free Software Foundation, Inc.
   4
   5    This program is free software: you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation, either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  17
  18 #include <config.h>
  19
  20 #include "libpspp/message.h"
  21
  22 #include <assert.h>
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28
  29 #include "libpspp/cast.h"
  30 #include "libpspp/str.h"
  31 #include "libpspp/version.h"
  32 #include "data/settings.h"
  33
  34 #include "gl/minmax.h"
  35 #include "gl/progname.h"
  36 #include "gl/xalloc.h"
  37 #include "gl/xvasprintf.h"
  38
  39 #include "gettext.h"
  40 #define _(msgid) gettext (msgid)
  41
  42 /* Message handler as set by msg_set_handler(). */
  43 static void (*msg_handler)  (const struct msg *, void *aux);
  44 static void *msg_aux;
  45
  46 /* Disables emitting messages if positive. */
  47 static int messages_disabled;
  48
  49 /* Public functions. */
  50
  51
  52 void
  53 vmsg (enum msg_class class, const char *format, va_list args)
  54 {
  55   struct msg m = {
  56     .category = msg_class_to_category (class),
  57     .severity = msg_class_to_severity (class),
  58     .text = xvasprintf (format, args),
  59   };
  60
  61   msg_emit (&m);
  62 }
  63
  64 /* Writes error message in CLASS, with text FORMAT, formatted with
  65    printf, to the standard places. */
  66 void
  67 msg (enum msg_class class, const char *format, ...)
  68 {
  69   va_list args;
  70   va_start (args, format);
  71   vmsg (class, format, args);
  72   va_end (args);
  73 }
  74
  75
  76
  77 void
  78 msg_error (int errnum, const char *format, ...)
  79 {
  80   va_list args;
  81   va_start (args, format);
  82   char *e = xvasprintf (format, args);
  83   va_end (args);
  84
  85   struct msg m = {
  86     .category = MSG_C_GENERAL,
  87     .severity = MSG_S_ERROR,
  88     .file_name = NULL,
  89     .text = xasprintf (_("%s: %s"), e, strerror (errnum)),
  90   };
  91   msg_emit (&m);
  92
  93   free (e);
  94 }
  95
  96
  97
  98 void
  99 msg_set_handler (void (*handler) (const struct msg *, void *aux), void *aux)
 100 {
 101   msg_handler = handler;
 102   msg_aux = aux;
 103 }
 104 \f
 105 /* Working with messages. */
 106
 107 const char *
 108 msg_severity_to_string (enum msg_severity severity)
 109 {
 110   switch (severity)
 111     {
 112     case MSG_S_ERROR:
 113       return _("error");
 114     case MSG_S_WARNING:
 115       return _("warning");
 116     case MSG_S_NOTE:
 117     default:
 118       return _("note");
 119     }
 120 }
 121
 122 /* Duplicate a message */
 123 struct msg *
 124 msg_dup (const struct msg *m)
 125 {
 126   struct msg *new_msg;
 127
 128   new_msg = xmemdup (m, sizeof *m);
 129   if (m->file_name != NULL)
 130     new_msg->file_name = xstrdup (m->file_name);
 131   new_msg->text = xstrdup (m->text);
 132
 133   return new_msg;
 134 }
 135
 136 /* Frees a message created by msg_dup().
 137
 138    (Messages not created by msg_dup(), as well as their file_name
 139    members, are typically not dynamically allocated, so this function should
 140    not be used to destroy them.) */
 141 void
 142 msg_destroy (struct msg *m)
 143 {
 144   free (m->file_name);
 145   free (m->text);
 146   free (m);
 147 }
 148
 149 char *
 150 msg_to_string (const struct msg *m, const char *command_name)
 151 {
 152   struct string s;
 153
 154   ds_init_empty (&s);
 155
 156   if (m->category != MSG_C_GENERAL
 157       && (m->file_name || m->first_line > 0 || m->first_column > 0))
 158     {
 159       int l1 = m->first_line;
 160       int l2 = MAX (m->first_line, m->last_line - 1);
 161       int c1 = m->first_column;
 162       int c2 = MAX (m->first_column, m->last_column - 1);
 163
 164       if (m->file_name)
 165         ds_put_format (&s, "%s", m->file_name);
 166
 167       if (l1 > 0)
 168         {
 169           if (!ds_is_empty (&s))
 170             ds_put_byte (&s, ':');
 171
 172           if (l2 > l1)
 173             {
 174               if (c1 > 0)
 175                 ds_put_format (&s, "%d.%d-%d.%d", l1, c1, l2, c2);
 176               else
 177                 ds_put_format (&s, "%d-%d", l1, l2);
 178             }
 179           else
 180             {
 181               if (c1 > 0)
 182                 {
 183                   if (c2 > c1)
 184                     {
 185                       /* The GNU coding standards say to use
 186                          LINENO-1.COLUMN-1-COLUMN-2 for this case, but GNU
 187                          Emacs interprets COLUMN-2 as LINENO-2 if I do that.
 188                          I've submitted an Emacs bug report:
 189                          http://debbugs.gnu.org/cgi/bugreport.cgi?bug=7725.
 190
 191                          For now, let's be compatible. */
 192                       ds_put_format (&s, "%d.%d-%d.%d", l1, c1, l1, c2);
 193                     }
 194                   else
 195                     ds_put_format (&s, "%d.%d", l1, c1);
 196                 }
 197               else
 198                 ds_put_format (&s, "%d", l1);
 199             }
 200         }
 201       else if (c1 > 0)
 202         {
 203           if (c2 > c1)
 204             ds_put_format (&s, ".%d-%d", c1, c2);
 205           else
 206             ds_put_format (&s, ".%d", c1);
 207         }
 208       ds_put_cstr (&s, ": ");
 209     }
 210
 211   ds_put_format (&s, "%s: ", msg_severity_to_string (m->severity));
 212
 213   if (m->category == MSG_C_SYNTAX && command_name != NULL)
 214     ds_put_format (&s, "%s: ", command_name);
 215
 216   ds_put_cstr (&s, m->text);
 217
 218   return ds_cstr (&s);
 219 }
 220 \f
 221
 222 /* Number of messages reported, by severity level. */
 223 static int counts[MSG_N_SEVERITIES];
 224
 225 /* True after the maximum number of errors or warnings has been exceeded. */
 226 static bool too_many_errors;
 227
 228 /* True after the maximum number of notes has been exceeded. */
 229 static bool too_many_notes;
 230
 231 /* True iff warnings have been explicitly disabled (MXWARNS = 0) */
 232 static bool warnings_off = false;
 233
 234 /* Checks whether we've had so many errors that it's time to quit
 235    processing this syntax file. */
 236 bool
 237 msg_ui_too_many_errors (void)
 238 {
 239   return too_many_errors;
 240 }
 241
 242 void
 243 msg_ui_disable_warnings (bool x)
 244 {
 245   warnings_off = x;
 246 }
 247
 248
 249 void
 250 msg_ui_reset_counts (void)
 251 {
 252   int i;
 253
 254   for (i = 0; i < MSG_N_SEVERITIES; i++)
 255     counts[i] = 0;
 256   too_many_errors = false;
 257   too_many_notes = false;
 258 }
 259
 260 bool
 261 msg_ui_any_errors (void)
 262 {
 263   return counts[MSG_S_ERROR] > 0;
 264 }
 265
 266
 267 static int entrances = 0;
 268
 269 static void
 270 ship_message (struct msg *m)
 271 {
 272   entrances++;
 273   if ( ! m->shipped )
 274     {
 275       if (msg_handler && entrances <= 1)
 276         msg_handler (m, msg_aux);
 277       else
 278         {
 279           fwrite (m->text, 1, strlen (m->text), stderr);
 280           fwrite ("\n", 1, 1, stderr);
 281         }
 282     }
 283   m->shipped = true;
 284   entrances--;
 285 }
 286
 287 static void
 288 submit_note (char *s)
 289 {
 290   struct msg m = {
 291     .category = MSG_C_GENERAL,
 292     .severity = MSG_S_NOTE,
 293     .text = s,
 294   };
 295   ship_message (&m);
 296
 297   free (s);
 298 }
 299
 300
 301
 302 static void
 303 process_msg (struct msg *m)
 304 {
 305   int n_msgs, max_msgs;
 306
 307   if (too_many_errors
 308       || (too_many_notes && m->severity == MSG_S_NOTE)
 309       || (warnings_off && m->severity == MSG_S_WARNING) )
 310     return;
 311
 312   ship_message (m);
 313
 314   counts[m->severity]++;
 315   max_msgs = settings_get_max_messages (m->severity);
 316   n_msgs = counts[m->severity];
 317   if (m->severity == MSG_S_WARNING)
 318     n_msgs += counts[MSG_S_ERROR];
 319   if (n_msgs > max_msgs)
 320     {
 321       if (m->severity == MSG_S_NOTE)
 322         {
 323           too_many_notes = true;
 324           submit_note (xasprintf (_("Notes (%d) exceed limit (%d).  "
 325                                     "Suppressing further notes."),
 326                                   n_msgs, max_msgs));
 327         }
 328       else
 329         {
 330           too_many_errors = true;
 331           if (m->severity == MSG_S_WARNING)
 332             submit_note (xasprintf (_("Warnings (%d) exceed limit (%d).  Syntax processing will be halted."),
 333                                     n_msgs, max_msgs));
 334           else
 335             submit_note (xasprintf (_("Errors (%d) exceed limit (%d).  Syntax processing will be halted."),
 336                                     n_msgs, max_msgs));
 337         }
 338     }
 339 }
 340
 341
 342 /* Emits M as an error message.
 343    Frees allocated data in M. */
 344 void
 345 msg_emit (struct msg *m)
 346 {
 347   m->shipped = false;
 348   if (!messages_disabled)
 349      process_msg (m);
 350
 351   free (m->text);
 352 }
 353
 354 /* Disables message output until the next call to msg_enable.  If
 355    this function is called multiple times, msg_enable must be
 356    called an equal number of times before messages are actually
 357    re-enabled. */
 358 void
 359 msg_disable (void)
 360 {
 361   messages_disabled++;
 362 }
 363
 364 /* Enables message output that was disabled by msg_disable. */
 365 void
 366 msg_enable (void)
 367 {
 368   assert (messages_disabled > 0);
 369   messages_disabled--;
 370 }
 371 \f
 372 /* Private functions. */
 373
 374 void
 375 request_bug_report (const char *msg)
 376 {
 377   fprintf (stderr, "******************************************************\n");
 378   fprintf (stderr, "You have discovered a bug in PSPP.  Please report this\n");
 379   fprintf (stderr, "to " PACKAGE_BUGREPORT ".  Please include this entire\n");
 380   fprintf (stderr, "message, *plus* several lines of output just above it.\n");
 381   fprintf (stderr, "For the best chance at having the bug fixed, also\n");
 382   fprintf (stderr, "include the syntax file that triggered it and a sample\n");
 383   fprintf (stderr, "of any data file used for input.\n");
 384   fprintf (stderr, "proximate cause:     %s\n", msg);
 385   fprintf (stderr, "version:             %s\n", version);
 386   fprintf (stderr, "host_system:         %s\n", host_system);
 387   fprintf (stderr, "build_system:        %s\n", build_system);
 388   fprintf (stderr, "locale_dir:          %s\n", locale_dir);
 389   fprintf (stderr, "compiler version:    %s\n",
 390 #ifdef __VERSION__
 391            __VERSION__
 392 #else
 393            "Unknown"
 394 #endif
 395            );
 396   fprintf (stderr, "******************************************************\n");
 397 }
 398