gdb/complaints.c

   1 /* Support for complaint handling during symbol reading in GDB.
   2
   3    Copyright 1990, 1991, 1992, 1993, 1995, 1998, 1999, 2000, 2002 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 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., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, 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 struct complaints
  64 {
  65   struct complain *root;
  66
  67   /* Should each complaint be self explanatory, or should we assume
  68      that a series of complaints is being produced?  case 0: Isolated
  69      self explanatory message.  case 1: First message of a series that
  70      must start off with explanation.  case 2: Subsequent message of a
  71      series that needs no explanation (the user already knows we have
  72      a problem so we can just state our piece).  */
  73   int series;
  74
  75   /* The explanatory messages that should accompany the complaint.
  76      NOTE: cagney/2002-08-14: In a desperate attempt at being vaguely
  77      i18n friendly, this is an array of two messages.  When present,
  78      EXPLANATION[SERIES] is used to wrap the message.  */
  79   const char **explanation;
  80 };
  81
  82 static struct complain complaint_sentinel;
  83
  84 /* The symbol table complaint table.  */
  85
  86 static const char *symfile_explanations[] = {
  87   "During symbol reading, %s.\n",
  88   "During symbol reading...%s...",
  89   "%s...",
  90   "%s...",
  91   NULL
  92 };
  93
  94 static struct complaints symfile_complaint_book = {
  95   &complaint_sentinel,
  96   0,
  97   symfile_explanations
  98 };
  99 struct complaints *symfile_complaints = &symfile_complaint_book;
 100
 101 /* Wrapper function to, on-demand, fill in a complaints object.  */
 102
 103 static struct complaints *
 104 get_complaints (struct complaints **c)
 105 {
 106   if ((*c) != NULL)
 107     return (*c);
 108   (*c) = XMALLOC (struct complaints);
 109   (*c)->root = &complaint_sentinel;
 110   (*c)->series = ISOLATED_MESSAGE;
 111   (*c)->explanation = NULL;
 112   return (*c);
 113 }
 114
 115 static struct complain *
 116 find_complaint (struct complaints *complaints, const char *file,
 117                 int line, const char *fmt)
 118 {
 119   struct complain *complaint;
 120
 121   /* Find the complaint in the table.  A more efficient search
 122      algorithm (based on hash table or something) could be used.  But
 123      that can wait until someone shows evidence that this lookup is
 124      a real bottle neck.  */
 125   for (complaint = complaints->root;
 126        complaint != NULL;
 127        complaint = complaint->next)
 128     {
 129       if (complaint->fmt == fmt
 130           && complaint->file == file
 131           && complaint->line == line)
 132         return complaint;
 133     }
 134
 135   /* Oops not seen before, fill in a new complaint.  */
 136   complaint = XMALLOC (struct complain);
 137   complaint->fmt = fmt;
 138   complaint->file = file;
 139   complaint->line = line;
 140   complaint->counter = 0;
 141   complaint->next = NULL;
 142
 143   /* File it, return it.  */
 144   complaint->next = complaints->root;
 145   complaints->root = complaint;
 146   return complaint;
 147 }
 148
 149
 150 /* How many complaints about a particular thing should be printed
 151    before we stop whining about it?  Default is no whining at all,
 152    since so many systems have ill-constructed symbol files.  */
 153
 154 static unsigned int stop_whining = 0;
 155
 156 /* Print a complaint, and link the complaint block into a chain for
 157    later handling.  */
 158
 159 static void
 160 vcomplaint (struct complaints **c, const char *file, int line, const char *fmt,
 161             va_list args)
 162 {
 163   struct complaints *complaints = get_complaints (c);
 164   struct complain *complaint = find_complaint (complaints, file, line, fmt);
 165   enum complaint_series series;
 166   gdb_assert (complaints != NULL);
 167
 168   complaint->counter++;
 169   if (complaint->counter > stop_whining)
 170     return;
 171
 172   if (info_verbose)
 173     series = SUBSEQUENT_MESSAGE;
 174   else
 175     series = complaints->series;
 176
 177   if (complaint->file != NULL)
 178     internal_vwarning (complaint->file, complaint->line, complaint->fmt, args);
 179   else if (warning_hook)
 180     (*warning_hook) (complaint->fmt, args);
 181   else
 182     {
 183       if (complaints->explanation == NULL)
 184         vwarning (complaint->fmt, args);
 185       else
 186         {
 187           char *msg;
 188           struct cleanup *cleanups;
 189           xvasprintf (&msg, complaint->fmt, args);
 190           cleanups = make_cleanup (xfree, msg);
 191           wrap_here ("");
 192           if (series != SUBSEQUENT_MESSAGE)
 193             begin_line ();
 194           fprintf_filtered (gdb_stderr,
 195                             complaints->explanation[series],
 196                             msg);
 197           wrap_here ("");
 198           do_cleanups (cleanups);
 199         }
 200     }
 201
 202   switch (series)
 203     {
 204     case ISOLATED_MESSAGE:
 205       break;
 206     case FIRST_MESSAGE:
 207       complaints->series = SUBSEQUENT_MESSAGE;
 208       break;
 209     case SUBSEQUENT_MESSAGE:
 210     case SHORT_FIRST_MESSAGE:
 211       complaints->series = SUBSEQUENT_MESSAGE;
 212       break;
 213     }
 214
 215   /* If GDB dumps core, we'd like to see the complaints first.
 216      Presumably GDB will not be sending so many complaints that this
 217      becomes a performance hog.  */
 218
 219   gdb_flush (gdb_stderr);
 220 }
 221
 222 void
 223 complaint (struct complaints **complaints, const char *fmt, ...)
 224 {
 225   va_list args;
 226   va_start (args, fmt);
 227   vcomplaint (complaints, NULL/*file*/, 0/*line*/, fmt, args);
 228   va_end (args);
 229 }
 230
 231 void
 232 internal_complaint (struct complaints **complaints, const char *file,
 233                     int line, const char *fmt, ...)
 234 {
 235   va_list args;
 236   va_start (args, fmt);
 237   vcomplaint (complaints, file, line, fmt, args);
 238   va_end (args);
 239 }
 240
 241 void
 242 complain (struct complaint *complaint, ...)
 243 {
 244   va_list args;
 245   va_start (args, complaint);
 246   vcomplaint (&symfile_complaints, NULL/*file*/, 0/*line*/,
 247               complaint->message, args);
 248   va_end (args);
 249 }
 250
 251 /* Clear out / initialize all complaint counters that have ever been
 252    incremented.  If LESS_VERBOSE is 1, be less verbose about
 253    successive complaints, since the messages are appearing all
 254    together during a command that is reporting a contiguous block of
 255    complaints (rather than being interleaved with other messages).  If
 256    noisy is 1, we are in a noisy command, and our caller will print
 257    enough context for the user to figure it out.  */
 258
 259 void
 260 clear_complaints (struct complaints **c, int less_verbose, int noisy)
 261 {
 262   struct complaints *complaints = get_complaints (c);
 263   struct complain *p;
 264
 265   for (p = complaints->root; p != NULL; p = p->next)
 266     {
 267       p->counter = 0;
 268     }
 269
 270   if (complaints->series > 1 && !warning_hook)
 271     {
 272       /* Terminate previous series, since caller won't.  */
 273       puts_filtered ("\n");
 274     }
 275
 276   if (!less_verbose)
 277     complaints->series = ISOLATED_MESSAGE;
 278   else if (!noisy)
 279     complaints->series = FIRST_MESSAGE;
 280   else
 281     complaints->series = SHORT_FIRST_MESSAGE;
 282 }
 283
 284 void
 285 _initialize_complaints (void)
 286 {
 287   add_setshow_cmd ("complaints", class_support, var_zinteger,
 288                    &stop_whining,
 289                    "Set max number of complaints about incorrect symbols.",
 290                    "Show max number of complaints about incorrect symbols.",
 291                    NULL, NULL,
 292                    &setlist, &showlist);
 293
 294 }