gdb/complaints.c

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