gcc/cp/errfn.c

   1 /* Provide a call-back mechanism for handling error output.
   2    Copyright (C) 1993, 94, 95, 96, 97, 98, 99, 2000
   3    Free Software Foundation, Inc.
   4    Contributed by Jason Merrill (jason@cygnus.com)
   5
   6    This file is part of GNU CC.
   7
   8 GNU CC 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, or (at your option)
  11 any later version.
  12
  13 GNU CC 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 GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "tree.h"
  26 #include "cp-tree.h"
  27 #include "toplev.h"
  28
  29 /* cp_printer is the type of a function which converts an argument into
  30    a string for digestion by printf.  The cp_printer function should deal
  31    with all memory management; the functions in this file will not free
  32    the char*s returned.  See error.c for an example use of this code.  */
  33
  34 typedef const char *cp_printer PARAMS ((tree, int));
  35 extern cp_printer * cp_printers[256];
  36
  37 /* Whether or not we should try to be quiet for errors and warnings; this is
  38    used to avoid being too talkative about problems with tentative choices
  39    when we're computing the conversion costs for a method call.  */
  40 int cp_silent = 0;
  41
  42 typedef void errorfn ();        /* deliberately vague */
  43
  44 static void cp_thing PARAMS ((errorfn *, int, const char *, va_list));
  45
  46 #define STRDUP(f) (ap = (char *) alloca (strlen (f) +1), strcpy (ap, (f)), ap)
  47
  48 /* This function supports only `%s', `%d', `%%', and the C++ print
  49    codes.  */
  50
  51 static void
  52 cp_thing (errfn, atarg1, format, ap)
  53      errorfn *errfn;
  54      int atarg1;
  55      const char *format;
  56      va_list ap;
  57 {
  58   static char *buf;
  59   static long buflen;
  60   int nargs = 0;
  61   long len;
  62   long offset;
  63   const char *f;
  64   tree atarg = 0;
  65
  66   len = strlen (format) + 1;
  67   if (len > buflen)
  68     {
  69       buflen = len;
  70       buf = xrealloc (buf, buflen);
  71     }
  72   offset = 0;
  73
  74   for (f = format; *f; ++f)
  75     {
  76       cp_printer * function;
  77       int alternate;
  78       int maybe_here;
  79
  80       /* ignore text */
  81       if (*f != '%')
  82         {
  83           buf[offset++] = *f;
  84           continue;
  85         }
  86
  87       ++f;
  88
  89       alternate = 0;
  90       maybe_here = 0;
  91
  92       /* Check for '+' and '#' (in that order). */
  93       if (*f == '+')
  94         {
  95           maybe_here = 1;
  96           ++f;
  97         }
  98       if (*f == '#')
  99         {
 100           alternate = 1;
 101           ++f;
 102         }
 103
 104       /* no field width or precision */
 105
 106       function = cp_printers[(int)*f];
 107
 108       if (function || *f == 's')
 109         {
 110           const char *p;
 111           int plen;
 112
 113           if (*f == 's')
 114             {
 115               p = va_arg (ap, char *);
 116               nargs++;
 117             }
 118           else
 119             {
 120               tree t = va_arg (ap, tree);
 121               nargs++;
 122
 123               /* This indicates that ATARG comes from a different
 124                  location than normal.  */
 125               if (maybe_here && atarg1)
 126                 atarg = t;
 127
 128               /* If atarg1 is set and this is the first argument, then
 129                  set ATARG appropriately.  */
 130               if (atarg1 && nargs == 1)
 131                 atarg = t;
 132
 133               p = (*function) (t, alternate);
 134             }
 135
 136           plen = strlen (p);
 137           len += plen;
 138           if (len > buflen)
 139             {
 140               buflen = len;
 141               buf = xrealloc (buf, len);
 142             }
 143           strcpy (buf + offset, p);
 144           offset += plen;
 145         }
 146       else if (*f == '%')
 147         {
 148           /* A `%%' has occurred in the input string. Replace it with
 149              a `%' in the formatted message buf. */
 150
 151           if (++len > buflen)
 152             {
 153               buflen = len;
 154               buf = xrealloc (buf, len);
 155             }
 156           buf[offset++] = '%';
 157         }
 158       else
 159         {
 160           if (*f != 'd')
 161             abort ();
 162           len += HOST_BITS_PER_INT / 2;
 163           if (len > buflen)
 164             {
 165               buflen = len;
 166               buf = xrealloc (buf, len);
 167             }
 168           sprintf (buf + offset, "%d", va_arg (ap, int));
 169           nargs++;
 170           offset += strlen (buf + offset);
 171           /* With an ANSI C library one could write
 172              out += sprintf (...); */
 173         }
 174     }
 175   buf[offset] = '\0';
 176
 177   /* If ATARG1 is set, but we haven't extracted any arguments, then
 178      extract one tree argument for ATARG.  */
 179   if (nargs == 0 && atarg1)
 180     atarg = va_arg (ap, tree);
 181
 182   if (atarg)
 183     {
 184       const char *file = cp_file_of (atarg);
 185       int   line = cp_line_of (atarg);
 186       (*errfn) (file, line, "%s", buf);
 187     }
 188   else
 189     (*errfn) ("%s", buf);
 190
 191 }
 192
 193 void
 194 cp_error VPARAMS ((const char *format, ...))
 195 {
 196 #ifndef ANSI_PROTOTYPES
 197   char *format;
 198 #endif
 199   va_list ap;
 200
 201   VA_START (ap, format);
 202
 203 #ifndef ANSI_PROTOTYPES
 204   format = va_arg (ap, char *);
 205 #endif
 206
 207   if (! cp_silent)
 208     cp_thing ((errorfn *) error, 0, format, ap);
 209   va_end (ap);
 210 }
 211
 212 void
 213 cp_warning VPARAMS ((const char *format, ...))
 214 {
 215 #ifndef ANSI_PROTOTYPES
 216   char *format;
 217 #endif
 218   va_list ap;
 219
 220   VA_START (ap, format);
 221
 222 #ifndef ANSI_PROTOTYPES
 223   format = va_arg (ap, char *);
 224 #endif
 225
 226   if (! cp_silent)
 227     cp_thing ((errorfn *) warning, 0, format, ap);
 228   va_end (ap);
 229 }
 230
 231 void
 232 cp_pedwarn VPARAMS ((const char *format, ...))
 233 {
 234 #ifndef ANSI_PROTOTYPES
 235   char *format;
 236 #endif
 237   va_list ap;
 238
 239   VA_START (ap, format);
 240
 241 #ifndef ANSI_PROTOTYPES
 242   format = va_arg (ap, char *);
 243 #endif
 244
 245   if (! cp_silent)
 246     cp_thing ((errorfn *) pedwarn, 0, format, ap);
 247   va_end (ap);
 248 }
 249
 250 void
 251 cp_compiler_error VPARAMS ((const char *format, ...))
 252 {
 253 #ifndef ANSI_PROTOTYPES
 254   char *format;
 255 #endif
 256   va_list ap;
 257
 258   VA_START (ap, format);
 259
 260 #ifndef ANSI_PROTOTYPES
 261   format = va_arg (ap, char *);
 262 #endif
 263
 264   if (! cp_silent)
 265     cp_thing ((errorfn *) compiler_error, 0, format, ap);
 266   va_end (ap);
 267 }
 268
 269 void
 270 cp_deprecated (msg)
 271   const char *msg;
 272 {
 273   extern int warn_deprecated;
 274   if (!warn_deprecated)
 275     return;
 276   cp_warning ("%s is deprecated.", msg);
 277   cp_warning ("Please see the documentation for details.");
 278 }
 279
 280 void
 281 cp_sprintf VPARAMS ((const char *format, ...))
 282 {
 283 #ifndef ANSI_PROTOTYPES
 284   char *format;
 285 #endif
 286   va_list ap;
 287
 288   VA_START (ap, format);
 289
 290 #ifndef ANSI_PROTOTYPES
 291   format = va_arg (ap, char *);
 292 #endif
 293
 294   cp_thing ((errorfn *) sprintf, 0, format, ap);
 295   va_end (ap);
 296 }
 297
 298 void
 299 cp_error_at VPARAMS ((const char *format, ...))
 300 {
 301 #ifndef ANSI_PROTOTYPES
 302   char *format;
 303 #endif
 304   va_list ap;
 305
 306   VA_START (ap, format);
 307
 308 #ifndef ANSI_PROTOTYPES
 309   format = va_arg (ap, char *);
 310 #endif
 311
 312   if (! cp_silent)
 313     cp_thing ((errorfn *) error_with_file_and_line, 1, format, ap);
 314   va_end (ap);
 315 }
 316
 317 void
 318 cp_warning_at VPARAMS ((const char *format, ...))
 319 {
 320 #ifndef ANSI_PROTOTYPES
 321   char *format;
 322 #endif
 323   va_list ap;
 324
 325   VA_START (ap, format);
 326
 327 #ifndef ANSI_PROTOTYPES
 328   format = va_arg (ap, char *);
 329 #endif
 330
 331   if (! cp_silent)
 332     cp_thing ((errorfn *) warning_with_file_and_line, 1, format, ap);
 333   va_end (ap);
 334 }
 335
 336 void
 337 cp_pedwarn_at VPARAMS ((const char *format, ...))
 338 {
 339 #ifndef ANSI_PROTOTYPES
 340   char *format;
 341 #endif
 342   va_list ap;
 343
 344   VA_START (ap, format);
 345
 346 #ifndef ANSI_PROTOTYPES
 347   format = va_arg (ap, char *);
 348 #endif
 349
 350   if (! cp_silent)
 351     cp_thing ((errorfn *) pedwarn_with_file_and_line, 1, format, ap);
 352   va_end (ap);
 353 }