gcc/diagnostic.c

   1 /* Language-independent diagnostic subroutines for the GNU C compiler
   2    Copyright (C) 1999, 2000 Free Software Foundation, Inc.
   3    Contributed by Gabriel Dos Reis <gdr@codesourcery.com>
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22
  23 /* This file implements the language independent aspect of diagnostic
  24    message module.  */
  25
  26 #include "config.h"
  27 #undef FLOAT /* This is for hpux. They should change hpux.  */
  28 #undef FFS  /* Some systems define this in param.h.  */
  29 #include "system.h"
  30
  31 #include "tree.h"
  32 #include "rtl.h"
  33 #include "tm_p.h"
  34 #include "flags.h"
  35 #include "input.h"
  36 #include "insn-attr.h"
  37 #include "insn-codes.h"
  38 #include "insn-config.h"
  39 #include "toplev.h"
  40 #include "intl.h"
  41 #include "diagnostic.h"
  42
  43 #define obstack_chunk_alloc xmalloc
  44 #define obstack_chunk_free  free
  45
  46 #define output_formatted_integer(BUFFER, FORMAT, INTEGER) \
  47   do {                                                    \
  48     sprintf (digit_buffer, FORMAT, INTEGER);              \
  49     output_add_string (BUFFER, digit_buffer);             \
  50   } while (0)
  51
  52 #define output_text_length(BUFFER) (BUFFER)->line_length
  53 #define is_starting_newline(BUFFER) (output_text_length (BUFFER) == 0)
  54 #define output_prefix(BUFFER) (BUFFER)->state.prefix
  55 #define line_wrap_cutoff(BUFFER) (BUFFER)->state.maximum_length
  56 #define ideal_line_wrap_cutoff(BUFFER) (BUFFER)->state.ideal_maximum_length
  57 #define prefix_was_emitted_for(BUFFER) (BUFFER)->state.emitted_prefix_p
  58 #define prefixing_policy(BUFFER) (BUFFER)->state.prefixing_rule
  59 #define output_buffer_ptr_to_format_args(BUFFER) (BUFFER)->state.format_args
  60
  61 #define diagnostic_args output_buffer_ptr_to_format_args (diagnostic_buffer)
  62 #define diagnostic_msg output_buffer_text_cursor (diagnostic_buffer)
  63
  64 /* Prototypes. */
  65 static void finish_diagnostic PARAMS ((void));
  66 static void output_do_verbatim PARAMS ((output_buffer *,
  67                                         const char *, va_list *));
  68 static void output_to_stream PARAMS ((output_buffer *, FILE *));
  69 static void output_format PARAMS ((output_buffer *));
  70 static void output_indent PARAMS ((output_buffer *));
  71
  72 static char *vbuild_message_string PARAMS ((const char *, va_list))
  73      ATTRIBUTE_PRINTF (1, 0);
  74 static char *build_message_string PARAMS ((const char *, ...))
  75      ATTRIBUTE_PRINTF_1;
  76 static void output_do_printf PARAMS ((output_buffer *, const char *))
  77      ATTRIBUTE_PRINTF (2, 0);
  78 static void format_with_decl PARAMS ((output_buffer *, tree));
  79 static void file_and_line_for_asm PARAMS ((rtx, const char **, int *));
  80 static void diagnostic_for_asm PARAMS ((rtx, const char *, va_list *, int));
  81 static void diagnostic_for_decl PARAMS ((tree, const char *, va_list *, int));
  82 static void vnotice PARAMS ((FILE *, const char *, va_list))
  83      ATTRIBUTE_PRINTF (2, 0);
  84 static void set_real_maximum_length PARAMS ((output_buffer *));
  85
  86 static void output_unsigned_decimal PARAMS ((output_buffer *, unsigned int));
  87 static void output_long_decimal PARAMS ((output_buffer *, long int));
  88 static void output_long_unsigned_decimal PARAMS ((output_buffer *,
  89                                                   long unsigned int));
  90 static void output_octal PARAMS ((output_buffer *, unsigned int));
  91 static void output_long_octal PARAMS ((output_buffer *, unsigned long int));
  92 static void output_hexadecimal PARAMS ((output_buffer *, unsigned int));
  93 static void output_long_hexadecimal PARAMS ((output_buffer *,
  94                                              unsigned long int));
  95 static void output_append_r PARAMS ((output_buffer *, const char *, int));
  96 static void wrap_text PARAMS ((output_buffer *, const char *, const char *));
  97 static void maybe_wrap_text PARAMS ((output_buffer *, const char *,
  98                                      const char *));
  99 static void clear_diagnostic_info PARAMS ((output_buffer *));
 100
 101 static void default_diagnostic_starter PARAMS ((output_buffer *,
 102                                                 diagnostic_context *));
 103 static void default_diagnostic_finalizer PARAMS ((output_buffer *,
 104                                                   diagnostic_context *));
 105
 106 static void error_recursion PARAMS ((void)) ATTRIBUTE_NORETURN;
 107 static const char *trim_filename PARAMS ((const char *));
 108
 109 extern int rtl_dump_and_exit;
 110 extern int inhibit_warnings;
 111 extern int warnings_are_errors;
 112 extern int warningcount;
 113 extern int errorcount;
 114
 115 /* Front-end specific tree formatter, if non-NULL.  */
 116 printer_fn lang_printer = NULL;
 117
 118 /* This must be large enough to hold any printed integer or
 119    floating-point value.  */
 120 static char digit_buffer[128];
 121
 122 /* An output_buffer surrogate for stderr.  */
 123 static output_buffer global_output_buffer;
 124 output_buffer *diagnostic_buffer = &global_output_buffer;
 125
 126 /* Function of last error message;
 127    more generally, function such that if next error message is in it
 128    then we don't have to mention the function name.  */
 129 static tree last_error_function = NULL;
 130
 131 /* Used to detect when input_file_stack has changed since last described.  */
 132 static int last_error_tick;
 133
 134 /* Called by report_error_function to print out function name.
 135    Default may be overridden by language front-ends.  */
 136
 137 void (*print_error_function) PARAMS ((const char *)) =
 138   default_print_error_function;
 139
 140 /* Hooks for language specific diagnostic messages pager and finalizer.  */
 141 diagnostic_starter_fn lang_diagnostic_starter;
 142 diagnostic_finalizer_fn lang_diagnostic_finalizer;
 143
 144 /* Maximum characters per line in automatic line wrapping mode.
 145    Zero means don't wrap lines. */
 146
 147 int diagnostic_message_length_per_line;
 148
 149 /* Used to control every diagnostic message formatting.  Front-ends should
 150    call set_message_prefixing_rule to set up their policies.  */
 151 static int current_prefixing_rule;
 152
 153 /* Prevent recursion into the error handler.  */
 154 static int diagnostic_lock;
 155
 156 \f
 157 /* Return truthvalue if current input file is different from the most recent
 158    file involved in a diagnostic message.  */
 159
 160 int
 161 error_module_changed ()
 162 {
 163   return last_error_tick != input_file_stack_tick;
 164 }
 165
 166 /* Remember current file as being the most recent file involved in a
 167    diagnostic message.  */
 168
 169 void
 170 record_last_error_module ()
 171 {
 172   last_error_tick = input_file_stack_tick;
 173 }
 174
 175 /* Same as error_module_changed, but for function.  */
 176
 177 int
 178 error_function_changed ()
 179 {
 180   return last_error_function != current_function_decl;
 181 }
 182
 183 /* Same as record_last_error_module, but for function.  */
 184
 185 void
 186 record_last_error_function ()
 187 {
 188   last_error_function = current_function_decl;
 189 }
 190
 191 /* Initialize the diagnostic message outputting machinery.  */
 192
 193 void
 194 initialize_diagnostics ()
 195 {
 196   /* By default, we don't line-wrap messages.  */
 197   diagnostic_message_length_per_line = 0;
 198   set_message_prefixing_rule (DIAGNOSTICS_SHOW_PREFIX_ONCE);
 199
 200   /* Proceed to actual initialization.  */
 201   default_initialize_buffer (diagnostic_buffer);
 202
 203   lang_diagnostic_starter = default_diagnostic_starter;
 204   lang_diagnostic_finalizer = default_diagnostic_finalizer;
 205 }
 206
 207 void
 208 set_message_prefixing_rule (rule)
 209      int rule;
 210 {
 211   current_prefixing_rule = rule;
 212 }
 213
 214 /* Returns true if BUFFER is in line-wrappind mode.  */
 215
 216 int
 217 output_is_line_wrapping (buffer)
 218      output_buffer *buffer;
 219 {
 220   return ideal_line_wrap_cutoff (buffer) > 0;
 221 }
 222
 223 /* Return BUFFER's prefix.  */
 224
 225 const char *
 226 output_get_prefix (buffer)
 227      const output_buffer *buffer;
 228 {
 229   return output_prefix (buffer);
 230 }
 231
 232 /* Subroutine of output_set_maximum_length.  Set up BUFFER's
 233    internal maximum characters per line.  */
 234
 235 static void
 236 set_real_maximum_length (buffer)
 237      output_buffer *buffer;
 238 {
 239   /* If we're told not to wrap lines then do the obvious thing.  In case
 240    we'll emit prefix only once per diagnostic message, it is appropriate
 241   not to increase unncessarily the line-length cut-off.  */
 242   if (! output_is_line_wrapping (buffer)
 243       || prefixing_policy (buffer) == DIAGNOSTICS_SHOW_PREFIX_ONCE
 244       || prefixing_policy (buffer) == DIAGNOSTICS_SHOW_PREFIX_NEVER)
 245     line_wrap_cutoff (buffer) = ideal_line_wrap_cutoff (buffer);
 246   else
 247     {
 248       int prefix_length =
 249         output_prefix (buffer) ? strlen (output_prefix (buffer)) : 0;
 250       /* If the prefix is ridiculously too long, output at least
 251          32 characters.  */
 252       if (ideal_line_wrap_cutoff (buffer) - prefix_length < 32)
 253         line_wrap_cutoff (buffer) = ideal_line_wrap_cutoff (buffer) + 32;
 254       else
 255         line_wrap_cutoff (buffer) = ideal_line_wrap_cutoff (buffer);
 256     }
 257 }
 258
 259 /* Sets the number of maximum characters per line BUFFER can output
 260    in line-wrapping mode.  A LENGTH value 0 suppresses line-wrapping.  */
 261
 262 void
 263 output_set_maximum_length (buffer, length)
 264      output_buffer *buffer;
 265      int length;
 266 {
 267  ideal_line_wrap_cutoff (buffer) = length;
 268   set_real_maximum_length (buffer);
 269 }
 270
 271 /* Sets BUFFER's PREFIX.  */
 272
 273 void
 274 output_set_prefix (buffer, prefix)
 275      output_buffer *buffer;
 276      const char *prefix;
 277 {
 278   output_prefix (buffer) = prefix;
 279   set_real_maximum_length (buffer);
 280   prefix_was_emitted_for (buffer) = 0;
 281   output_indentation (buffer) = 0;
 282 }
 283
 284 /*  Return a pointer to the last character emitted in the output
 285     BUFFER area.  A NULL pointer means no character available.  */
 286 const char *
 287 output_last_position (buffer)
 288      const output_buffer *buffer;
 289 {
 290   const char *p = NULL;
 291
 292   if (obstack_base (&buffer->obstack) != obstack_next_free (&buffer->obstack))
 293     p = ((const char *) obstack_next_free (&buffer->obstack)) - 1;
 294   return p;
 295 }
 296
 297 /* Free BUFFER's prefix, a previously malloc'd string.  */
 298
 299 void
 300 output_destroy_prefix (buffer)
 301      output_buffer *buffer;
 302 {
 303   if (output_prefix (buffer) != NULL)
 304     {
 305       free ((char *) output_prefix (buffer));
 306       output_prefix (buffer) = NULL;
 307     }
 308 }
 309
 310 /* Zero out any text output so far in BUFFER.  */
 311
 312 void
 313 output_clear_message_text (buffer)
 314      output_buffer *buffer;
 315 {
 316   obstack_free (&buffer->obstack, obstack_base (&buffer->obstack));
 317   output_text_length (buffer) = 0;
 318 }
 319
 320 /* Zero out any diagnostic data used so far by BUFFER.  */
 321
 322 static void
 323 clear_diagnostic_info (buffer)
 324      output_buffer *buffer;
 325 {
 326   output_buffer_text_cursor (buffer) = NULL;
 327   output_buffer_ptr_to_format_args (buffer) = NULL;
 328   prefix_was_emitted_for (buffer) = 0;
 329   output_indentation (buffer) = 0;
 330 }
 331
 332 /* Construct an output BUFFER with PREFIX and of MAXIMUM_LENGTH
 333    characters per line.  */
 334
 335 void
 336 init_output_buffer (buffer, prefix, maximum_length)
 337      output_buffer *buffer;
 338      const char *prefix;
 339      int maximum_length;
 340 {
 341   memset (buffer, 0, sizeof (output_buffer));
 342   obstack_init (&buffer->obstack);
 343   ideal_line_wrap_cutoff (buffer) = maximum_length;
 344   prefixing_policy (buffer) = current_prefixing_rule;
 345   output_set_prefix (buffer, prefix);
 346   output_text_length (buffer) = 0;
 347   clear_diagnostic_info (buffer);
 348 }
 349
 350 /* Initialize BUFFER with a NULL prefix and current diagnostic message
 351    length cutoff.  */
 352
 353 void
 354 default_initialize_buffer (buffer)
 355      output_buffer *buffer;
 356 {
 357   init_output_buffer (buffer, NULL, diagnostic_message_length_per_line);
 358 }
 359
 360 /* Recompute diagnostic_buffer's attributes to reflect any change
 361    in diagnostic formatting global options.  */
 362
 363 void
 364 reshape_diagnostic_buffer ()
 365 {
 366   ideal_line_wrap_cutoff (diagnostic_buffer) =
 367     diagnostic_message_length_per_line;
 368   prefixing_policy (diagnostic_buffer) = current_prefixing_rule;
 369   set_real_maximum_length (diagnostic_buffer);
 370 }
 371
 372 /* Reinitialize BUFFER.  */
 373
 374 void
 375 output_clear (buffer)
 376      output_buffer *buffer;
 377 {
 378   output_clear_message_text (buffer);
 379   clear_diagnostic_info (buffer);
 380 }
 381
 382 /* Finishes constructing a NULL-terminated character string representing
 383    the BUFFERed message.  */
 384
 385 const char *
 386 output_finalize_message (buffer)
 387      output_buffer *buffer;
 388 {
 389   obstack_1grow (&buffer->obstack, '\0');
 390   return output_message_text (buffer);
 391 }
 392
 393 void
 394 flush_diagnostic_buffer ()
 395 {
 396   output_to_stream (diagnostic_buffer, stderr);
 397   fflush (stderr);
 398 }
 399
 400 /* Return the amount of characters BUFFER can accept to
 401    make a full line.  */
 402
 403 int
 404 output_space_left (buffer)
 405      const output_buffer *buffer;
 406 {
 407   return line_wrap_cutoff (buffer) - output_text_length (buffer);
 408 }
 409
 410 /* Write out BUFFER's prefix.  */
 411
 412 void
 413 output_emit_prefix (buffer)
 414      output_buffer *buffer;
 415 {
 416   if (output_prefix (buffer) != NULL)
 417     {
 418       switch (prefixing_policy (buffer))
 419         {
 420         default:
 421         case DIAGNOSTICS_SHOW_PREFIX_NEVER:
 422           break;
 423
 424         case DIAGNOSTICS_SHOW_PREFIX_ONCE:
 425           if (prefix_was_emitted_for (buffer))
 426             {
 427               output_indent (buffer);
 428               break;
 429             }
 430           output_indentation (buffer) += 3;
 431           /* Fall through.  */
 432
 433         case DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE:
 434           {
 435             int prefix_length = strlen (output_prefix (buffer));
 436             output_append_r (buffer, output_prefix (buffer), prefix_length);
 437             prefix_was_emitted_for (buffer) = 1;
 438           }
 439           break;
 440         }
 441     }
 442 }
 443
 444 /* Have BUFFER start a new line.  */
 445
 446 void
 447 output_add_newline (buffer)
 448      output_buffer *buffer;
 449 {
 450   obstack_1grow (&buffer->obstack, '\n');
 451   output_text_length (buffer) = 0;
 452 }
 453
 454 /* Appends a character to BUFFER.  */
 455
 456 void
 457 output_add_character (buffer, c)
 458      output_buffer *buffer;
 459      int c;
 460 {
 461   if (output_is_line_wrapping (buffer) && output_space_left (buffer) <= 0)
 462     output_add_newline (buffer);
 463   obstack_1grow (&buffer->obstack, c);
 464   ++output_text_length (buffer);
 465 }
 466
 467 /* Adds a space to BUFFER.  */
 468
 469 void
 470 output_add_space (buffer)
 471      output_buffer *buffer;
 472 {
 473   if (output_is_line_wrapping (buffer) && output_space_left (buffer) <= 0)
 474     {
 475       output_add_newline (buffer);
 476       return;
 477     }
 478   obstack_1grow (&buffer->obstack, ' ');
 479   ++output_text_length (buffer);
 480 }
 481
 482 /* These functions format an INTEGER into BUFFER as suggested by their
 483    names.  */
 484
 485 void
 486 output_decimal (buffer, i)
 487      output_buffer *buffer;
 488      int i;
 489 {
 490   output_formatted_integer (buffer, "%d", i);
 491 }
 492
 493 static void
 494 output_long_decimal (buffer, i)
 495      output_buffer *buffer;
 496      long int i;
 497 {
 498   output_formatted_integer (buffer, "%ld", i);
 499 }
 500
 501 static void
 502 output_unsigned_decimal (buffer, i)
 503      output_buffer *buffer;
 504      unsigned int i;
 505 {
 506   output_formatted_integer (buffer, "%u", i);
 507 }
 508
 509 static void
 510 output_long_unsigned_decimal (buffer, i)
 511      output_buffer *buffer;
 512      long unsigned int i;
 513 {
 514   output_formatted_integer (buffer, "%lu", i);
 515 }
 516
 517 static void
 518 output_octal (buffer, i)
 519      output_buffer *buffer;
 520      unsigned int i;
 521 {
 522   output_formatted_integer (buffer, "%o", i);
 523 }
 524
 525 static void
 526 output_long_octal (buffer, i)
 527      output_buffer *buffer;
 528      unsigned long int i;
 529 {
 530   output_formatted_integer (buffer, "%lo", i);
 531 }
 532
 533 static void
 534 output_hexadecimal (buffer, i)
 535      output_buffer *buffer;
 536      unsigned int i;
 537 {
 538   output_formatted_integer (buffer, "%x", i);
 539 }
 540
 541 static void
 542 output_long_hexadecimal (buffer, i)
 543      output_buffer *buffer;
 544      unsigned long int i;
 545 {
 546   output_formatted_integer (buffer, "%lx", i);
 547 }
 548
 549 /* Append to BUFFER a string specified by its STARTING character
 550    and LENGTH.  */
 551
 552 static void
 553 output_append_r (buffer, start, length)
 554      output_buffer *buffer;
 555      const char *start;
 556      int length;
 557 {
 558   obstack_grow (&buffer->obstack, start, length);
 559   output_text_length (buffer) += length;
 560 }
 561
 562 /* Append a string deliminated by START and END to BUFFER.  No wrapping is
 563    done.  However, if beginning a new line then emit output_prefix (BUFFER)
 564    and skip any leading whitespace if appropriate.  The caller must ensure
 565    that it is safe to do so.  */
 566
 567 void
 568 output_append (buffer, start, end)
 569      output_buffer *buffer;
 570      const char *start;
 571      const char *end;
 572 {
 573   /* Emit prefix and skip whitespace if we're starting a new line.  */
 574   if (is_starting_newline (buffer))
 575     {
 576       output_emit_prefix (buffer);
 577       if (output_is_line_wrapping (buffer))
 578         while (start != end && *start == ' ')
 579           ++start;
 580     }
 581   output_append_r (buffer, start, end - start);
 582 }
 583
 584 static void
 585 output_indent (buffer)
 586      output_buffer *buffer;
 587 {
 588   int n = output_indentation (buffer);
 589   int i;
 590
 591   for (i = 0; i < n; ++i)
 592     output_add_character (buffer, ' ');
 593 }
 594
 595 /* Wrap a text delimited by START and END into BUFFER.  */
 596
 597 static void
 598 wrap_text (buffer, start, end)
 599      output_buffer *buffer;
 600      const char *start;
 601      const char *end;
 602 {
 603   int is_wrapping = output_is_line_wrapping (buffer);
 604
 605   while (start != end)
 606     {
 607       /* Dump anything bodered by whitespaces.  */
 608       {
 609         const char *p = start;
 610         while (p != end && *p != ' ' && *p != '\n')
 611           ++p;
 612         if (is_wrapping && p - start >= output_space_left (buffer))
 613           output_add_newline (buffer);
 614         output_append (buffer, start, p);
 615         start = p;
 616       }
 617
 618       if (start != end && *start == ' ')
 619         {
 620           output_add_space (buffer);
 621           ++start;
 622         }
 623       if (start != end && *start == '\n')
 624         {
 625           output_add_newline (buffer);
 626           ++start;
 627         }
 628     }
 629 }
 630
 631 /* Same as wrap_text but wrap text only when in line-wrapping mode.  */
 632
 633 static void
 634 maybe_wrap_text (buffer, start, end)
 635      output_buffer *buffer;
 636      const char *start;
 637      const char *end;
 638 {
 639   if (output_is_line_wrapping (buffer))
 640     wrap_text (buffer, start, end);
 641   else
 642     output_append (buffer, start, end);
 643 }
 644
 645
 646 /* Append a STRING to BUFFER; the STRING might be line-wrapped if in
 647    appropriate mode.  */
 648
 649 void
 650 output_add_string (buffer, str)
 651      output_buffer *buffer;
 652      const char *str;
 653 {
 654   maybe_wrap_text (buffer, str, str + (str ? strlen (str) : 0));
 655 }
 656
 657 /* Flush the content of BUFFER onto FILE and reinitialize BUFFER.  */
 658
 659 static void
 660 output_to_stream (buffer, file)
 661      output_buffer *buffer;
 662      FILE *file;
 663 {
 664   const char *text = output_finalize_message (buffer);
 665   fputs (text, file);
 666   output_clear_message_text (buffer);
 667 }
 668
 669 /* Format a message pointed to by output_buffer_text_cursor (BUFFER) using
 670    output_buffer_format_args (BUFFER) as appropriate.  The following format
 671    specifiers are recognized as being language independent:
 672    %d, %i: (signed) integer in base ten.
 673    %u: unsigned integer in base ten.
 674    %o: unsigned integer in base eight.
 675    %x: unsigned integer in base sixteen.
 676    %ld, %li, %lo, %lu, %lx: long versions of the above.
 677    %c: character.
 678    %s: string.
 679    %%: `%'.
 680    %*.s: a substring the length of which is specified by an integer.  */
 681
 682 static void
 683 output_format (buffer)
 684      output_buffer *buffer;
 685 {
 686   for (; *output_buffer_text_cursor (buffer);
 687        ++output_buffer_text_cursor (buffer))
 688     {
 689       int long_integer = 0;
 690
 691       /* Ignore text.  */
 692       {
 693         const char *p = output_buffer_text_cursor (buffer);
 694         while (*p && *p != '%')
 695           ++p;
 696         wrap_text (buffer, output_buffer_text_cursor (buffer), p);
 697         output_buffer_text_cursor (buffer) = p;
 698       }
 699
 700       if (!*output_buffer_text_cursor (buffer))
 701         break;
 702
 703       /* We got a '%'.  Let's see what happens. Record whether we're
 704          parsing a long integer format specifier.  */
 705       if (*++output_buffer_text_cursor (buffer) == 'l')
 706         {
 707           long_integer = 1;
 708           ++output_buffer_text_cursor (buffer);
 709         }
 710
 711       /* Handle %c, %d, %i, %ld, %li, %lo, %lu, %lx, %o, %s, %u,
 712          %x, %.*s; %%.  And nothing else.  Front-ends should install
 713          printers to grok language specific format specifiers.  */
 714       switch (*output_buffer_text_cursor (buffer))
 715         {
 716         case 'c':
 717           output_add_character
 718             (buffer, va_arg (output_buffer_format_args (buffer), int));
 719           break;
 720
 721         case 'd':
 722         case 'i':
 723           if (long_integer)
 724             output_long_decimal
 725               (buffer, va_arg (output_buffer_format_args (buffer), long int));
 726           else
 727             output_decimal
 728               (buffer, va_arg (output_buffer_format_args (buffer), int));
 729           break;
 730
 731         case 'o':
 732           if (long_integer)
 733             output_long_octal (buffer,
 734                                va_arg (output_buffer_format_args (buffer),
 735                                        unsigned long int));
 736           else
 737             output_octal (buffer,
 738                           va_arg (output_buffer_format_args (buffer),
 739                                   unsigned int));
 740           break;
 741
 742         case 's':
 743           output_add_string (buffer,
 744                              va_arg (output_buffer_format_args (buffer),
 745                                      const char *));
 746           break;
 747
 748         case 'u':
 749           if (long_integer)
 750             output_long_unsigned_decimal
 751               (buffer, va_arg (output_buffer_format_args (buffer),
 752                                long unsigned int));
 753           else
 754             output_unsigned_decimal
 755               (buffer, va_arg (output_buffer_format_args (buffer),
 756                                unsigned int));
 757           break;
 758
 759         case 'x':
 760           if (long_integer)
 761             output_long_hexadecimal
 762               (buffer, va_arg (output_buffer_format_args (buffer),
 763                                unsigned long int));
 764           else
 765             output_hexadecimal
 766               (buffer, va_arg (output_buffer_format_args (buffer),
 767                                unsigned int));
 768           break;
 769
 770         case '%':
 771           output_add_character (buffer, '%');
 772           break;
 773
 774         case '.':
 775           {
 776             int n;
 777             const char *s;
 778             /* We handle no precision specifier but `%.*s'.  */
 779             if (*++output_buffer_text_cursor (buffer) != '*')
 780               abort ();
 781             else if (*++output_buffer_text_cursor (buffer) != 's')
 782               abort();
 783             n = va_arg (output_buffer_format_args (buffer), int);
 784             s = va_arg (output_buffer_format_args (buffer), const char *);
 785             output_append (buffer, s, s + n);
 786           }
 787           break;
 788
 789         default:
 790           if (! lang_printer || !(*lang_printer) (buffer))
 791             {
 792               /* Hmmm.  The front-end failed to install a format translator
 793                  but called us with an unrecognized format.  Sorry.  */
 794               abort ();
 795             }
 796         }
 797     }
 798 }
 799
 800 static char *
 801 vbuild_message_string (msgid, ap)
 802      const char *msgid;
 803      va_list ap;
 804 {
 805   char *str;
 806
 807   vasprintf (&str, msgid, ap);
 808   return str;
 809 }
 810
 811 /*  Return a malloc'd string containing MSGID formatted a la
 812     printf.  The caller is reponsible for freeing the memory.  */
 813
 814 static char *
 815 build_message_string VPARAMS ((const char *msgid, ...))
 816 {
 817 #ifndef ANSI_PROTOTYPES
 818   const char *msgid;
 819 #endif
 820   va_list ap;
 821   char *str;
 822
 823   VA_START (ap, msgid);
 824
 825 #ifndef ANSI_PROTOTYPES
 826   msgid = va_arg (ap, const char *);
 827 #endif
 828
 829   str = vbuild_message_string (msgid, ap);
 830
 831   va_end (ap);
 832
 833   return str;
 834 }
 835
 836 /* Return a malloc'd string describing a location.  The caller is
 837    responsible for freeing the memory.  */
 838
 839 char *
 840 context_as_prefix (file, line, warn)
 841      const char *file;
 842      int line;
 843      int warn;
 844 {
 845   if (file)
 846     {
 847       if (warn)
 848         return build_message_string ("%s:%d: warning: ", file, line);
 849       else
 850         return build_message_string ("%s:%d: ", file, line);
 851     }
 852   else
 853     {
 854       if (warn)
 855         return build_message_string ("%s: warning: ", progname);
 856       else
 857         return build_message_string ("%s: ", progname);
 858     }
 859 }
 860
 861 /* Same as context_as_prefix, but only the source FILE is given.  */
 862
 863 char *
 864 file_name_as_prefix (f)
 865      const char *f;
 866 {
 867   return build_message_string ("%s: ", f);
 868 }
 869
 870 /* Format a MESSAGE into BUFFER.  Automatically wrap lines.  */
 871
 872 static void
 873 output_do_printf (buffer, msgid)
 874      output_buffer *buffer;
 875      const char *msgid;
 876 {
 877   char *message = vbuild_message_string (msgid,
 878                                          output_buffer_format_args (buffer));
 879
 880   wrap_text (buffer, message, message + strlen (message));
 881   free (message);
 882 }
 883
 884
 885 /* Format a message into BUFFER a la printf.  */
 886
 887 void
 888 output_printf VPARAMS ((struct output_buffer *buffer, const char *msgid, ...))
 889 {
 890 #ifndef ANSI_PROTOTYPES
 891   struct output_buffer *buffer;
 892   const char *msgid;
 893 #endif
 894   va_list ap;
 895   va_list *old_args;
 896
 897   VA_START (ap, msgid);
 898 #ifndef ANSI_PROTOTYPES
 899   buffer = va_arg (ap, output_buffer *);
 900   msgid = va_arg (ap, const char *);
 901 #endif
 902   old_args = output_buffer_ptr_to_format_args (buffer);
 903   output_buffer_ptr_to_format_args (buffer) = &ap;
 904   output_do_printf (buffer, msgid);
 905   output_buffer_ptr_to_format_args (buffer) = old_args;
 906   va_end (ap);
 907 }
 908
 909 /* Print the message MSGID in FILE.  */
 910
 911 static void
 912 vnotice (file, msgid, ap)
 913      FILE *file;
 914      const char *msgid;
 915      va_list ap;
 916 {
 917   vfprintf (file, _(msgid), ap);
 918 }
 919
 920 /* Print a message relevant to the given DECL.  */
 921
 922 static void
 923 format_with_decl (buffer, decl)
 924      output_buffer *buffer;
 925      tree decl;
 926 {
 927   const char *p;
 928
 929   /* Do magic to get around lack of varargs support for insertion
 930      of arguments into existing list.  We know that the decl is first;
 931      we ass_u_me that it will be printed with "%s".  */
 932   for (p = output_buffer_text_cursor (buffer); *p; ++p)
 933     {
 934       if (*p == '%')
 935         {
 936           if (*(p + 1) == '%')
 937             ++p;
 938           else if (*(p + 1) != 's')
 939             abort ();
 940           else
 941             break;
 942         }
 943     }
 944
 945   /* Print the left-hand substring.  */
 946   maybe_wrap_text (buffer, output_buffer_text_cursor (buffer), p);
 947
 948   if (*p == '%')                /* Print the name.  */
 949     {
 950       const char *n = (DECL_NAME (decl)
 951                  ? (*decl_printable_name) (decl, 2)
 952                  : _("((anonymous))"));
 953       output_add_string (buffer, n);
 954       while (*p)
 955         {
 956           ++p;
 957           if (ISALPHA (*(p - 1) & 0xFF))
 958             break;
 959         }
 960     }
 961
 962   if (*p)                       /* Print the rest of the message.  */
 963     {
 964       output_buffer_text_cursor (buffer) = p;
 965       output_format (buffer);
 966     }
 967 }
 968
 969 /* Figure file and line of the given INSN.  */
 970
 971 static void
 972 file_and_line_for_asm (insn, pfile, pline)
 973      rtx insn;
 974      const char **pfile;
 975      int *pline;
 976 {
 977   rtx body = PATTERN (insn);
 978   rtx asmop;
 979
 980   /* Find the (or one of the) ASM_OPERANDS in the insn.  */
 981   if (GET_CODE (body) == SET && GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
 982     asmop = SET_SRC (body);
 983   else if (GET_CODE (body) == ASM_OPERANDS)
 984     asmop = body;
 985   else if (GET_CODE (body) == PARALLEL
 986            && GET_CODE (XVECEXP (body, 0, 0)) == SET)
 987     asmop = SET_SRC (XVECEXP (body, 0, 0));
 988   else if (GET_CODE (body) == PARALLEL
 989            && GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
 990     asmop = XVECEXP (body, 0, 0);
 991   else
 992     asmop = NULL;
 993
 994   if (asmop)
 995     {
 996       *pfile = ASM_OPERANDS_SOURCE_FILE (asmop);
 997       *pline = ASM_OPERANDS_SOURCE_LINE (asmop);
 998     }
 999   else
1000     {
1001       *pfile = input_filename;
1002       *pline = lineno;
1003     }
1004 }
1005
1006 /* Report a diagnostic MESSAGE (an errror or a WARNING) at the line number
1007    of the insn INSN.  This is used only when INSN is an `asm' with operands,
1008    and each ASM_OPERANDS records its own source file and line.  */
1009
1010 static void
1011 diagnostic_for_asm (insn, msg, args_ptr, warn)
1012      rtx insn;
1013      const char *msg;
1014      va_list *args_ptr;
1015      int warn;
1016 {
1017   diagnostic_context dc;
1018
1019   set_diagnostic_context (&dc, msg, args_ptr, NULL, 0, warn);
1020   file_and_line_for_asm (insn, &diagnostic_file_location (&dc),
1021                          &diagnostic_line_location (&dc));
1022   report_diagnostic (&dc);
1023 }
1024
1025 /* Report a diagnostic MESSAGE at the declaration DECL.
1026    MSG is a format string which uses %s to substitute the declaration
1027    name; subsequent substitutions are a la output_format.  */
1028
1029 static void
1030 diagnostic_for_decl (decl, msg, args_ptr, warn)
1031      tree decl;
1032      const char *msg;
1033      va_list *args_ptr;
1034      int warn;
1035 {
1036   output_state os;
1037
1038   if (diagnostic_lock++)
1039     error_recursion ();
1040
1041   if (count_error (warn))
1042     {
1043       os = output_buffer_state (diagnostic_buffer);
1044       report_error_function (DECL_SOURCE_FILE (decl));
1045       output_set_prefix
1046         (diagnostic_buffer, context_as_prefix
1047          (DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl), warn));
1048       output_buffer_ptr_to_format_args (diagnostic_buffer) = args_ptr;
1049       output_buffer_text_cursor (diagnostic_buffer) = msg;
1050       format_with_decl (diagnostic_buffer, decl);
1051       finish_diagnostic ();
1052       output_destroy_prefix (diagnostic_buffer);
1053
1054       output_buffer_state (diagnostic_buffer) = os;
1055     }
1056   diagnostic_lock--;
1057 }
1058
1059 \f
1060 /* Count an error or warning.  Return 1 if the message should be printed.  */
1061
1062 int
1063 count_error (warningp)
1064      int warningp;
1065 {
1066   if (warningp
1067       && (inhibit_warnings
1068           || (in_system_header && !warn_system_headers)))
1069     return 0;
1070
1071   if (warningp && !warnings_are_errors)
1072     warningcount++;
1073   else
1074     {
1075       static int warning_message = 0;
1076
1077       if (warningp && !warning_message)
1078         {
1079           verbatim ("%s: warnings being treated as errors\n", progname);
1080           warning_message = 1;
1081         }
1082       errorcount++;
1083     }
1084
1085   return 1;
1086 }
1087
1088 /* Print a diagnistic MSGID on FILE.  */
1089
1090 void
1091 fnotice VPARAMS ((FILE *file, const char *msgid, ...))
1092 {
1093 #ifndef ANSI_PROTOTYPES
1094   FILE *file;
1095   const char *msgid;
1096 #endif
1097   va_list ap;
1098
1099   VA_START (ap, msgid);
1100
1101 #ifndef ANSI_PROTOTYPES
1102   file = va_arg (ap, FILE *);
1103   msgid = va_arg (ap, const char *);
1104 #endif
1105
1106   vnotice (file, msgid, ap);
1107   va_end (ap);
1108 }
1109
1110
1111 /* Print a fatal error message.  NAME is the text.
1112    Also include a system error message based on `errno'.  */
1113
1114 void
1115 pfatal_with_name (name)
1116   const char *name;
1117 {
1118   fprintf (stderr, "%s: ", progname);
1119   perror (name);
1120   exit (FATAL_EXIT_CODE);
1121 }
1122
1123 void
1124 fatal_io_error (name)
1125   const char *name;
1126 {
1127   verbatim ("%s: %s: I/O error\n", progname, name);
1128   exit (FATAL_EXIT_CODE);
1129 }
1130
1131 /* Issue a pedantic warning MSGID.  */
1132
1133 void
1134 pedwarn VPARAMS ((const char *msgid, ...))
1135 {
1136 #ifndef ANSI_PROTOTYPES
1137   const char *msgid;
1138 #endif
1139   va_list ap;
1140   diagnostic_context dc;
1141
1142   VA_START (ap, msgid);
1143
1144 #ifndef ANSI_PROTOTYPES
1145   msgid = va_arg (ap, const char *);
1146 #endif
1147
1148   set_diagnostic_context
1149     (&dc, msgid, &ap, input_filename, lineno, !flag_pedantic_errors);
1150   report_diagnostic (&dc);
1151   va_end (ap);
1152 }
1153
1154 /* Issue a pedantic waring about DECL.  */
1155
1156 void
1157 pedwarn_with_decl VPARAMS ((tree decl, const char *msgid, ...))
1158 {
1159 #ifndef ANSI_PROTOTYPES
1160   tree decl;
1161   const char *msgid;
1162 #endif
1163   va_list ap;
1164
1165   VA_START (ap, msgid);
1166
1167 #ifndef ANSI_PROTOTYPES
1168   decl = va_arg (ap, tree);
1169   msgid = va_arg (ap, const char *);
1170 #endif
1171   /* We don't want -pedantic-errors to cause the compilation to fail from
1172      "errors" in system header files.  Sometimes fixincludes can't fix what's
1173      broken (eg: unsigned char bitfields - fixing it may change the alignment
1174      which will cause programs to mysteriously fail because the C library
1175      or kernel uses the original layout).  There's no point in issuing a
1176      warning either, it's just unnecessary noise.  */
1177   if (!DECL_IN_SYSTEM_HEADER (decl))
1178     diagnostic_for_decl (decl, msgid, &ap, !flag_pedantic_errors);
1179   va_end (ap);
1180 }
1181
1182 /* Same as above but within the context FILE and LINE. */
1183
1184 void
1185 pedwarn_with_file_and_line VPARAMS ((const char *file, int line,
1186                                      const char *msgid, ...))
1187 {
1188 #ifndef ANSI_PROTOTYPES
1189   const char *file;
1190   int line;
1191   const char *msgid;
1192 #endif
1193   va_list ap;
1194   diagnostic_context dc;
1195
1196   VA_START (ap, msgid);
1197
1198 #ifndef ANSI_PROTOTYPES
1199   file = va_arg (ap, const char *);
1200   line = va_arg (ap, int);
1201   msgid = va_arg (ap, const char *);
1202 #endif
1203
1204   set_diagnostic_context (&dc, msgid, &ap, file, line, !flag_pedantic_errors);
1205   report_diagnostic (&dc);
1206   va_end (ap);
1207 }
1208
1209 /* Just apologize with MSGID.  */
1210
1211 void
1212 sorry VPARAMS ((const char *msgid, ...))
1213 {
1214 #ifndef ANSI_PROTOTYPES
1215   const char *msgid;
1216 #endif
1217   va_list ap;
1218   output_state os;
1219
1220   os = output_buffer_state (diagnostic_buffer);
1221   VA_START (ap, msgid);
1222
1223 #ifndef ANSI_PROTOTYPES
1224   msgid = va_arg (ap, const char *);
1225 #endif
1226   ++sorrycount;
1227   output_set_prefix
1228     (diagnostic_buffer, context_as_prefix (input_filename, lineno, 0));
1229   output_printf (diagnostic_buffer, "sorry, not implemented: ");
1230   output_buffer_ptr_to_format_args (diagnostic_buffer) = &ap;
1231   output_buffer_text_cursor (diagnostic_buffer) = msgid;
1232   output_format (diagnostic_buffer);
1233   finish_diagnostic ();
1234   output_buffer_state (diagnostic_buffer) = os;
1235   va_end (ap);
1236 }
1237
1238 /* Called when the start of a function definition is parsed,
1239    this function prints on stderr the name of the function.  */
1240
1241 void
1242 announce_function (decl)
1243      tree decl;
1244 {
1245   if (! quiet_flag)
1246     {
1247       if (rtl_dump_and_exit)
1248         verbatim ("%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));
1249       else
1250         verbatim (" %s", (*decl_printable_name) (decl, 2));
1251       fflush (stderr);
1252       output_needs_newline (diagnostic_buffer) = 1;
1253       record_last_error_function ();
1254     }
1255 }
1256
1257 /* The default function to print out name of current function that caused
1258    an error.  */
1259
1260 void
1261 default_print_error_function (file)
1262   const char *file;
1263 {
1264   if (error_function_changed ())
1265     {
1266       char *prefix = file ? build_message_string ("%s: ", file) : NULL;
1267       output_state os;
1268
1269       os = output_buffer_state (diagnostic_buffer);
1270       output_set_prefix (diagnostic_buffer, prefix);
1271
1272       if (current_function_decl == NULL)
1273           output_add_string (diagnostic_buffer, "At top level:");
1274       else
1275         {
1276           if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
1277             output_printf
1278               (diagnostic_buffer, "In method `%s':",
1279                (*decl_printable_name) (current_function_decl, 2));
1280           else
1281             output_printf
1282               (diagnostic_buffer, "In function `%s':",
1283                (*decl_printable_name) (current_function_decl, 2));
1284         }
1285       output_add_newline (diagnostic_buffer);
1286
1287       record_last_error_function ();
1288       output_to_stream (diagnostic_buffer, stderr);
1289       output_buffer_state (diagnostic_buffer) = os;
1290       free ((char*) prefix);
1291     }
1292 }
1293
1294 /* Prints out, if necessary, the name of the current function
1295   that caused an error.  Called from all error and warning functions.
1296   We ignore the FILE parameter, as it cannot be relied upon.  */
1297
1298 void
1299 report_error_function (file)
1300   const char *file ATTRIBUTE_UNUSED;
1301 {
1302   report_problematic_module (diagnostic_buffer);
1303   (*print_error_function) (input_filename);
1304 }
1305
1306 void
1307 error_with_file_and_line VPARAMS ((const char *file, int line,
1308                                    const char *msgid, ...))
1309 {
1310 #ifndef ANSI_PROTOTYPES
1311   const char *file;
1312   int line;
1313   const char *msgid;
1314 #endif
1315   va_list ap;
1316   diagnostic_context dc;
1317
1318   VA_START (ap, msgid);
1319
1320 #ifndef ANSI_PROTOTYPES
1321   file = va_arg (ap, const char *);
1322   line = va_arg (ap, int);
1323   msgid = va_arg (ap, const char *);
1324 #endif
1325
1326   set_diagnostic_context (&dc, msgid, &ap, file, line, /* warn = */ 0);
1327   report_diagnostic (&dc);
1328   va_end (ap);
1329 }
1330
1331 void
1332 error_with_decl VPARAMS ((tree decl, const char *msgid, ...))
1333 {
1334 #ifndef ANSI_PROTOTYPES
1335   tree decl;
1336   const char *msgid;
1337 #endif
1338   va_list ap;
1339
1340   VA_START (ap, msgid);
1341
1342 #ifndef ANSI_PROTOTYPES
1343   decl = va_arg (ap, tree);
1344   msgid = va_arg (ap, const char *);
1345 #endif
1346
1347   diagnostic_for_decl (decl, msgid, &ap, /* warn = */ 0);
1348   va_end (ap);
1349 }
1350
1351 void
1352 error_for_asm VPARAMS ((rtx insn, const char *msgid, ...))
1353 {
1354 #ifndef ANSI_PROTOTYPES
1355   rtx insn;
1356   const char *msgid;
1357 #endif
1358   va_list ap;
1359
1360   VA_START (ap, msgid);
1361
1362 #ifndef ANSI_PROTOTYPES
1363   insn = va_arg (ap, rtx);
1364   msgid = va_arg (ap, const char *);
1365 #endif
1366
1367   diagnostic_for_asm (insn, msgid, &ap, /* warn = */ 0);
1368   va_end (ap);
1369 }
1370
1371 void
1372 error VPARAMS ((const char *msgid, ...))
1373 {
1374 #ifndef ANSI_PROTOTYPES
1375   const char *msgid;
1376 #endif
1377   va_list ap;
1378   diagnostic_context dc;
1379
1380   VA_START (ap, msgid);
1381
1382 #ifndef ANSI_PROTOTYPES
1383   msgid = va_arg (ap, const char *);
1384 #endif
1385
1386   set_diagnostic_context
1387     (&dc, msgid, &ap, input_filename, lineno, /* warn = */ 0);
1388   report_diagnostic (&dc);
1389   va_end (ap);
1390 }
1391
1392 /* Report a fatal error at the current line number.  Allow a front end to
1393    intercept the message.  */
1394
1395 static void (*fatal_function) PARAMS((const char *, va_list *));
1396
1397 /* Set the function to call when a fatal error occurs.  */
1398
1399 void
1400 set_fatal_function (f)
1401      void (*f) PARAMS ((const char *, va_list *));
1402 {
1403   fatal_function = f;
1404 }
1405
1406 void
1407 fatal VPARAMS ((const char *msgid, ...))
1408 {
1409 #ifndef ANSI_PROTOTYPES
1410   const char *msgid;
1411 #endif
1412   va_list ap;
1413   diagnostic_context dc;
1414
1415   VA_START (ap, msgid);
1416
1417 #ifndef ANSI_PROTOTYPES
1418   msgid = va_arg (ap, const char *);
1419 #endif
1420
1421   if (errorcount > 1 || sorrycount > 0)
1422     {
1423       fprintf (stderr, "confused by earlier errors, bailing out\n");
1424       exit (FATAL_EXIT_CODE);
1425     }
1426
1427   if (fatal_function != 0)
1428     (*fatal_function) (_(msgid), &ap);
1429
1430   set_diagnostic_context
1431     (&dc, msgid, &ap, input_filename, lineno, /* warn = */0);
1432   report_diagnostic (&dc);
1433   va_end (ap);
1434
1435   fprintf (stderr, "Please submit a full bug report, with preprocessed source if appropriate.\n");
1436   fprintf (stderr, "See %s for instructions.\n", GCCBUGURL);
1437   exit (FATAL_EXIT_CODE);
1438 }
1439
1440 void
1441 _fatal_insn (msgid, insn, file, line, function)
1442      const char *msgid;
1443      rtx insn;
1444      const char *file;
1445      int line;
1446      const char *function;
1447 {
1448   error ("%s", msgid);
1449   debug_rtx (insn);
1450   fancy_abort (file, line, function);
1451 }
1452
1453 void
1454 _fatal_insn_not_found (insn, file, line, function)
1455      rtx insn;
1456      const char *file;
1457      int line;
1458      const char *function;
1459 {
1460   if (INSN_CODE (insn) < 0)
1461     _fatal_insn ("Unrecognizable insn:", insn, file, line, function);
1462   else
1463     _fatal_insn ("Insn does not satisfy its constraints:",
1464                 insn, file, line, function);
1465 }
1466
1467 void
1468 warning_with_file_and_line VPARAMS ((const char *file, int line,
1469                                      const char *msgid, ...))
1470 {
1471 #ifndef ANSI_PROTOTYPES
1472   const char *file;
1473   int line;
1474   const char *msgid;
1475 #endif
1476   va_list ap;
1477   diagnostic_context dc;
1478
1479   VA_START (ap, msgid);
1480
1481 #ifndef ANSI_PROTOTYPES
1482   file = va_arg (ap, const char *);
1483   line = va_arg (ap, int);
1484   msgid = va_arg (ap, const char *);
1485 #endif
1486
1487   set_diagnostic_context (&dc, msgid, &ap, file, line, /* warn = */ 1);
1488   report_diagnostic (&dc);
1489   va_end (ap);
1490 }
1491
1492 void
1493 warning_with_decl VPARAMS ((tree decl, const char *msgid, ...))
1494 {
1495 #ifndef ANSI_PROTOTYPES
1496   tree decl;
1497   const char *msgid;
1498 #endif
1499   va_list ap;
1500
1501   VA_START (ap, msgid);
1502
1503 #ifndef ANSI_PROTOTYPES
1504   decl = va_arg (ap, tree);
1505   msgid = va_arg (ap, const char *);
1506 #endif
1507
1508   diagnostic_for_decl (decl, msgid, &ap, /* warn = */ 1);
1509   va_end (ap);
1510 }
1511
1512 void
1513 warning_for_asm VPARAMS ((rtx insn, const char *msgid, ...))
1514 {
1515 #ifndef ANSI_PROTOTYPES
1516   rtx insn;
1517   const char *msgid;
1518 #endif
1519   va_list ap;
1520
1521   VA_START (ap, msgid);
1522
1523 #ifndef ANSI_PROTOTYPES
1524   insn = va_arg (ap, rtx);
1525   msgid = va_arg (ap, const char *);
1526 #endif
1527
1528   diagnostic_for_asm (insn, msgid, &ap, /* warn = */ 1);
1529   va_end (ap);
1530 }
1531
1532 void
1533 warning VPARAMS ((const char *msgid, ...))
1534 {
1535 #ifndef ANSI_PROTOTYPES
1536   const char *msgid;
1537 #endif
1538   va_list ap;
1539   diagnostic_context dc;
1540
1541   VA_START (ap, msgid);
1542
1543 #ifndef ANSI_PROTOTYPES
1544   msgid = va_arg (ap, const char *);
1545 #endif
1546
1547   set_diagnostic_context
1548     (&dc, msgid, &ap, input_filename, lineno, /* warn = */ 1);
1549   report_diagnostic (&dc);
1550   va_end (ap);
1551 }
1552
1553 /* Flush diagnostic_buffer content on stderr.  */
1554
1555 static void
1556 finish_diagnostic ()
1557 {
1558   output_to_stream (diagnostic_buffer, stderr);
1559   clear_diagnostic_info (diagnostic_buffer);
1560   fputc ('\n', stderr);
1561   fflush (stderr);
1562 }
1563
1564 /* Helper subroutine of output_verbatim and verbatim. Do the approriate
1565    settings needed by BUFFER for a verbatim formatting.  */
1566
1567 static void
1568 output_do_verbatim (buffer, msg, args_ptr)
1569      output_buffer *buffer;
1570      const char *msg;
1571      va_list *args_ptr;
1572 {
1573   output_state os;
1574
1575   os = output_buffer_state (buffer);
1576   output_prefix (buffer) = NULL;
1577   prefixing_policy (buffer) = DIAGNOSTICS_SHOW_PREFIX_NEVER;
1578   output_buffer_text_cursor (buffer) = msg;
1579   output_buffer_ptr_to_format_args (buffer) = args_ptr;
1580   output_set_maximum_length (buffer, 0);
1581   output_format (buffer);
1582   output_buffer_state (buffer) = os;
1583 }
1584
1585 /* Output MESSAGE verbatim into BUFFER.  */
1586
1587 void
1588 output_verbatim VPARAMS ((output_buffer *buffer, const char *msg, ...))
1589 {
1590 #ifndef ANSI_PROTOTYPES
1591   output_buffer *buffer;
1592   const char *msg;
1593 #endif
1594   va_list ap;
1595
1596   VA_START (ap, msg);
1597 #ifndef ANSI_PROTOTYPES
1598   buffer = va_arg (ap, output_buffer *);
1599   msg = va_arg (ap, const char *);
1600 #endif
1601   output_do_verbatim (buffer, msg, &ap);
1602   va_end (ap);
1603 }
1604
1605 /* Same as above but use diagnostic_buffer.  */
1606
1607 void
1608 verbatim VPARAMS ((const char *msg, ...))
1609 {
1610 #ifndef ANSI_PROTOTYPES
1611   const char *msg;
1612 #endif
1613   va_list ap;
1614
1615   VA_START (ap, msg);
1616 #ifndef ANSI_PROTOTYPES
1617   msg = va_arg (ap, const char *);
1618 #endif
1619   output_do_verbatim (diagnostic_buffer, msg, &ap);
1620   output_to_stream (diagnostic_buffer, stderr);
1621   va_end (ap);
1622 }
1623
1624 /* Report a diagnostic message (an error or a warning) as specified by
1625    DC.  This function is *the* subroutine in terms of which front-ends
1626    should implement their specific diagnostic handling modules.  The
1627    front-end independent format specifiers are exactly those described
1628    in the documentation of output_format.  */
1629
1630 void
1631 report_diagnostic (dc)
1632      diagnostic_context *dc;
1633 {
1634   output_state os;
1635
1636   if (diagnostic_lock++)
1637     error_recursion ();
1638
1639   if (count_error (diagnostic_is_warning (dc)))
1640     {
1641       os = output_buffer_state (diagnostic_buffer);
1642       diagnostic_msg = diagnostic_message (dc);
1643       diagnostic_args = diagnostic_argument_list (dc);
1644       (*diagnostic_starter (dc)) (diagnostic_buffer, dc);
1645       output_format (diagnostic_buffer);
1646       (*diagnostic_finalizer (dc)) (diagnostic_buffer, dc);
1647       finish_diagnostic ();
1648       output_buffer_state (diagnostic_buffer) = os;
1649     }
1650
1651   diagnostic_lock--;
1652 }
1653
1654 /* Inform the user that an error occurred while trying to report some
1655    other error.  This indicates catastrophic internal inconsistencies,
1656    so give up now.  But do try to flush out the previous error.  */
1657
1658 static void
1659 error_recursion ()
1660 {
1661   if (diagnostic_lock < 3)
1662     finish_diagnostic ();
1663
1664   fatal ("Internal compiler error: Error reporting routines re-entered.");
1665 }
1666
1667 /* Given a partial pathname as input, return another pathname that
1668    shares no directory elements with the pathname of __FILE__.  This
1669    is used by fancy_abort() to print `Internal compiler error in expr.c'
1670    instead of `Internal compiler error in ../../GCC/gcc/expr.c'.  */
1671
1672 static const char *
1673 trim_filename (name)
1674      const char *name;
1675 {
1676   static const char this_file[] = __FILE__;
1677   const char *p = name, *q = this_file;
1678
1679   /* First skip any "../" in each filename.  This allows us to give a proper
1680      reference to a file in a subdirectory.  */
1681   while (p[0] == '.' && p[1] == '.'
1682          && (p[2] == DIR_SEPARATOR
1683 #ifdef DIR_SEPARATOR_2
1684              || p[2] == DIR_SEPARATOR_2
1685 #endif
1686              ))
1687     p += 3;
1688
1689   while (q[0] == '.' && q[1] == '.'
1690          && (q[2] == DIR_SEPARATOR
1691 #ifdef DIR_SEPARATOR_2
1692              || p[2] == DIR_SEPARATOR_2
1693 #endif
1694              ))
1695     q += 3;
1696
1697   /* Now skip any parts the two filenames have in common.  */
1698   while (*p == *q && *p != 0 && *q != 0)
1699     p++, q++;
1700
1701   /* Now go backwards until the previous directory separator.  */
1702   while (p > name && p[-1] != DIR_SEPARATOR
1703 #ifdef DIR_SEPARATOR_2
1704          && p[-1] != DIR_SEPARATOR_2
1705 #endif
1706          )
1707     p--;
1708
1709   return p;
1710 }
1711
1712 /* Report an internal compiler error in a friendly manner and without
1713    dumping core.  */
1714
1715 void
1716 fancy_abort (file, line, function)
1717      const char *file;
1718      int line;
1719      const char *function;
1720 {
1721   fatal ("Internal compiler error in %s, at %s:%d",
1722          function, trim_filename (file), line);
1723 }
1724
1725 /* Setup DC for reporting a diagnostic MESSAGE (an error or a WARNING),
1726    using arguments pointed to by ARGS_PTR, issued at a location specified
1727    by FILE and LINE.  */
1728
1729 void
1730 set_diagnostic_context (dc, message, args_ptr, file, line, warn)
1731      diagnostic_context *dc;
1732      const char *message;
1733      va_list *args_ptr;
1734      const char *file;
1735      int line;
1736      int warn;
1737 {
1738   memset (dc, 0, sizeof (diagnostic_context));
1739   diagnostic_message (dc) = message;
1740   diagnostic_argument_list (dc) = args_ptr;
1741   diagnostic_file_location (dc) = file;
1742   diagnostic_line_location (dc) = line;
1743   diagnostic_is_warning (dc) = warn;
1744   diagnostic_starter (dc) = lang_diagnostic_starter;
1745   diagnostic_finalizer (dc) = lang_diagnostic_finalizer;
1746 }
1747
1748 void
1749 report_problematic_module (buffer)
1750      output_buffer *buffer;
1751 {
1752   struct file_stack *p;
1753
1754   if (output_needs_newline (buffer))
1755     {
1756       output_add_newline (buffer);
1757       output_needs_newline (buffer) = 0;
1758     }
1759
1760   if (input_file_stack && input_file_stack->next != 0
1761       && error_module_changed ())
1762     {
1763       for (p = input_file_stack->next; p; p = p->next)
1764         if (p == input_file_stack->next)
1765           output_verbatim
1766             (buffer, "In file included from %s:%d", p->name, p->line);
1767         else
1768           output_verbatim
1769             (buffer, ",\n                 from %s:%d", p->name, p->line);
1770       output_verbatim (buffer, ":\n");
1771       record_last_error_module ();
1772     }
1773 }
1774
1775 static void
1776 default_diagnostic_starter (buffer, dc)
1777      output_buffer *buffer;
1778      diagnostic_context *dc;
1779 {
1780   report_error_function (diagnostic_file_location (dc));
1781   output_set_prefix (buffer,
1782                      context_as_prefix (diagnostic_file_location (dc),
1783                                         diagnostic_line_location (dc),
1784                                         diagnostic_is_warning (dc)));
1785 }
1786
1787 static void
1788 default_diagnostic_finalizer (buffer, dc)
1789      output_buffer *buffer;
1790      diagnostic_context *dc __attribute__((__unused__));
1791 {
1792   output_destroy_prefix (buffer);
1793 }