libyasm/errwarn.c

   1 /*
   2  * Error and warning reporting and related functions.
   3  *
   4  *  Copyright (C) 2001-2007  Peter Johnson
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND OTHER CONTRIBUTORS ``AS IS''
  16  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR OTHER CONTRIBUTORS BE
  19  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  20  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  21  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  22  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  23  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  24  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  25  * POSSIBILITY OF SUCH DAMAGE.
  26  */
  27 #include "util.h"
  28
  29 #include <ctype.h>
  30 #include <stdarg.h>
  31
  32 #include "coretype.h"
  33
  34 #include "linemap.h"
  35 #include "errwarn.h"
  36
  37
  38 #define MSG_MAXSIZE     1024
  39
  40 #if !defined(HAVE_TOASCII) || defined(lint)
  41 # define toascii(c) ((c) & 0x7F)
  42 #endif
  43
  44 /* Default handlers for replacable functions */
  45 static /*@exits@*/ void def_internal_error_
  46     (const char *file, unsigned int line, const char *message);
  47 static /*@exits@*/ void def_fatal(const char *message, va_list va);
  48 static const char *def_gettext_hook(const char *msgid);
  49
  50 /* Storage for errwarn's "extern" functions */
  51 /*@exits@*/ void (*yasm_internal_error_)
  52     (const char *file, unsigned int line, const char *message)
  53     = def_internal_error_;
  54 /*@exits@*/ void (*yasm_fatal) (const char *message, va_list va) = def_fatal;
  55 const char * (*yasm_gettext_hook) (const char *msgid) = def_gettext_hook;
  56
  57 /* Error indicator */
  58 /* yasm_eclass is not static so that yasm_error_occurred macro can access it */
  59 yasm_error_class yasm_eclass;
  60 static /*@only@*/ /*@null@*/ char *yasm_estr;
  61 static unsigned long yasm_exrefline;
  62 static /*@only@*/ /*@null@*/ char *yasm_exrefstr;
  63
  64 /* Warning indicator */
  65 typedef struct warn {
  66     /*@reldef@*/ STAILQ_ENTRY(warn) link;
  67
  68     yasm_warn_class wclass;
  69     /*@owned@*/ /*@null@*/ char *wstr;
  70 } warn;
  71 static STAILQ_HEAD(warn_head, warn) yasm_warns;
  72
  73 /* Enabled warnings.  See errwarn.h for a list. */
  74 static unsigned long warn_class_enabled;
  75
  76 typedef struct errwarn_data {
  77     /*@reldef@*/ SLIST_ENTRY(errwarn_data) link;
  78
  79     enum { WE_UNKNOWN, WE_ERROR, WE_WARNING, WE_PARSERERROR } type;
  80
  81     unsigned long line;
  82     unsigned long xrefline;
  83     /*@owned@*/ char *msg;
  84     /*@owned@*/ char *xrefmsg;
  85 } errwarn_data;
  86
  87 struct yasm_errwarns {
  88     /*@reldef@*/ SLIST_HEAD(errwarn_head, errwarn_data) errwarns;
  89
  90     /* Total error count */
  91     unsigned int ecount;
  92
  93     /* Total warning count */
  94     unsigned int wcount;
  95
  96     /* Last inserted error/warning.  Used to speed up insertions. */
  97     /*@null@*/ errwarn_data *previous_we;
  98 };
  99
 100 /* Static buffer for use by conv_unprint(). */
 101 static char unprint[5];
 102
 103
 104 static const char *
 105 def_gettext_hook(const char *msgid)
 106 {
 107     return msgid;
 108 }
 109
 110 void
 111 yasm_errwarn_initialize(void)
 112 {
 113     /* Default enabled warnings.  See errwarn.h for a list. */
 114     warn_class_enabled =
 115         (1UL<<YASM_WARN_GENERAL) | (1UL<<YASM_WARN_UNREC_CHAR) |
 116         (1UL<<YASM_WARN_PREPROC) | (0UL<<YASM_WARN_ORPHAN_LABEL) |
 117         (1UL<<YASM_WARN_UNINIT_CONTENTS) | (0UL<<YASM_WARN_SIZE_OVERRIDE) |
 118         (1UL<<YASM_WARN_IMPLICIT_SIZE_OVERRIDE);
 119
 120     yasm_eclass = YASM_ERROR_NONE;
 121     yasm_estr = NULL;
 122     yasm_exrefline = 0;
 123     yasm_exrefstr = NULL;
 124
 125     STAILQ_INIT(&yasm_warns);
 126 }
 127
 128 void
 129 yasm_errwarn_cleanup(void)
 130 {
 131     yasm_error_clear();
 132     yasm_warn_clear();
 133 }
 134
 135 /* Convert a possibly unprintable character into a printable string, using
 136  * standard cat(1) convention for unprintable characters.
 137  */
 138 char *
 139 yasm__conv_unprint(int ch)
 140 {
 141     int pos = 0;
 142
 143     if (((ch & ~0x7F) != 0) /*!isascii(ch)*/ && !isprint(ch)) {
 144         unprint[pos++] = 'M';
 145         unprint[pos++] = '-';
 146         ch &= toascii(ch);
 147     }
 148     if (iscntrl(ch)) {
 149         unprint[pos++] = '^';
 150         unprint[pos++] = (ch == '\177') ? '?' : ch | 0100;
 151     } else
 152         unprint[pos++] = ch;
 153     unprint[pos] = '\0';
 154
 155     return unprint;
 156 }
 157
 158 /* Report an internal error.  Essentially a fatal error with trace info.
 159  * Exit immediately because it's essentially an assert() trap.
 160  */
 161 static void
 162 def_internal_error_(const char *file, unsigned int line, const char *message)
 163 {
 164     fprintf(stderr,
 165             yasm_gettext_hook(N_("INTERNAL ERROR at %s, line %u: %s\n")),
 166             file, line, yasm_gettext_hook(message));
 167 #ifdef HAVE_ABORT
 168     abort();
 169 #else
 170     exit(EXIT_FAILURE);
 171 #endif
 172 }
 173
 174 /* Report a fatal error.  These are unrecoverable (such as running out of
 175  * memory), so just exit immediately.
 176  */
 177 static void
 178 def_fatal(const char *fmt, va_list va)
 179 {
 180     fprintf(stderr, "%s: ", yasm_gettext_hook(N_("FATAL")));
 181     vfprintf(stderr, yasm_gettext_hook(fmt), va);
 182     fputc('\n', stderr);
 183     exit(EXIT_FAILURE);
 184 }
 185
 186 /* Create an errwarn structure in the correct linked list location.
 187  * If replace_parser_error is nonzero, overwrites the last error if its
 188  * type is WE_PARSERERROR.
 189  */
 190 static errwarn_data *
 191 errwarn_data_new(yasm_errwarns *errwarns, unsigned long line,
 192                  int replace_parser_error)
 193 {
 194     errwarn_data *first, *next, *ins_we, *we;
 195     enum { INS_NONE, INS_HEAD, INS_AFTER } action = INS_NONE;
 196
 197     /* Find the entry with either line=line or the last one with line<line.
 198      * Start with the last entry added to speed the search.
 199      */
 200     ins_we = errwarns->previous_we;
 201     first = SLIST_FIRST(&errwarns->errwarns);
 202     if (!ins_we || !first)
 203         action = INS_HEAD;
 204     while (action == INS_NONE) {
 205         next = SLIST_NEXT(ins_we, link);
 206         if (line < ins_we->line) {
 207             if (ins_we == first)
 208                 action = INS_HEAD;
 209             else
 210                 ins_we = first;
 211         } else if (!next)
 212             action = INS_AFTER;
 213         else if (line >= ins_we->line && line < next->line)
 214             action = INS_AFTER;
 215         else
 216             ins_we = next;
 217     }
 218
 219     if (replace_parser_error && ins_we && ins_we->type == WE_PARSERERROR) {
 220         /* overwrite last error */
 221         we = ins_we;
 222     } else {
 223         /* add a new error */
 224         we = yasm_xmalloc(sizeof(errwarn_data));
 225
 226         we->type = WE_UNKNOWN;
 227         we->line = line;
 228         we->xrefline = 0;
 229         we->msg = NULL;
 230         we->xrefmsg = NULL;
 231
 232         if (action == INS_HEAD)
 233             SLIST_INSERT_HEAD(&errwarns->errwarns, we, link);
 234         else if (action == INS_AFTER) {
 235             assert(ins_we != NULL);
 236             SLIST_INSERT_AFTER(ins_we, we, link);
 237         } else
 238             yasm_internal_error(N_("Unexpected errwarn insert action"));
 239     }
 240
 241     /* Remember previous err/warn */
 242     errwarns->previous_we = we;
 243
 244     return we;
 245 }
 246
 247 void
 248 yasm_error_clear(void)
 249 {
 250     if (yasm_estr)
 251         yasm_xfree(yasm_estr);
 252     if (yasm_exrefstr)
 253         yasm_xfree(yasm_exrefstr);
 254     yasm_eclass = YASM_ERROR_NONE;
 255     yasm_estr = NULL;
 256     yasm_exrefline = 0;
 257     yasm_exrefstr = NULL;
 258 }
 259
 260 int
 261 yasm_error_matches(yasm_error_class eclass)
 262 {
 263     if (yasm_eclass == YASM_ERROR_NONE)
 264         return eclass == YASM_ERROR_NONE;
 265     if (yasm_eclass == YASM_ERROR_GENERAL)
 266         return eclass == YASM_ERROR_GENERAL;
 267     return (yasm_eclass & eclass) == eclass;
 268 }
 269
 270 void
 271 yasm_error_set_va(yasm_error_class eclass, const char *format, va_list va)
 272 {
 273     if (yasm_eclass != YASM_ERROR_NONE)
 274         return;
 275
 276     yasm_eclass = eclass;
 277     yasm_estr = yasm_xmalloc(MSG_MAXSIZE+1);
 278 #ifdef HAVE_VSNPRINTF
 279     vsnprintf(yasm_estr, MSG_MAXSIZE, yasm_gettext_hook(format), va);
 280 #else
 281     vsprintf(yasm_estr, yasm_gettext_hook(format), va);
 282 #endif
 283 }
 284
 285 void
 286 yasm_error_set(yasm_error_class eclass, const char *format, ...)
 287 {
 288     va_list va;
 289     va_start(va, format);
 290     yasm_error_set_va(eclass, format, va);
 291     va_end(va);
 292 }
 293
 294 void
 295 yasm_error_set_xref_va(unsigned long xrefline, const char *format, va_list va)
 296 {
 297     if (yasm_eclass != YASM_ERROR_NONE)
 298         return;
 299
 300     yasm_exrefline = xrefline;
 301
 302     yasm_exrefstr = yasm_xmalloc(MSG_MAXSIZE+1);
 303 #ifdef HAVE_VSNPRINTF
 304     vsnprintf(yasm_exrefstr, MSG_MAXSIZE, yasm_gettext_hook(format), va);
 305 #else
 306     vsprintf(yasm_exrefstr, yasm_gettext_hook(format), va);
 307 #endif
 308 }
 309
 310 void
 311 yasm_error_set_xref(unsigned long xrefline, const char *format, ...)
 312 {
 313     va_list va;
 314     va_start(va, format);
 315     yasm_error_set_xref_va(xrefline, format, va);
 316     va_end(va);
 317 }
 318
 319 void
 320 yasm_error_fetch(yasm_error_class *eclass, char **str, unsigned long *xrefline,
 321                  char **xrefstr)
 322 {
 323     *eclass = yasm_eclass;
 324     *str = yasm_estr;
 325     *xrefline = yasm_exrefline;
 326     *xrefstr = yasm_exrefstr;
 327     yasm_eclass = YASM_ERROR_NONE;
 328     yasm_estr = NULL;
 329     yasm_exrefline = 0;
 330     yasm_exrefstr = NULL;
 331 }
 332
 333 void yasm_warn_clear(void)
 334 {
 335     /* Delete all error/warnings */
 336     while (!STAILQ_EMPTY(&yasm_warns)) {
 337         warn *w = STAILQ_FIRST(&yasm_warns);
 338
 339         if (w->wstr)
 340             yasm_xfree(w->wstr);
 341
 342         STAILQ_REMOVE_HEAD(&yasm_warns, link);
 343         yasm_xfree(w);
 344     }
 345 }
 346
 347 yasm_warn_class
 348 yasm_warn_occurred(void)
 349 {
 350     if (STAILQ_EMPTY(&yasm_warns))
 351         return YASM_WARN_NONE;
 352     return STAILQ_FIRST(&yasm_warns)->wclass;
 353 }
 354
 355 void
 356 yasm_warn_set_va(yasm_warn_class wclass, const char *format, va_list va)
 357 {
 358     warn *w;
 359
 360     if (!(warn_class_enabled & (1UL<<wclass)))
 361         return;     /* warning is part of disabled class */
 362
 363     w = yasm_xmalloc(sizeof(warn));
 364     w->wclass = wclass;
 365     w->wstr = yasm_xmalloc(MSG_MAXSIZE+1);
 366 #ifdef HAVE_VSNPRINTF
 367     vsnprintf(w->wstr, MSG_MAXSIZE, yasm_gettext_hook(format), va);
 368 #else
 369     vsprintf(w->wstr, yasm_gettext_hook(format), va);
 370 #endif
 371     STAILQ_INSERT_TAIL(&yasm_warns, w, link);
 372 }
 373
 374 void
 375 yasm_warn_set(yasm_warn_class wclass, const char *format, ...)
 376 {
 377     va_list va;
 378     va_start(va, format);
 379     yasm_warn_set_va(wclass, format, va);
 380     va_end(va);
 381 }
 382
 383 void
 384 yasm_warn_fetch(yasm_warn_class *wclass, char **str)
 385 {
 386     warn *w = STAILQ_FIRST(&yasm_warns);
 387
 388     if (!w) {
 389         *wclass = YASM_WARN_NONE;
 390         *str = NULL;
 391         return;
 392     }
 393
 394     *wclass = w->wclass;
 395     *str = w->wstr;
 396
 397     STAILQ_REMOVE_HEAD(&yasm_warns, link);
 398     yasm_xfree(w);
 399 }
 400
 401 void
 402 yasm_warn_enable(yasm_warn_class num)
 403 {
 404     warn_class_enabled |= (1UL<<num);
 405 }
 406
 407 void
 408 yasm_warn_disable(yasm_warn_class num)
 409 {
 410     warn_class_enabled &= ~(1UL<<num);
 411 }
 412
 413 void
 414 yasm_warn_disable_all(void)
 415 {
 416     warn_class_enabled = 0;
 417 }
 418
 419 yasm_errwarns *
 420 yasm_errwarns_create(void)
 421 {
 422     yasm_errwarns *errwarns = yasm_xmalloc(sizeof(yasm_errwarns));
 423     SLIST_INIT(&errwarns->errwarns);
 424     errwarns->ecount = 0;
 425     errwarns->wcount = 0;
 426     errwarns->previous_we = NULL;
 427     return errwarns;
 428 }
 429
 430 void
 431 yasm_errwarns_destroy(yasm_errwarns *errwarns)
 432 {
 433     errwarn_data *we;
 434
 435     /* Delete all error/warnings */
 436     while (!SLIST_EMPTY(&errwarns->errwarns)) {
 437         we = SLIST_FIRST(&errwarns->errwarns);
 438         if (we->msg)
 439             yasm_xfree(we->msg);
 440         if (we->xrefmsg)
 441             yasm_xfree(we->xrefmsg);
 442
 443         SLIST_REMOVE_HEAD(&errwarns->errwarns, link);
 444         yasm_xfree(we);
 445     }
 446
 447     yasm_xfree(errwarns);
 448 }
 449
 450 void
 451 yasm_errwarn_propagate(yasm_errwarns *errwarns, unsigned long line)
 452 {
 453     if (yasm_eclass != YASM_ERROR_NONE) {
 454         errwarn_data *we = errwarn_data_new(errwarns, line, 1);
 455         yasm_error_class eclass;
 456
 457         yasm_error_fetch(&eclass, &we->msg, &we->xrefline, &we->xrefmsg);
 458         if (eclass != YASM_ERROR_GENERAL
 459             && (eclass & YASM_ERROR_PARSE) == YASM_ERROR_PARSE)
 460             we->type = WE_PARSERERROR;
 461         else
 462             we->type = WE_ERROR;
 463         errwarns->ecount++;
 464     }
 465
 466     while (!STAILQ_EMPTY(&yasm_warns)) {
 467         errwarn_data *we = errwarn_data_new(errwarns, line, 0);
 468         yasm_warn_class wclass;
 469
 470         yasm_warn_fetch(&wclass, &we->msg);
 471         we->type = WE_WARNING;
 472         errwarns->wcount++;
 473     }
 474 }
 475
 476 unsigned int
 477 yasm_errwarns_num_errors(yasm_errwarns *errwarns, int warning_as_error)
 478 {
 479     if (warning_as_error)
 480         return errwarns->ecount+errwarns->wcount;
 481     else
 482         return errwarns->ecount;
 483 }
 484
 485 void
 486 yasm_errwarns_output_all(yasm_errwarns *errwarns, yasm_linemap *lm,
 487                          int warning_as_error,
 488                          yasm_print_error_func print_error,
 489                          yasm_print_warning_func print_warning)
 490 {
 491     errwarn_data *we;
 492     const char *filename, *xref_filename;
 493     unsigned long line, xref_line;
 494
 495     /* If we're treating warnings as errors, tell the user about it. */
 496     if (warning_as_error && warning_as_error != 2) {
 497         print_error("", 0,
 498                     yasm_gettext_hook(N_("warnings being treated as errors")),
 499                     NULL, 0, NULL);
 500         warning_as_error = 2;
 501     }
 502
 503     /* Output error/warnings. */
 504     SLIST_FOREACH(we, &errwarns->errwarns, link) {
 505         /* Output error/warning */
 506         yasm_linemap_lookup(lm, we->line, &filename, &line);
 507         if (we->xrefline)
 508             yasm_linemap_lookup(lm, we->xrefline, &xref_filename, &xref_line);
 509         else {
 510             xref_filename = NULL;
 511             xref_line = 0;
 512         }
 513         if (we->type == WE_ERROR || we->type == WE_PARSERERROR)
 514             print_error(filename, line, we->msg, xref_filename, xref_line,
 515                         we->xrefmsg);
 516         else
 517             print_warning(filename, line, we->msg);
 518     }
 519 }
 520
 521 void
 522 yasm__fatal(const char *message, ...)
 523 {
 524     va_list va;
 525     va_start(va, message);
 526     yasm_fatal(message, va);
 527     /*@notreached@*/
 528     va_end(va);
 529 }