gcc/diagnostic.c

   1 /* Top level of GNU C compiler
   2    Copyright (C) 1999 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21
  22 /* This file implements the language independant aspect of diagnostic
  23    message module.  */
  24
  25 #include "config.h"
  26 #undef FLOAT /* This is for hpux. They should change hpux.  */
  27 #undef FFS  /* Some systems define this in param.h.  */
  28 #include "system.h"
  29
  30 #include "tree.h"
  31 #include "rtl.h"
  32 #include "tm_p.h"
  33 #include "flags.h"
  34 #include "input.h"
  35 #include "insn-attr.h"
  36 #include "insn-codes.h"
  37 #include "insn-config.h"
  38 #include "toplev.h"
  39 #include "intl.h"
  40 #include "obstack.h"
  41
  42 #define obstack_chunk_alloc xmalloc
  43 #define obstack_chunk_free  free
  44
  45 struct output_buffer
  46 {
  47   struct obstack obstack;       /* where we build the text to output */
  48   const char *prefix;           /* prefix of every new line  */
  49   int line_length;              /* current line length (in characters) */
  50   int max_length;               /* maximum characters per line */
  51 };
  52
  53 /* Prototypes. */
  54 static int doing_line_wrapping PROTO((void));
  55 static void init_output_buffer PROTO((struct output_buffer*,
  56                                       const char *, int));
  57 static const char *get_output_prefix PROTO((const struct output_buffer *));
  58 static int output_space_left PROTO((const struct output_buffer *));
  59 static void emit_output_prefix PROTO((struct output_buffer *));
  60 static void output_newline PROTO((struct output_buffer *));
  61 static void output_append PROTO((struct output_buffer *, const char *,
  62                                  const char *));
  63 static void output_puts PROTO((struct output_buffer *, const char *));
  64 static void dump_output PROTO((struct output_buffer *, FILE *));
  65 static const char *vbuild_message_string PROTO((const char *, va_list));
  66 static const char *build_message_string PVPROTO((const char *, ...));
  67 static const char *build_location_prefix PROTO((const char *, int, int));
  68 static void voutput_notice PROTO((struct output_buffer *, const char *,
  69                                   va_list));
  70 static void output_printf PVPROTO((struct output_buffer *, const char *, ...));
  71 static void line_wrapper_printf PVPROTO((FILE *, const char *, ...));
  72 static void vline_wrapper_message_with_location PROTO((const char *, int, int,
  73                                                        const char *, va_list));
  74 static void notice PVPROTO((const char *s, ...)) ATTRIBUTE_PRINTF_1;
  75 static void v_message_with_file_and_line PROTO((const char *, int, int,
  76                                                 const char *, va_list));
  77 static void v_message_with_decl PROTO((tree, int, const char *, va_list));
  78 static void file_and_line_for_asm PROTO((rtx, char **, int *));
  79 static void v_error_with_file_and_line PROTO((const char *, int,
  80                                               const char *, va_list));
  81 static void v_error_with_decl PROTO((tree, const char *, va_list));
  82 static void v_error_for_asm PROTO((rtx, const char *, va_list));
  83 static void verror PROTO((const char *, va_list));
  84 static void vfatal PROTO((const char *, va_list)) ATTRIBUTE_NORETURN;
  85 static void v_warning_with_file_and_line PROTO ((const char *, int,
  86                                                  const char *, va_list));
  87 static void v_warning_with_decl PROTO((tree, const char *, va_list));
  88 static void v_warning_for_asm PROTO((rtx, const char *, va_list));
  89 static void vwarning PROTO((const char *, va_list));
  90 static void vpedwarn PROTO((const char *, va_list));
  91 static void v_pedwarn_with_decl PROTO((tree, const char *, va_list));
  92 static void v_pedwarn_with_file_and_line PROTO((const char *, int,
  93                                                 const char *, va_list));
  94 static void vsorry PROTO((const char *, va_list));
  95 static void report_file_and_line PROTO ((const char *, int, int));
  96 static void vnotice PROTO ((FILE *, const char *, va_list));
  97
  98
  99 extern int rtl_dump_and_exit;
 100 extern int inhibit_warnings;
 101 extern int warnings_are_errors;
 102 extern int warningcount;
 103 extern int errorcount;
 104
 105 static int need_error_newline;
 106
 107 /* Function of last error message;
 108    more generally, function such that if next error message is in it
 109    then we don't have to mention the function name.  */
 110 static tree last_error_function = NULL;
 111
 112 /* Used to detect when input_file_stack has changed since last described.  */
 113 static int last_error_tick;
 114
 115 /* Called by report_error_function to print out function name.
 116  * Default may be overridden by language front-ends.  */
 117
 118 void (*print_error_function) PROTO((const char *)) =
 119   default_print_error_function;
 120
 121 /* Maximum characters per line in automatic line wrapping mode.
 122    Non Zero means don't wrap lines. */
 123
 124 static int output_maximum_width = 0;
 125 \f
 126 /* Predicate. Return 1 if we're in automatic line wrapping mode.  */
 127
 128 static int
 129 doing_line_wrapping ()
 130 {
 131   return output_maximum_width > 0;
 132 }
 133
 134 /* Set Maximum characters per line in automatic line wrapping mode.  */
 135
 136 void
 137 set_message_length (n)
 138      int n;
 139 {
 140     output_maximum_width = n;
 141 }
 142
 143 /* Construct an output BUFFER with PREFIX and of MAX_LENGTH characters
 144    per line.  */
 145
 146 static void
 147 init_output_buffer (buffer, prefix, max_length)
 148      struct output_buffer *buffer;
 149      const char *prefix;
 150      int max_length;
 151 {
 152   obstack_init (&buffer->obstack);
 153   buffer->prefix = prefix;
 154   buffer->line_length = 0;
 155   buffer->max_length = max_length;
 156 }
 157
 158 /* Return BUFFER's prefix.  */
 159
 160 static const char *
 161 get_output_prefix (buffer)
 162      const struct output_buffer *buffer;
 163 {
 164   return buffer->prefix;
 165 }
 166
 167 /* Return the amount of characters BUFFER can accept to
 168    make a full line.  */
 169
 170 static int
 171 output_space_left (buffer)
 172      const struct output_buffer *buffer;
 173 {
 174   return buffer->max_length - buffer->line_length;
 175 }
 176
 177 /* Dump BUFFER's prefix.  */
 178
 179 static void
 180 emit_output_prefix (buffer)
 181      struct output_buffer *buffer;
 182 {
 183   if (buffer->prefix)
 184     {
 185       buffer->line_length = strlen (buffer->prefix);
 186       obstack_grow (&buffer->obstack, buffer->prefix, buffer->line_length);
 187     }
 188 }
 189
 190 /* Have BUFFER start a new line.  */
 191
 192 static void
 193 output_newline (buffer)
 194      struct output_buffer *buffer;
 195 {
 196   obstack_1grow (&buffer->obstack, '\n');
 197   buffer->line_length = 0;
 198 }
 199
 200 /* Append a string deliminated by START and END to BUFFER.  No wrapping is
 201    done.  The caller must ensure that it is safe to do so.  */
 202
 203 static void
 204 output_append (buffer, start, end)
 205      struct output_buffer *buffer;
 206      const char *start;
 207      const char *end;
 208 {
 209   int n;
 210
 211   /* Emit prefix and skip whitespace if we're starting a new line.  */
 212   if (buffer->line_length == 0)
 213     {
 214       emit_output_prefix (buffer);
 215       while (start != end && *start == ' ')
 216         ++start;
 217     }
 218   n = end - start;
 219   obstack_grow (&buffer->obstack, start, n);
 220   buffer->line_length += n;
 221 }
 222
 223 /* Wrap a STRing into BUFFER.  */
 224
 225 static void
 226 output_puts (buffer, str)
 227      struct output_buffer *buffer;
 228      const char *str;
 229 {
 230   const char *p = str;
 231
 232   while (*str)
 233     {
 234       while (*p && *p != ' ' && *p != '\n')
 235         ++p;
 236
 237       if (p - str < output_space_left (buffer))
 238         output_append (buffer, str, p);
 239       else
 240         {
 241           output_newline (buffer);
 242           output_append (buffer, str, p);
 243         }
 244
 245       while (*p && *p == '\n')
 246         {
 247           output_newline (buffer);
 248           ++p;
 249         }
 250
 251       str = p++;
 252     }
 253 }
 254
 255 /* Dump the content of BUFFER into FILE.  */
 256
 257 static void
 258 dump_output (buffer, file)
 259      struct output_buffer *buffer;
 260      FILE *file;
 261 {
 262   const char *text;
 263
 264   obstack_1grow (&buffer->obstack, '\0');
 265   text = obstack_finish (&buffer->obstack);
 266   fputs (text, file);
 267   obstack_free (&buffer->obstack, (char *)text);
 268   buffer->line_length = 0;
 269 }
 270
 271 static const char *
 272 vbuild_message_string (msgid, ap)
 273      const char *msgid;
 274      va_list ap;
 275 {
 276   char *str;
 277
 278   vasprintf (&str, msgid, ap);
 279   return str;
 280 }
 281
 282 /*  Return a malloc'd string containing MSGID formatted a la
 283     printf.  The caller is reponsible for freeing the memory.  */
 284
 285 static const char *
 286 build_message_string VPROTO((const char *msgid, ...))
 287 {
 288 #ifndef ANSI_PROTOTYPES
 289   const char *msgid;
 290 #endif
 291   va_list ap;
 292   const char *str;
 293
 294   VA_START (ap, msgid);
 295
 296 #ifndef ANSI_PROTOTYPES
 297   msgid = va_arg (ap, const char *);
 298 #endif
 299
 300   str = vbuild_message_string (msgid, ap);
 301
 302   va_end (ap);
 303
 304   return str;
 305 }
 306
 307
 308 /* Return a malloc'd string describing a location.  The caller is
 309    responsible for freeing the memory.  */
 310
 311 static const char *
 312 build_location_prefix (file, line, warn)
 313      const char *file;
 314      int line;
 315      int warn;
 316 {
 317   const char *fmt = file
 318     ? (warn ? "%s:%d: warning: " : "%s:%d: ")
 319     : (warn ? "%s: warning: " : "%s: ");
 320
 321   return file
 322     ? build_message_string (fmt, file, line)
 323     : build_message_string (fmt, progname);
 324 }
 325
 326 /* Format a MESSAGE into BUFFER.  Automatically wrap lines.  */
 327
 328 static void
 329 voutput_notice (buffer, msgid, ap)
 330      struct output_buffer *buffer;
 331      const char *msgid;
 332      va_list ap;
 333 {
 334   const char *message = vbuild_message_string (msgid, ap);
 335
 336   output_puts (buffer, message);
 337   free ((char *)message);
 338 }
 339
 340
 341 /* Format a message into BUFFER a la printf.  */
 342
 343 static void
 344 output_printf VPROTO((struct output_buffer *buffer, const char *msgid, ...))
 345 {
 346 #ifndef ANSI_PROTOTYPES
 347   struct output_buffer *buffer;
 348   const char *msgid;
 349 #endif
 350   va_list ap;
 351
 352   VA_START (ap, msgid);
 353
 354 #ifndef ANSI_PROTOTYPES
 355   buffer = va_arg (ap, struct output_buffer *);
 356   msgid = va_arg (ap, const char *);
 357 #endif
 358
 359   voutput_notice (buffer, msgid, ap);
 360   va_end (ap);
 361 }
 362
 363
 364 /* Format a MESSAGE into FILE.  Do line wrapping, starting new lines
 365    with PREFIX.  */
 366
 367 static void
 368 line_wrapper_printf VPROTO((FILE *file, const char *msgid, ...))
 369 {
 370 #ifndef ANSI_PROTOTYPES
 371   FILE *file;
 372   const char *msgid;
 373 #endif
 374   struct output_buffer buffer;
 375   va_list ap;
 376
 377   VA_START (ap, msgid);
 378
 379 #ifndef ANSI_PROTOTYPES
 380   file = va_arg (ap, FILE *);
 381   msgid = va_arg (ap, const char *);
 382 #endif
 383
 384   init_output_buffer (&buffer, (const char *)NULL, output_maximum_width);
 385   voutput_notice (&buffer, msgid, ap);
 386   dump_output (&buffer, file);
 387
 388   va_end (ap);
 389 }
 390
 391
 392 static void
 393 vline_wrapper_message_with_location (file, line, warn, msgid, ap)
 394      const char *file;
 395      int line;
 396      int warn;
 397      const char *msgid;
 398      va_list ap;
 399 {
 400   struct output_buffer buffer;
 401
 402   init_output_buffer
 403     (&buffer, build_location_prefix (file, line, warn), output_maximum_width);
 404   voutput_notice (&buffer, msgid, ap);
 405   dump_output (&buffer, stderr);
 406   free ((char*)get_output_prefix (&buffer));
 407   fputc ('\n', stderr);
 408 }
 409
 410
 411 /* Print the message MSGID in FILE.  */
 412
 413 static void
 414 vnotice (file, msgid, ap)
 415      FILE *file;
 416      const char *msgid;
 417      va_list ap;
 418 {
 419   vfprintf (file, _(msgid), ap);
 420 }
 421
 422 /* Print MSGID on stderr.  */
 423
 424 static void
 425 notice VPROTO((const char *msgid, ...))
 426 {
 427 #ifndef ANSI_PROTOTYPES
 428   char *msgid;
 429 #endif
 430   va_list ap;
 431
 432   VA_START (ap, msgid);
 433
 434 #ifndef ANSI_PROTOTYPES
 435   msgid = va_arg (ap, char *);
 436 #endif
 437
 438   vnotice (stderr, msgid, ap);
 439   va_end (ap);
 440 }
 441
 442 /* Report FILE and LINE (or program name), and optionally just WARN.  */
 443
 444 static void
 445 report_file_and_line (file, line, warn)
 446      const char *file;
 447      int line;
 448      int warn;
 449 {
 450   if (file)
 451     fprintf (stderr, "%s:%d: ", file, line);
 452   else
 453     fprintf (stderr, "%s: ", progname);
 454
 455   if (warn)
 456     notice ("warning: ");
 457 }
 458
 459 /* Print a message relevant to line LINE of file FILE.  */
 460
 461 static void
 462 v_message_with_file_and_line (file, line, warn, msgid, ap)
 463      const char *file;
 464      int line;
 465      int warn;
 466      const char *msgid;
 467      va_list ap;
 468 {
 469   report_file_and_line (file, line, warn);
 470   vnotice (stderr, msgid, ap);
 471   fputc ('\n', stderr);
 472 }
 473
 474 /* Print a message relevant to the given DECL.  */
 475
 476 static void
 477 v_message_with_decl (decl, warn, msgid, ap)
 478      tree decl;
 479      int warn;
 480      const char *msgid;
 481      va_list ap;
 482 {
 483   const char *p;
 484   struct output_buffer buffer;
 485
 486   if (doing_line_wrapping ())
 487     init_output_buffer
 488       (&buffer,
 489        build_location_prefix (DECL_SOURCE_FILE (decl),
 490                               DECL_SOURCE_LINE (decl), warn),
 491        output_maximum_width);
 492   else
 493     report_file_and_line (DECL_SOURCE_FILE (decl),
 494                           DECL_SOURCE_LINE (decl), warn);
 495
 496   /* Do magic to get around lack of varargs support for insertion
 497      of arguments into existing list.  We know that the decl is first;
 498      we ass_u_me that it will be printed with "%s".  */
 499
 500   for (p = _(msgid); *p; ++p)
 501     {
 502       if (*p == '%')
 503         {
 504           if (*(p + 1) == '%')
 505             ++p;
 506           else if (*(p + 1) != 's')
 507             abort ();
 508           else
 509             break;
 510         }
 511     }
 512
 513   if (p > _(msgid))                     /* Print the left-hand substring.  */
 514     {
 515       if (doing_line_wrapping ())
 516         output_printf (&buffer, "%.*s", (int)(p - _(msgid)), _(msgid));
 517       else
 518         fprintf (stderr, "%.*s", (int)(p - _(msgid)), _(msgid));
 519     }
 520
 521   if (*p == '%')                /* Print the name.  */
 522     {
 523       const char *n = (DECL_NAME (decl)
 524                  ? (*decl_printable_name) (decl, 2)
 525                  : "((anonymous))");
 526       if (doing_line_wrapping ())
 527         output_puts (&buffer, n);
 528       else
 529         fputs (n, stderr);
 530       while (*p)
 531         {
 532           ++p;
 533           if (ISALPHA (*(p - 1) & 0xFF))
 534             break;
 535         }
 536     }
 537
 538   if (*p)                       /* Print the rest of the message.  */
 539     {
 540       if (doing_line_wrapping ())
 541         voutput_notice (&buffer, p, ap);
 542       else
 543         vfprintf (stderr, p, ap);
 544     }
 545
 546   if (doing_line_wrapping())
 547     {
 548       dump_output (&buffer, stderr);
 549       free ((char *)get_output_prefix (&buffer));
 550     }
 551
 552   fputc ('\n', stderr);
 553 }
 554
 555 /* Figure file and line of the given INSN.  */
 556
 557 static void
 558 file_and_line_for_asm (insn, pfile, pline)
 559      rtx insn;
 560      char **pfile;
 561      int *pline;
 562 {
 563   rtx body = PATTERN (insn);
 564   rtx asmop;
 565
 566   /* Find the (or one of the) ASM_OPERANDS in the insn.  */
 567   if (GET_CODE (body) == SET && GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
 568     asmop = SET_SRC (body);
 569   else if (GET_CODE (body) == ASM_OPERANDS)
 570     asmop = body;
 571   else if (GET_CODE (body) == PARALLEL
 572            && GET_CODE (XVECEXP (body, 0, 0)) == SET)
 573     asmop = SET_SRC (XVECEXP (body, 0, 0));
 574   else if (GET_CODE (body) == PARALLEL
 575            && GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
 576     asmop = XVECEXP (body, 0, 0);
 577   else
 578     asmop = NULL;
 579
 580   if (asmop)
 581     {
 582       *pfile = ASM_OPERANDS_SOURCE_FILE (asmop);
 583       *pline = ASM_OPERANDS_SOURCE_LINE (asmop);
 584     }
 585   else
 586     {
 587       *pfile = input_filename;
 588       *pline = lineno;
 589     }
 590 }
 591
 592 /* Report an error at line LINE of file FILE.  */
 593
 594 static void
 595 v_error_with_file_and_line (file, line, msgid, ap)
 596      const char *file;
 597      int line;
 598      const char *msgid;
 599      va_list ap;
 600 {
 601   count_error (0);
 602   report_error_function (file);
 603   if (doing_line_wrapping ())
 604     vline_wrapper_message_with_location (file, line, 0, msgid, ap);
 605   else
 606     v_message_with_file_and_line (file, line, 0, msgid, ap);
 607 }
 608
 609 /* Report an error at the declaration DECL.
 610    MSGID is a format string which uses %s to substitute the declaration
 611    name; subsequent substitutions are a la printf.  */
 612
 613 static void
 614 v_error_with_decl (decl, msgid, ap)
 615      tree decl;
 616      const char *msgid;
 617      va_list ap;
 618 {
 619   count_error (0);
 620   report_error_function (DECL_SOURCE_FILE (decl));
 621   v_message_with_decl (decl, 0, msgid, ap);
 622 }
 623
 624
 625 /* Report an error at the line number of the insn INSN.
 626    This is used only when INSN is an `asm' with operands,
 627    and each ASM_OPERANDS records its own source file and line.  */
 628
 629 static void
 630 v_error_for_asm (insn, msgid, ap)
 631      rtx insn;
 632      const char *msgid;
 633      va_list ap;
 634 {
 635   char *file;
 636   int line;
 637
 638   count_error (0);
 639   file_and_line_for_asm (insn, &file, &line);
 640   report_error_function (file);
 641   v_message_with_file_and_line (file, line, 0, msgid, ap);
 642 }
 643
 644
 645 /* Report an error at the current line number.  */
 646
 647 static void
 648 verror (msgid, ap)
 649      const char *msgid;
 650      va_list ap;
 651 {
 652   v_error_with_file_and_line (input_filename, lineno, msgid, ap);
 653 }
 654
 655
 656 /* Report a fatal error at the current line number.  Allow a front end to
 657    intercept the message.  */
 658
 659 static void (*fatal_function) PROTO ((const char *, va_list));
 660
 661 static void
 662 vfatal (msgid, ap)
 663      const char *msgid;
 664      va_list ap;
 665 {
 666    if (fatal_function != 0)
 667      (*fatal_function) (_(msgid), ap);
 668
 669   verror (msgid, ap);
 670   exit (FATAL_EXIT_CODE);
 671 }
 672
 673 /* Report a warning at line LINE of file FILE.  */
 674
 675 static void
 676 v_warning_with_file_and_line (file, line, msgid, ap)
 677      const char *file;
 678      int line;
 679      const char *msgid;
 680      va_list ap;
 681 {
 682   if (count_error (1))
 683     {
 684       report_error_function (file);
 685       if (doing_line_wrapping ())
 686         vline_wrapper_message_with_location (file, line, 1, msgid, ap);
 687       else
 688         v_message_with_file_and_line (file, line, 1, msgid, ap);
 689     }
 690 }
 691
 692
 693 /* Report a warning at the declaration DECL.
 694    MSGID is a format string which uses %s to substitute the declaration
 695    name; subsequent substitutions are a la printf.  */
 696
 697 static void
 698 v_warning_with_decl (decl, msgid, ap)
 699      tree decl;
 700      const char *msgid;
 701      va_list ap;
 702 {
 703   if (count_error (1))
 704     {
 705       report_error_function (DECL_SOURCE_FILE (decl));
 706       v_message_with_decl (decl, 1, msgid, ap);
 707     }
 708 }
 709
 710
 711 /* Report a warning at the line number of the insn INSN.
 712    This is used only when INSN is an `asm' with operands,
 713    and each ASM_OPERANDS records its own source file and line.  */
 714
 715 static void
 716 v_warning_for_asm (insn, msgid, ap)
 717      rtx insn;
 718      const char *msgid;
 719      va_list ap;
 720 {
 721   if (count_error (1))
 722     {
 723       char *file;
 724       int line;
 725
 726       file_and_line_for_asm (insn, &file, &line);
 727       report_error_function (file);
 728       v_message_with_file_and_line (file, line, 1, msgid, ap);
 729     }
 730 }
 731
 732
 733 /* Report a warning at the current line number.  */
 734
 735 static void
 736 vwarning (msgid, ap)
 737      const char *msgid;
 738      va_list ap;
 739 {
 740   v_warning_with_file_and_line (input_filename, lineno, msgid, ap);
 741 }
 742
 743 /* These functions issue either warnings or errors depending on
 744    -pedantic-errors.  */
 745
 746 static void
 747 vpedwarn (msgid, ap)
 748      const char *msgid;
 749      va_list ap;
 750 {
 751   if (flag_pedantic_errors)
 752     verror (msgid, ap);
 753   else
 754     vwarning (msgid, ap);
 755 }
 756
 757
 758 static void
 759 v_pedwarn_with_decl (decl, msgid, ap)
 760      tree decl;
 761      const char *msgid;
 762      va_list ap;
 763 {
 764   /* We don't want -pedantic-errors to cause the compilation to fail from
 765      "errors" in system header files.  Sometimes fixincludes can't fix what's
 766      broken (eg: unsigned char bitfields - fixing it may change the alignment
 767      which will cause programs to mysteriously fail because the C library
 768      or kernel uses the original layout).  There's no point in issuing a
 769      warning either, it's just unnecessary noise.  */
 770
 771   if (! DECL_IN_SYSTEM_HEADER (decl))
 772     {
 773       if (flag_pedantic_errors)
 774         v_error_with_decl (decl, msgid, ap);
 775       else
 776         v_warning_with_decl (decl, msgid, ap);
 777     }
 778 }
 779
 780
 781 static void
 782 v_pedwarn_with_file_and_line (file, line, msgid, ap)
 783      const char *file;
 784      int line;
 785      const char *msgid;
 786      va_list ap;
 787 {
 788   if (flag_pedantic_errors)
 789     v_error_with_file_and_line (file, line, msgid, ap);
 790   else
 791     v_warning_with_file_and_line (file, line, msgid, ap);
 792 }
 793
 794
 795 /* Apologize for not implementing some feature.  */
 796
 797 static void
 798 vsorry (msgid, ap)
 799      const char *msgid;
 800      va_list ap;
 801 {
 802   sorrycount++;
 803   if (input_filename)
 804     fprintf (stderr, "%s:%d: ", input_filename, lineno);
 805   else
 806     fprintf (stderr, "%s: ", progname);
 807   notice ("sorry, not implemented: ");
 808   vnotice (stderr, msgid, ap);
 809   fputc ('\n', stderr);
 810 }
 811
 812 \f
 813 /* Count an error or warning.  Return 1 if the message should be printed.  */
 814
 815 int
 816 count_error (warningp)
 817      int warningp;
 818 {
 819   if (warningp && inhibit_warnings)
 820     return 0;
 821
 822   if (warningp && !warnings_are_errors)
 823     warningcount++;
 824   else
 825     {
 826       static int warning_message = 0;
 827
 828       if (warningp && !warning_message)
 829         {
 830           notice ("%s: warnings being treated as errors\n", progname);
 831           warning_message = 1;
 832         }
 833       errorcount++;
 834     }
 835
 836   return 1;
 837 }
 838
 839 /* Print a diagnistic MSGID on FILE.  */
 840 void
 841 fnotice VPROTO((FILE *file, const char *msgid, ...))
 842 {
 843 #ifndef ANSI_PROTOTYPES
 844   FILE *file;
 845   const char *msgid;
 846 #endif
 847   va_list ap;
 848
 849   VA_START (ap, msgid);
 850
 851 #ifndef ANSI_PROTOTYPES
 852   file = va_arg (ap, FILE *);
 853   msgid = va_arg (ap, const char *);
 854 #endif
 855
 856   vnotice (file, msgid, ap);
 857   va_end (ap);
 858 }
 859
 860
 861 /* Print a fatal error message.  NAME is the text.
 862    Also include a system error message based on `errno'.  */
 863
 864 void
 865 pfatal_with_name (name)
 866   const char *name;
 867 {
 868   fprintf (stderr, "%s: ", progname);
 869   perror (name);
 870   exit (FATAL_EXIT_CODE);
 871 }
 872
 873 void
 874 fatal_io_error (name)
 875   const char *name;
 876 {
 877   notice ("%s: %s: I/O error\n", progname, name);
 878   exit (FATAL_EXIT_CODE);
 879 }
 880
 881 /* Issue a pedantic warning MSGID.  */
 882 void
 883 pedwarn VPROTO((const char *msgid, ...))
 884 {
 885 #ifndef ANSI_PROTOTYPES
 886   const char *msgid;
 887 #endif
 888   va_list ap;
 889
 890   VA_START (ap, msgid);
 891
 892 #ifndef ANSI_PROTOTYPES
 893   msgid = va_arg (ap, const char *);
 894 #endif
 895
 896   vpedwarn (msgid, ap);
 897   va_end (ap);
 898 }
 899
 900 /* Issue a pedantic waring about DECL.  */
 901 void
 902 pedwarn_with_decl VPROTO((tree decl, const char *msgid, ...))
 903 {
 904 #ifndef ANSI_PROTOTYPES
 905   tree decl;
 906   const char *msgid;
 907 #endif
 908   va_list ap;
 909
 910   VA_START (ap, msgid);
 911
 912 #ifndef ANSI_PROTOTYPES
 913   decl = va_arg (ap, tree);
 914   msgid = va_arg (ap, const char *);
 915 #endif
 916
 917   v_pedwarn_with_decl (decl, msgid, ap);
 918   va_end (ap);
 919 }
 920
 921 /* Same as above but within the context FILE and LINE. */
 922 void
 923 pedwarn_with_file_and_line VPROTO((const char *file, int line,
 924                                    const char *msgid, ...))
 925 {
 926 #ifndef ANSI_PROTOTYPES
 927   const char *file;
 928   int line;
 929   const char *msgid;
 930 #endif
 931   va_list ap;
 932
 933   VA_START (ap, msgid);
 934
 935 #ifndef ANSI_PROTOTYPES
 936   file = va_arg (ap, const char *);
 937   line = va_arg (ap, int);
 938   msgid = va_arg (ap, const char *);
 939 #endif
 940
 941   v_pedwarn_with_file_and_line (file, line, msgid, ap);
 942   va_end (ap);
 943 }
 944
 945 /* Just apologize with MSGID.  */
 946 void
 947 sorry VPROTO((const char *msgid, ...))
 948 {
 949 #ifndef ANSI_PROTOTYPES
 950   const char *msgid;
 951 #endif
 952   va_list ap;
 953
 954   VA_START (ap, msgid);
 955
 956 #ifndef ANSI_PROTOTYPES
 957   msgid = va_arg (ap, const char *);
 958 #endif
 959
 960   vsorry (msgid, ap);
 961   va_end (ap);
 962 }
 963
 964 /* Called when the start of a function definition is parsed,
 965    this function prints on stderr the name of the function.  */
 966
 967 void
 968 announce_function (decl)
 969      tree decl;
 970 {
 971   if (! quiet_flag)
 972     {
 973       if (rtl_dump_and_exit)
 974         fprintf (stderr, "%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));
 975       else
 976         {
 977           if (doing_line_wrapping ())
 978             line_wrapper_printf
 979               (stderr, " %s", (*decl_printable_name) (decl, 2));
 980           else
 981             fprintf (stderr, " %s", (*decl_printable_name) (decl, 2));
 982         }
 983       fflush (stderr);
 984       need_error_newline = 1;
 985       last_error_function = current_function_decl;
 986     }
 987 }
 988
 989 /* The default function to print out name of current function that caused
 990    an error.  */
 991
 992 void
 993 default_print_error_function (file)
 994   const char *file;
 995 {
 996   if (last_error_function != current_function_decl)
 997     {
 998       const char *prefix = NULL;
 999       struct output_buffer buffer;
1000
1001       if (file)
1002         prefix = build_message_string ("%s: ", file);
1003
1004       if (doing_line_wrapping ())
1005         init_output_buffer (&buffer, prefix, output_maximum_width);
1006       else
1007         {
1008           if (file)
1009             fprintf (stderr, "%s: ", file);
1010         }
1011
1012       if (current_function_decl == NULL)
1013         {
1014           if (doing_line_wrapping ())
1015             output_printf (&buffer, "At top level:\n");
1016           else
1017             notice ("At top level:\n");
1018         }
1019       else
1020         {
1021           if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
1022             {
1023               if (doing_line_wrapping ())
1024                 output_printf
1025                   (&buffer, "In method `%s':\n",
1026                    (*decl_printable_name) (current_function_decl, 2));
1027               else
1028                 notice ("In method `%s':\n",
1029                         (*decl_printable_name) (current_function_decl, 2));
1030             }
1031           else
1032             {
1033               if (doing_line_wrapping ())
1034                 output_printf
1035                   (&buffer, "In function `%s':\n",
1036                    (*decl_printable_name) (current_function_decl, 2));
1037               else
1038                 notice ("In function `%s':\n",
1039                         (*decl_printable_name) (current_function_decl, 2));
1040             }
1041         }
1042
1043       last_error_function = current_function_decl;
1044
1045       if (doing_line_wrapping ())
1046         dump_output (&buffer, stderr);
1047
1048       free ((char *)prefix);
1049     }
1050 }
1051
1052 /* Prints out, if necessary, the name of the current function
1053   that caused an error.  Called from all error and warning functions.
1054   We ignore the FILE parameter, as it cannot be relied upon.  */
1055
1056 void
1057 report_error_function (file)
1058   const char *file ATTRIBUTE_UNUSED;
1059 {
1060   struct file_stack *p;
1061
1062   if (need_error_newline)
1063     {
1064       fprintf (stderr, "\n");
1065       need_error_newline = 0;
1066     }
1067
1068   if (input_file_stack && input_file_stack->next != 0
1069       && input_file_stack_tick != last_error_tick)
1070     {
1071       for (p = input_file_stack->next; p; p = p->next)
1072         if (p == input_file_stack->next)
1073           notice ("In file included from %s:%d", p->name, p->line);
1074         else
1075           notice (",\n                 from %s:%d", p->name, p->line);
1076       fprintf (stderr, ":\n");
1077       last_error_tick = input_file_stack_tick;
1078     }
1079
1080   (*print_error_function) (input_filename);
1081 }
1082
1083 void
1084 error_with_file_and_line VPROTO((const char *file, int line,
1085                                  const char *msgid, ...))
1086 {
1087 #ifndef ANSI_PROTOTYPES
1088   const char *file;
1089   int line;
1090   const char *msgid;
1091 #endif
1092   va_list ap;
1093
1094   VA_START (ap, msgid);
1095
1096 #ifndef ANSI_PROTOTYPES
1097   file = va_arg (ap, const char *);
1098   line = va_arg (ap, int);
1099   msgid = va_arg (ap, const char *);
1100 #endif
1101
1102   v_error_with_file_and_line (file, line, msgid, ap);
1103   va_end (ap);
1104 }
1105
1106 void
1107 error_with_decl VPROTO((tree decl, const char *msgid, ...))
1108 {
1109 #ifndef ANSI_PROTOTYPES
1110   tree decl;
1111   const char *msgid;
1112 #endif
1113   va_list ap;
1114
1115   VA_START (ap, msgid);
1116
1117 #ifndef ANSI_PROTOTYPES
1118   decl = va_arg (ap, tree);
1119   msgid = va_arg (ap, const char *);
1120 #endif
1121
1122   v_error_with_decl (decl, msgid, ap);
1123   va_end (ap);
1124 }
1125
1126 void
1127 error_for_asm VPROTO((rtx insn, const char *msgid, ...))
1128 {
1129 #ifndef ANSI_PROTOTYPES
1130   rtx insn;
1131   const char *msgid;
1132 #endif
1133   va_list ap;
1134
1135   VA_START (ap, msgid);
1136
1137 #ifndef ANSI_PROTOTYPES
1138   insn = va_arg (ap, rtx);
1139   msgid = va_arg (ap, const char *);
1140 #endif
1141
1142   v_error_for_asm (insn, msgid, ap);
1143   va_end (ap);
1144 }
1145
1146 void
1147 error VPROTO((const char *msgid, ...))
1148 {
1149 #ifndef ANSI_PROTOTYPES
1150   const char *msgid;
1151 #endif
1152   va_list ap;
1153
1154   VA_START (ap, msgid);
1155
1156 #ifndef ANSI_PROTOTYPES
1157   msgid = va_arg (ap, const char *);
1158 #endif
1159
1160   verror (msgid, ap);
1161   va_end (ap);
1162 }
1163
1164 /* Set the function to call when a fatal error occurs.  */
1165
1166 void
1167 set_fatal_function (f)
1168      void (*f) PROTO ((const char *, va_list));
1169 {
1170   fatal_function = f;
1171 }
1172
1173 void
1174 fatal VPROTO((const char *msgid, ...))
1175 {
1176 #ifndef ANSI_PROTOTYPES
1177   const char *msgid;
1178 #endif
1179   va_list ap;
1180
1181   VA_START (ap, msgid);
1182
1183 #ifndef ANSI_PROTOTYPES
1184   msgid = va_arg (ap, const char *);
1185 #endif
1186
1187   vfatal (msgid, ap);
1188   va_end (ap);
1189 }
1190
1191 void
1192 _fatal_insn (msgid, insn, file, line, function)
1193      const char *msgid;
1194      rtx insn;
1195      const char *file;
1196      int line;
1197      const char *function;
1198 {
1199   error ("%s", msgid);
1200   debug_rtx (insn);
1201   fancy_abort (file, line, function);
1202 }
1203
1204 void
1205 _fatal_insn_not_found (insn, file, line, function)
1206      rtx insn;
1207      const char *file;
1208      int line;
1209      const char *function;
1210 {
1211   if (INSN_CODE (insn) < 0)
1212     _fatal_insn ("Unrecognizable insn:", insn, file, line, function);
1213   else
1214     _fatal_insn ("Insn does not satisfy its constraints:",
1215                 insn, file, line, function);
1216 }
1217
1218 void
1219 warning_with_file_and_line VPROTO((const char *file, int line,
1220                                    const char *msgid, ...))
1221 {
1222 #ifndef ANSI_PROTOTYPES
1223   const char *file;
1224   int line;
1225   const char *msgid;
1226 #endif
1227   va_list ap;
1228
1229   VA_START (ap, msgid);
1230
1231 #ifndef ANSI_PROTOTYPES
1232   file = va_arg (ap, const char *);
1233   line = va_arg (ap, int);
1234   msgid = va_arg (ap, const char *);
1235 #endif
1236
1237   v_warning_with_file_and_line (file, line, msgid, ap);
1238   va_end (ap);
1239 }
1240
1241 void
1242 warning_with_decl VPROTO((tree decl, const char *msgid, ...))
1243 {
1244 #ifndef ANSI_PROTOTYPES
1245   tree decl;
1246   const char *msgid;
1247 #endif
1248   va_list ap;
1249
1250   VA_START (ap, msgid);
1251
1252 #ifndef ANSI_PROTOTYPES
1253   decl = va_arg (ap, tree);
1254   msgid = va_arg (ap, const char *);
1255 #endif
1256
1257   v_warning_with_decl (decl, msgid, ap);
1258   va_end (ap);
1259 }
1260
1261 void
1262 warning_for_asm VPROTO((rtx insn, const char *msgid, ...))
1263 {
1264 #ifndef ANSI_PROTOTYPES
1265   rtx insn;
1266   const char *msgid;
1267 #endif
1268   va_list ap;
1269
1270   VA_START (ap, msgid);
1271
1272 #ifndef ANSI_PROTOTYPES
1273   insn = va_arg (ap, rtx);
1274   msgid = va_arg (ap, const char *);
1275 #endif
1276
1277   v_warning_for_asm (insn, msgid, ap);
1278   va_end (ap);
1279 }
1280
1281 void
1282 warning VPROTO((const char *msgid, ...))
1283 {
1284 #ifndef ANSI_PROTOTYPES
1285   const char *msgid;
1286 #endif
1287   va_list ap;
1288
1289   VA_START (ap, msgid);
1290
1291 #ifndef ANSI_PROTOTYPES
1292   msgid = va_arg (ap, const char *);
1293 #endif
1294
1295   vwarning (msgid, ap);
1296   va_end (ap);
1297 }
1298