gdb/complaints.c

   1 /* Support for complaint handling during symbol reading in GDB.
   2
   3    Copyright (C) 1990, 1991, 1992, 1993, 1995, 1998, 1999, 2000, 2002,
   4    2004, 2005, 2006 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21    Boston, MA 02110-1301, USA.  */
  22
  23 #include "defs.h"
  24 #include "complaints.h"
  25 #include "gdb_assert.h"
  26 #include "command.h"
  27 #include "gdbcmd.h"
  28
  29 extern void _initialize_complaints (void);
  30
  31 /* Should each complaint message be self explanatory, or should we assume that
  32    a series of complaints is being produced?  */
  33
  34 /* case 1: First message of a series that must
  35    start off with explanation.  case 2: Subsequent message of a series
  36    that needs no explanation (the user already knows we have a problem
  37    so we can just state our piece).  */
  38 enum complaint_series {
  39   /* Isolated self explanatory message.  */
  40   ISOLATED_MESSAGE,
  41   /* First message of a series, includes an explanation.  */
  42   FIRST_MESSAGE,
  43   /* First message of a series, but does not need to include any sort
  44      of explanation.  */
  45   SHORT_FIRST_MESSAGE,
  46   /* Subsequent message of a series that needs no explanation (the
  47      user already knows we have a problem so we can just state our
  48      piece).  */
  49   SUBSEQUENT_MESSAGE
  50 };
  51
  52 /* Structure to manage complaints about symbol file contents.  */
  53
  54 struct complain
  55 {
  56   const char *file;
  57   int line;
  58   const char *fmt;
  59   int counter;
  60   struct complain *next;
  61 };
  62
  63 /* The explanatory message that should accompany the complaint.  The
  64    message is in two parts - pre and post - that are printed around
  65    the complaint text.  */
  66 struct explanation
  67 {
  68   const char *prefix;
  69   const char *postfix;
  70 };
  71
  72 struct complaints
  73 {
  74   struct complain *root;
  75
  76   /* Should each complaint be self explanatory, or should we assume
  77      that a series of complaints is being produced?  case 0: Isolated
  78      self explanatory message.  case 1: First message of a series that
  79      must start off with explanation.  case 2: Subsequent message of a
  80      series that needs no explanation (the user already knows we have
  81      a problem so we can just state our piece).  */
  82   int series;
  83
  84   /* The explanatory messages that should accompany the complaint.
  85      NOTE: cagney/2002-08-14: In a desperate attempt at being vaguely
  86      i18n friendly, this is an array of two messages.  When present,
  87      the PRE and POST EXPLANATION[SERIES] are used to wrap the
  88      message.  */
  89   const struct explanation *explanation;
  90 };
  91
  92 static struct complain complaint_sentinel;
  93
  94 /* The symbol table complaint table.  */
  95
  96 static struct explanation symfile_explanations[] = {
  97   { "During symbol reading, ", "." },
  98   { "During symbol reading...", "..."},
  99   { "", "..."},
 100   { "", "..."},
 101   { NULL, NULL }
 102 };
 103
 104 static struct complaints symfile_complaint_book = {
 105   &complaint_sentinel,
 106   0,
 107   symfile_explanations
 108 };
 109 struct complaints *symfile_complaints = &symfile_complaint_book;
 110
 111 /* Wrapper function to, on-demand, fill in a complaints object.  */
 112
 113 static struct complaints *
 114 get_complaints (struct complaints **c)
 115 {
 116   if ((*c) != NULL)
 117     return (*c);
 118   (*c) = XMALLOC (struct complaints);
 119   (*c)->root = &complaint_sentinel;
 120   (*c)->series = ISOLATED_MESSAGE;
 121   (*c)->explanation = NULL;
 122   return (*c);
 123 }
 124
 125 static struct complain *
 126 find_complaint (struct complaints *complaints, const char *file,
 127                 int line, const char *fmt)
 128 {
 129   struct complain *complaint;
 130
 131   /* Find the complaint in the table.  A more efficient search
 132      algorithm (based on hash table or something) could be used.  But
 133      that can wait until someone shows evidence that this lookup is
 134      a real bottle neck.  */
 135   for (complaint = complaints->root;
 136        complaint != NULL;
 137        complaint = complaint->next)
 138     {
 139       if (complaint->fmt == fmt
 140           && complaint->file == file
 141           && complaint->line == line)
 142         return complaint;
 143     }
 144
 145   /* Oops not seen before, fill in a new complaint.  */
 146   complaint = XMALLOC (struct complain);
 147   complaint->fmt = fmt;
 148   complaint->file = file;
 149   complaint->line = line;
 150   complaint->counter = 0;
 151   complaint->next = NULL;
 152
 153   /* File it, return it.  */
 154   complaint->next = complaints->root;
 155   complaints->root = complaint;
 156   return complaint;
 157 }
 158
 159
 160 /* How many complaints about a particular thing should be printed
 161    before we stop whining about it?  Default is no whining at all,
 162    since so many systems have ill-constructed symbol files.  */
 163
 164 static int stop_whining = 0;
 165
 166 /* Print a complaint, and link the complaint block into a chain for
 167    later handling.  */
 168
 169 static void ATTR_FORMAT (printf, 4, 0)
 170 vcomplaint (struct complaints **c, const char *file, int line, const char *fmt,
 171             va_list args)
 172 {
 173   struct complaints *complaints = get_complaints (c);
 174   struct complain *complaint = find_complaint (complaints, file, line, fmt);
 175   enum complaint_series series;
 176   gdb_assert (complaints != NULL);
 177
 178   complaint->counter++;
 179   if (complaint->counter > stop_whining)
 180     return;
 181
 182   if (info_verbose)
 183     series = SUBSEQUENT_MESSAGE;
 184   else
 185     series = complaints->series;
 186
 187   if (complaint->file != NULL)
 188     internal_vwarning (complaint->file, complaint->line, complaint->fmt, args);
 189   else if (deprecated_warning_hook)
 190     (*deprecated_warning_hook) (complaint->fmt, args);
 191   else
 192     {
 193       if (complaints->explanation == NULL)
 194         /* A [v]warning() call always appends a newline.  */
 195         vwarning (complaint->fmt, args);
 196       else
 197         {
 198           char *msg;
 199           struct cleanup *cleanups;
 200           msg = xstrvprintf (complaint->fmt, args);
 201           cleanups = make_cleanup (xfree, msg);
 202           wrap_here ("");
 203           if (series != SUBSEQUENT_MESSAGE)
 204             begin_line ();
 205           /* XXX: i18n */
 206           fprintf_filtered (gdb_stderr, "%s%s%s",
 207                             complaints->explanation[series].prefix, msg,
 208                             complaints->explanation[series].postfix);
 209           /* Force a line-break after any isolated message.  For the
 210              other cases, clear_complaints() takes care of any missing
 211              trailing newline, the wrap_here() is just a hint.  */
 212           if (series == ISOLATED_MESSAGE)
 213             /* It would be really nice to use begin_line() here.
 214                Unfortunately that function doesn't track GDB_STDERR and
 215                consequently will sometimes supress a line when it
 216                shouldn't.  */
 217             fputs_filtered ("\n", gdb_stderr);
 218           else
 219             wrap_here ("");
 220           do_cleanups (cleanups);
 221         }
 222     }
 223
 224   switch (series)
 225     {
 226     case ISOLATED_MESSAGE:
 227       break;
 228     case FIRST_MESSAGE:
 229       complaints->series = SUBSEQUENT_MESSAGE;
 230       break;
 231     case SUBSEQUENT_MESSAGE:
 232     case SHORT_FIRST_MESSAGE:
 233       complaints->series = SUBSEQUENT_MESSAGE;
 234       break;
 235     }
 236
 237   /* If GDB dumps core, we'd like to see the complaints first.
 238      Presumably GDB will not be sending so many complaints that this
 239      becomes a performance hog.  */
 240
 241   gdb_flush (gdb_stderr);
 242 }
 243
 244 void
 245 complaint (struct complaints **complaints, const char *fmt, ...)
 246 {
 247   va_list args;
 248   va_start (args, fmt);
 249   vcomplaint (complaints, NULL/*file*/, 0/*line*/, fmt, args);
 250   va_end (args);
 251 }
 252
 253 void
 254 internal_complaint (struct complaints **complaints, const char *file,
 255                     int line, const char *fmt, ...)
 256 {
 257   va_list args;
 258   va_start (args, fmt);
 259   vcomplaint (complaints, file, line, fmt, args);
 260   va_end (args);
 261 }
 262
 263 /* Clear out / initialize all complaint counters that have ever been
 264    incremented.  If LESS_VERBOSE is 1, be less verbose about
 265    successive complaints, since the messages are appearing all
 266    together during a command that is reporting a contiguous block of
 267    complaints (rather than being interleaved with other messages).  If
 268    noisy is 1, we are in a noisy command, and our caller will print
 269    enough context for the user to figure it out.  */
 270
 271 void
 272 clear_complaints (struct complaints **c, int less_verbose, int noisy)
 273 {
 274   struct complaints *complaints = get_complaints (c);
 275   struct complain *p;
 276
 277   for (p = complaints->root; p != NULL; p = p->next)
 278     {
 279       p->counter = 0;
 280     }
 281
 282   switch (complaints->series)
 283     {
 284     case FIRST_MESSAGE:
 285       /* Haven't yet printed anything.  */
 286       break;
 287     case SHORT_FIRST_MESSAGE:
 288       /* Haven't yet printed anything.  */
 289       break;
 290     case ISOLATED_MESSAGE:
 291       /* The code above, always forces a line-break.  No need to do it
 292          here.  */
 293       break;
 294     case SUBSEQUENT_MESSAGE:
 295       /* It would be really nice to use begin_line() here.
 296          Unfortunately that function doesn't track GDB_STDERR and
 297          consequently will sometimes supress a line when it shouldn't.  */
 298       fputs_unfiltered ("\n", gdb_stderr);
 299       break;
 300     default:
 301       internal_error (__FILE__, __LINE__, _("bad switch"));
 302     }
 303
 304   if (!less_verbose)
 305     complaints->series = ISOLATED_MESSAGE;
 306   else if (!noisy)
 307     complaints->series = FIRST_MESSAGE;
 308   else
 309     complaints->series = SHORT_FIRST_MESSAGE;
 310 }
 311
 312 static void
 313 complaints_show_value (struct ui_file *file, int from_tty,
 314                        struct cmd_list_element *cmd, const char *value)
 315 {
 316   fprintf_filtered (file, _("Max number of complaints about incorrect"
 317                             " symbols is %s.\n"),
 318                     value);
 319 }
 320
 321 void
 322 _initialize_complaints (void)
 323 {
 324   add_setshow_zinteger_cmd ("complaints", class_support, &stop_whining, _("\
 325 Set max number of complaints about incorrect symbols."), _("\
 326 Show max number of complaints about incorrect symbols."), NULL,
 327                             NULL, complaints_show_value,
 328                             &setlist, &showlist);
 329 }