OSDN Git Service

53399fcf4a8db67eb48ccb6d836d5a0bdfcc75a7
[pf3gnuchains/gcc-fork.git] / gcc / diagnostic.c
1 /* Language-independent diagnostic subroutines for the GNU Compiler Collection
2    Copyright (C) 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
3    Contributed by Gabriel Dos Reis <gdr@codesourcery.com>
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 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 #include "coretypes.h"
31 #include "tm.h"
32 #include "tree.h"
33 #include "tm_p.h"
34 #include "flags.h"
35 #include "input.h"
36 #include "toplev.h"
37 #include "intl.h"
38 #include "diagnostic.h"
39 #include "langhooks.h"
40 #include "langhooks-def.h"
41
42 #define output_text_length(BUFFER) (BUFFER)->line_length
43 #define is_starting_newline(BUFFER) (output_text_length (BUFFER) == 0)
44 #define line_wrap_cutoff(BUFFER) (BUFFER)->state.maximum_length
45 #define prefix_was_emitted_for(BUFFER) (BUFFER)->state.emitted_prefix_p
46
47 /* Prototypes.  */
48 static void output_flush PARAMS ((output_buffer *));
49 static void output_do_verbatim PARAMS ((output_buffer *, text_info *));
50 static void output_buffer_to_stream PARAMS ((output_buffer *));
51 static void output_format PARAMS ((output_buffer *, text_info *));
52 static void output_indent PARAMS ((output_buffer *));
53
54 static char *build_message_string PARAMS ((const char *, ...))
55      ATTRIBUTE_PRINTF_1;
56 static void format_with_decl PARAMS ((output_buffer *, text_info *, tree));
57 static void diagnostic_for_decl PARAMS ((diagnostic_context *,
58                                          diagnostic_info *, tree));
59 static void set_real_maximum_length PARAMS ((output_buffer *));
60
61 static void output_unsigned_decimal PARAMS ((output_buffer *, unsigned int));
62 static void output_long_decimal PARAMS ((output_buffer *, long int));
63 static void output_long_unsigned_decimal PARAMS ((output_buffer *,
64                                                   long unsigned int));
65 static void output_octal PARAMS ((output_buffer *, unsigned int));
66 static void output_long_octal PARAMS ((output_buffer *, unsigned long int));
67 static void output_hexadecimal PARAMS ((output_buffer *, unsigned int));
68 static void output_long_hexadecimal PARAMS ((output_buffer *,
69                                              unsigned long int));
70 static void output_append_r PARAMS ((output_buffer *, const char *, int));
71 static void wrap_text PARAMS ((output_buffer *, const char *, const char *));
72 static void maybe_wrap_text PARAMS ((output_buffer *, const char *,
73                                      const char *));
74 static void output_clear_data PARAMS ((output_buffer *));
75
76 static void default_diagnostic_starter PARAMS ((diagnostic_context *,
77                                                 diagnostic_info *));
78 static void default_diagnostic_finalizer PARAMS ((diagnostic_context *,
79                                                   diagnostic_info *));
80
81 static void error_recursion PARAMS ((diagnostic_context *)) ATTRIBUTE_NORETURN;
82 static bool text_specifies_location PARAMS ((text_info *, location_t *));
83 static bool diagnostic_count_diagnostic PARAMS ((diagnostic_context *,
84                                                  diagnostic_info *));
85 static void diagnostic_action_after_output PARAMS ((diagnostic_context *,
86                                                     diagnostic_info *));
87 static void real_abort PARAMS ((void)) ATTRIBUTE_NORETURN;
88
89 extern int rtl_dump_and_exit;
90 extern int warnings_are_errors;
91
92 /* A diagnostic_context surrogate for stderr.  */
93 static diagnostic_context global_diagnostic_context;
94 diagnostic_context *global_dc = &global_diagnostic_context;
95
96 /* Boilerplate text used in two locations.  */
97 #define bug_report_request \
98 "Please submit a full bug report,\n\
99 with preprocessed source if appropriate.\n\
100 See %s for instructions.\n"
101
102 \f
103 /* Subroutine of output_set_maximum_length.  Set up BUFFER's
104    internal maximum characters per line.  */
105 static void
106 set_real_maximum_length (buffer)
107      output_buffer *buffer;
108 {
109   /* If we're told not to wrap lines then do the obvious thing.  In case
110    we'll emit prefix only once per diagnostic message, it is appropriate
111   not to increase unnecessarily the line-length cut-off.  */
112   if (!output_is_line_wrapping (buffer)
113       || output_prefixing_rule (buffer) == DIAGNOSTICS_SHOW_PREFIX_ONCE
114       || output_prefixing_rule (buffer) == DIAGNOSTICS_SHOW_PREFIX_NEVER)
115     line_wrap_cutoff (buffer) = output_line_cutoff (buffer);
116   else
117     {
118       int prefix_length = buffer->state.prefix ?
119         strlen (buffer->state.prefix) : 0;
120       /* If the prefix is ridiculously too long, output at least
121          32 characters.  */
122       if (output_line_cutoff (buffer) - prefix_length < 32)
123         line_wrap_cutoff (buffer) = output_line_cutoff (buffer) + 32;
124       else
125         line_wrap_cutoff (buffer) = output_line_cutoff (buffer);
126     }
127 }
128
129 /* Sets the number of maximum characters per line BUFFER can output
130    in line-wrapping mode.  A LENGTH value 0 suppresses line-wrapping.  */
131 void
132 output_set_maximum_length (buffer, length)
133      output_buffer *buffer;
134      int length;
135 {
136   output_line_cutoff (buffer) = length;
137   set_real_maximum_length (buffer);
138 }
139
140 /* Sets BUFFER's PREFIX.  */
141 void
142 output_set_prefix (buffer, prefix)
143      output_buffer *buffer;
144      const char *prefix;
145 {
146   buffer->state.prefix = prefix;
147   set_real_maximum_length (buffer);
148   prefix_was_emitted_for (buffer) = false;
149   output_indentation (buffer) = 0;
150 }
151
152 /*  Return a pointer to the last character emitted in the output
153     BUFFER area.  A NULL pointer means no character available.  */
154 const char *
155 output_last_position (buffer)
156      const output_buffer *buffer;
157 {
158   const char *p = NULL;
159
160   if (obstack_base (&buffer->obstack) != obstack_next_free (&buffer->obstack))
161     p = ((const char *) obstack_next_free (&buffer->obstack)) - 1;
162   return p;
163 }
164
165 /* Free BUFFER's prefix, a previously malloc'd string.  */
166 void
167 output_destroy_prefix (buffer)
168      output_buffer *buffer;
169 {
170   if (buffer->state.prefix != NULL)
171     {
172       free ((char *) buffer->state.prefix);
173       buffer->state.prefix = NULL;
174     }
175 }
176
177 /* Zero out any text output so far in BUFFER.  */
178 void
179 output_clear_message_text (buffer)
180      output_buffer *buffer;
181 {
182   obstack_free (&buffer->obstack, obstack_base (&buffer->obstack));
183   output_text_length (buffer) = 0;
184 }
185
186 /* Zero out any formatting data used so far by BUFFER.  */
187 static void
188 output_clear_data (buffer)
189      output_buffer *buffer;
190 {
191   prefix_was_emitted_for (buffer) = false;
192   output_indentation (buffer) = 0;
193 }
194
195 /* Construct an output BUFFER with PREFIX and of MAXIMUM_LENGTH
196    characters per line.  */
197 void
198 init_output_buffer (buffer, prefix, maximum_length)
199      output_buffer *buffer;
200      const char *prefix;
201      int maximum_length;
202 {
203   memset (buffer, 0, sizeof (output_buffer));
204   obstack_init (&buffer->obstack);
205   output_buffer_attached_stream (buffer) = stderr;
206   output_line_cutoff (buffer) = maximum_length;
207   output_prefixing_rule (buffer) = diagnostic_prefixing_rule (global_dc);
208   output_set_prefix (buffer, prefix);
209   output_text_length (buffer) = 0;
210   output_clear_data (buffer);
211 }
212
213 /* Reinitialize BUFFER.  */
214 void
215 output_clear (buffer)
216      output_buffer *buffer;
217 {
218   output_clear_message_text (buffer);
219   output_clear_data (buffer);
220 }
221
222 /* Finishes constructing a NULL-terminated character string representing
223    the BUFFERed message.  */
224 const char *
225 output_finalize_message (buffer)
226      output_buffer *buffer;
227 {
228   obstack_1grow (&buffer->obstack, '\0');
229   return output_message_text (buffer);
230 }
231
232 /* Return the amount of characters BUFFER can accept to
233    make a full line.  */
234 int
235 output_space_left (buffer)
236      const output_buffer *buffer;
237 {
238   return line_wrap_cutoff (buffer) - output_text_length (buffer);
239 }
240
241 /* Write out BUFFER's prefix.  */
242 void
243 output_emit_prefix (buffer)
244      output_buffer *buffer;
245 {
246   if (buffer->state.prefix != NULL)
247     {
248       switch (output_prefixing_rule (buffer))
249         {
250         default:
251         case DIAGNOSTICS_SHOW_PREFIX_NEVER:
252           break;
253
254         case DIAGNOSTICS_SHOW_PREFIX_ONCE:
255           if (prefix_was_emitted_for (buffer))
256             {
257               output_indent (buffer);
258               break;
259             }
260           output_indentation (buffer) += 3;
261           /* Fall through.  */
262
263         case DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE:
264           {
265             int prefix_length = strlen (buffer->state.prefix);
266             output_append_r (buffer, buffer->state.prefix, prefix_length);
267             prefix_was_emitted_for (buffer) = true;
268           }
269           break;
270         }
271     }
272 }
273
274 /* Have BUFFER start a new line.  */
275 void
276 output_add_newline (buffer)
277      output_buffer *buffer;
278 {
279   obstack_1grow (&buffer->obstack, '\n');
280   output_text_length (buffer) = 0;
281 }
282
283 /* Appends a character to BUFFER.  */
284 void
285 output_add_character (buffer, c)
286      output_buffer *buffer;
287      int c;
288 {
289   if (output_is_line_wrapping (buffer) && output_space_left (buffer) <= 0)
290     output_add_newline (buffer);
291   obstack_1grow (&buffer->obstack, c);
292   ++output_text_length (buffer);
293 }
294
295 /* Adds a space to BUFFER.  */
296 void
297 output_add_space (buffer)
298      output_buffer *buffer;
299 {
300   if (output_is_line_wrapping (buffer) && output_space_left (buffer) <= 0)
301     {
302       output_add_newline (buffer);
303       return;
304     }
305   obstack_1grow (&buffer->obstack, ' ');
306   ++output_text_length (buffer);
307 }
308
309 /* These functions format an INTEGER into BUFFER as suggested by their
310    names.  */
311 void
312 output_decimal (buffer, i)
313      output_buffer *buffer;
314      int i;
315 {
316   output_formatted_scalar (buffer, "%d", i);
317 }
318
319 static inline void
320 output_long_decimal (output_buffer *buffer, long int i)
321 {
322   output_formatted_scalar (buffer, "%ld", i);
323 }
324
325 static inline void
326 output_unsigned_decimal (output_buffer *buffer, unsigned int i)
327 {
328   output_formatted_scalar (buffer, "%u", i);
329 }
330
331 static inline void
332 output_long_unsigned_decimal (output_buffer *buffer, long unsigned int i)
333 {
334   output_formatted_scalar (buffer, "%lu", i);
335 }
336
337 static inline void
338 output_octal (output_buffer *buffer, unsigned int i)
339 {
340   output_formatted_scalar (buffer, "%o", i);
341 }
342
343 static inline void
344 output_long_octal (output_buffer *buffer, long unsigned int i)
345 {
346   output_formatted_scalar (buffer, "%lo", i);
347 }
348
349 static inline void
350 output_hexadecimal (output_buffer *buffer, unsigned int i)
351 {
352   output_formatted_scalar (buffer, "%x", i);
353 }
354
355 static inline void
356 output_long_hexadecimal (output_buffer *buffer, long unsigned int i)
357 {
358   output_formatted_scalar (buffer, "%lx", i);
359 }
360
361 static inline void
362 output_pointer (output_buffer *buffer, void *p)
363 {
364   output_formatted_scalar (buffer, HOST_PTR_PRINTF, p);
365 }
366
367 /* Append to BUFFER a string specified by its STARTING character
368    and LENGTH.  */
369 static void
370 output_append_r (buffer, start, length)
371      output_buffer *buffer;
372      const char *start;
373      int length;
374 {
375   obstack_grow (&buffer->obstack, start, length);
376   output_text_length (buffer) += length;
377 }
378
379 /* Append a string deliminated by START and END to BUFFER.  No wrapping is
380    done.  However, if beginning a new line then emit BUFFER->state.prefix
381    and skip any leading whitespace if appropriate.  The caller must ensure
382    that it is safe to do so.  */
383 void
384 output_append (buffer, start, end)
385      output_buffer *buffer;
386      const char *start;
387      const char *end;
388 {
389   /* Emit prefix and skip whitespace if we're starting a new line.  */
390   if (is_starting_newline (buffer))
391     {
392       output_emit_prefix (buffer);
393       if (output_is_line_wrapping (buffer))
394         while (start != end && *start == ' ')
395           ++start;
396     }
397   output_append_r (buffer, start, end - start);
398 }
399
400 /* Insert enough spaces into BUFFER to bring the column position to
401    the current indentation level, assuming that a newline has just
402    been written to the buffer.  */
403 static void
404 output_indent (buffer)
405      output_buffer *buffer;
406 {
407   int n = output_indentation (buffer);
408   int i;
409
410   for (i = 0; i < n; ++i)
411     output_add_character (buffer, ' ');
412 }
413
414 /* Wrap a text delimited by START and END into BUFFER.  */
415 static void
416 wrap_text (buffer, start, end)
417      output_buffer *buffer;
418      const char *start;
419      const char *end;
420 {
421   bool is_wrapping = output_is_line_wrapping (buffer);
422
423   while (start != end)
424     {
425       /* Dump anything bordered by whitespaces.  */
426       {
427         const char *p = start;
428         while (p != end && *p != ' ' && *p != '\n')
429           ++p;
430         if (is_wrapping && p - start >= output_space_left (buffer))
431           output_add_newline (buffer);
432         output_append (buffer, start, p);
433         start = p;
434       }
435
436       if (start != end && *start == ' ')
437         {
438           output_add_space (buffer);
439           ++start;
440         }
441       if (start != end && *start == '\n')
442         {
443           output_add_newline (buffer);
444           ++start;
445         }
446     }
447 }
448
449 /* Same as wrap_text but wrap text only when in line-wrapping mode.  */
450 static void
451 maybe_wrap_text (buffer, start, end)
452      output_buffer *buffer;
453      const char *start;
454      const char *end;
455 {
456   if (output_is_line_wrapping (buffer))
457     wrap_text (buffer, start, end);
458   else
459     output_append (buffer, start, end);
460 }
461
462
463 /* Append a STRING to BUFFER; the STRING might be line-wrapped if in
464    appropriate mode.  */
465 void
466 output_add_string (buffer, str)
467      output_buffer *buffer;
468      const char *str;
469 {
470   maybe_wrap_text (buffer, str, str + (str ? strlen (str) : 0));
471 }
472
473 /* Append an identifier ID to BUFFER.  */
474 void
475 output_add_identifier (buffer, id)
476      output_buffer *buffer;
477      tree id;
478 {
479   output_append (buffer, IDENTIFIER_POINTER (id),
480                  IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id));
481 }
482
483 /* Flush the content of BUFFER onto the attached stream,
484    and reinitialize.  */
485
486 static void
487 output_buffer_to_stream (buffer)
488      output_buffer *buffer;
489 {
490   const char *text = output_finalize_message (buffer);
491   fputs (text, output_buffer_attached_stream (buffer));
492   output_clear_message_text (buffer);
493 }
494
495 /* Format a message pointed to by TEXT.  The following format specifiers are
496    recognized as being language independent:
497    %d, %i: (signed) integer in base ten.
498    %u: unsigned integer in base ten.
499    %o: unsigned integer in base eight.
500    %x: unsigned integer in base sixteen.
501    %ld, %li, %lo, %lu, %lx: long versions of the above.
502    %c: character.
503    %s: string.
504    %p: pointer.
505    %m: strerror(text->err_no) - does not consume a value from args_ptr.
506    %%: `%'.
507    %*.s: a substring the length of which is specified by an integer.
508    %H: location_t.  */
509 static void
510 output_format (buffer, text)
511      output_buffer *buffer;
512      text_info *text;
513 {
514   for (; *text->format_spec; ++text->format_spec)
515     {
516       bool long_integer = 0;
517
518       /* Ignore text.  */
519       {
520         const char *p = text->format_spec;
521         while (*p && *p != '%')
522           ++p;
523         wrap_text (buffer, text->format_spec, p);
524         text->format_spec = p;
525       }
526
527       if (*text->format_spec == '\0')
528         break;
529
530       /* We got a '%'.  Let's see what happens. Record whether we're
531          parsing a long integer format specifier.  */
532       if (*++text->format_spec == 'l')
533         {
534           long_integer = true;
535           ++text->format_spec;
536         }
537
538       /* Handle %c, %d, %i, %ld, %li, %lo, %lu, %lx, %m, %o, %s, %u,
539          %x, %p, %.*s; %%.  And nothing else.  Front-ends should install
540          printers to grok language specific format specifiers.  */
541       switch (*text->format_spec)
542         {
543         case 'c':
544           output_add_character (buffer, va_arg (*text->args_ptr, int));
545           break;
546
547         case 'd':
548         case 'i':
549           if (long_integer)
550             output_long_decimal (buffer, va_arg (*text->args_ptr, long int));
551           else
552             output_decimal (buffer, va_arg (*text->args_ptr, int));
553           break;
554
555         case 'o':
556           if (long_integer)
557             output_long_octal (buffer,
558                                va_arg (*text->args_ptr, unsigned long int));
559           else
560             output_octal (buffer, va_arg (*text->args_ptr, unsigned int));
561           break;
562
563         case 's':
564           output_add_string (buffer, va_arg (*text->args_ptr, const char *));
565           break;
566
567         case 'p':
568           output_pointer (buffer, va_arg (*text->args_ptr, void *));
569           break;
570
571         case 'u':
572           if (long_integer)
573             output_long_unsigned_decimal
574               (buffer, va_arg (*text->args_ptr, long unsigned int));
575           else
576             output_unsigned_decimal
577               (buffer, va_arg (*text->args_ptr, unsigned int));
578           break;
579
580         case 'x':
581           if (long_integer)
582             output_long_hexadecimal
583               (buffer, va_arg (*text->args_ptr, unsigned long int));
584           else
585             output_hexadecimal
586               (buffer, va_arg (*text->args_ptr, unsigned int));
587           break;
588
589         case 'm':
590           output_add_string (buffer, xstrerror (text->err_no));
591           break;
592
593         case '%':
594           output_add_character (buffer, '%');
595           break;
596
597         case 'H':
598           {
599             const location_t *locus = va_arg (*text->args_ptr, location_t *);
600             output_add_string (buffer, "file '");
601             output_add_string (buffer, locus->file);
602             output_add_string (buffer, "', line ");
603             output_decimal (buffer, locus->line);
604           }
605           break;
606
607         case '.':
608           {
609             int n;
610             const char *s;
611             /* We handle no precision specifier but `%.*s'.  */
612             if (*++text->format_spec != '*')
613               abort ();
614             else if (*++text->format_spec != 's')
615               abort ();
616             n = va_arg (*text->args_ptr, int);
617             s = va_arg (*text->args_ptr, const char *);
618             output_append (buffer, s, s + n);
619           }
620           break;
621
622         default:
623           if (!buffer->format_decoder
624               || !(*buffer->format_decoder) (buffer, text))
625             {
626               /* Hmmm.  The front-end failed to install a format translator
627                  but called us with an unrecognized format.  Or, maybe, the
628                  translated string just contains an invalid format, or
629                  has formats in the wrong order.  Sorry.  */
630               abort ();
631             }
632         }
633     }
634 }
635
636 /* Return a malloc'd string containing MSG formatted a la printf.  The
637    caller is responsible for freeing the memory.  */
638 static char *
639 build_message_string VPARAMS ((const char *msg, ...))
640 {
641   char *str;
642
643   VA_OPEN (ap, msg);
644   VA_FIXEDARG (ap, const char *, msg);
645
646   vasprintf (&str, msg, ap);
647
648   VA_CLOSE (ap);
649
650   return str;
651 }
652
653 /* Same as diagnostic_build_prefix, but only the source FILE is given.  */
654 char *
655 file_name_as_prefix (f)
656      const char *f;
657 {
658   return build_message_string ("%s: ", f);
659 }
660
661 /* Format a message into BUFFER a la printf.  */
662 void
663 output_printf VPARAMS ((struct output_buffer *buffer, const char *msgid, ...))
664 {
665   text_info text;
666   VA_OPEN (ap, msgid);
667   VA_FIXEDARG (ap, output_buffer *, buffer);
668   VA_FIXEDARG (ap, const char *, msgid);
669
670   text.err_no = errno;
671   text.args_ptr = &ap;
672   text.format_spec = _(msgid);
673   output_format (buffer, &text);
674   VA_CLOSE (ap);
675 }
676
677 /* Print a message relevant to the given DECL.  */
678 static void
679 format_with_decl (buffer, text, decl)
680      output_buffer *buffer;
681      text_info *text;
682      tree decl;
683 {
684   const char *p;
685
686   /* Do magic to get around lack of varargs support for insertion
687      of arguments into existing list.  We know that the decl is first;
688      we ass_u_me that it will be printed with "%s".  */
689   for (p = text->format_spec; *p; ++p)
690     {
691       if (*p == '%')
692         {
693           if (*(p + 1) == '%')
694             ++p;
695           else if (*(p + 1) != 's')
696             abort ();
697           else
698             break;
699         }
700     }
701
702   /* Print the left-hand substring.  */
703   maybe_wrap_text (buffer, text->format_spec, p);
704
705   if (*p == '%')                /* Print the name.  */
706     {
707       const char *const n = (DECL_NAME (decl)
708                              ? (*lang_hooks.decl_printable_name) (decl, 2)
709                              : _("((anonymous))"));
710       output_add_string (buffer, n);
711       while (*p)
712         {
713           ++p;
714           if (ISALPHA (*(p - 1) & 0xFF))
715             break;
716         }
717     }
718
719   if (*p)                       /* Print the rest of the message.  */
720     {
721       text->format_spec = p;
722       output_format (buffer, text);
723     }
724 }
725
726 /* Flush the content of BUFFER onto the attached stream.  */
727 static void
728 output_flush (buffer)
729      output_buffer *buffer;
730 {
731   output_buffer_to_stream (buffer);
732   output_clear_data (buffer);
733   fputc ('\n', output_buffer_attached_stream (buffer));
734   fflush (output_buffer_attached_stream (buffer));
735 }
736
737 /* Helper subroutine of output_verbatim and verbatim. Do the appropriate
738    settings needed by BUFFER for a verbatim formatting.  */
739 static void
740 output_do_verbatim (buffer, text)
741      output_buffer *buffer;
742      text_info *text;
743 {
744   diagnostic_prefixing_rule_t rule = output_prefixing_rule (buffer);
745   int line_cutoff = output_line_cutoff (buffer);
746
747   /* Set verbatim mode.  */
748   output_prefixing_rule (buffer) = DIAGNOSTICS_SHOW_PREFIX_NEVER;
749   output_line_cutoff (buffer) = 0;
750   /* Do the actual formatting.  */
751   output_format (buffer, text);
752   /* Restore previous settings.  */
753   output_prefixing_rule (buffer) = rule;
754   output_line_cutoff (buffer) = line_cutoff;
755 }
756
757 /* Output MESSAGE verbatim into BUFFER.  */
758 void
759 output_verbatim VPARAMS ((output_buffer *buffer, const char *msgid, ...))
760 {
761   text_info text;
762   VA_OPEN (ap, msgid);
763   VA_FIXEDARG (ap, output_buffer *, buffer);
764   VA_FIXEDARG (ap, const char *, msgid);
765
766   text.err_no = errno;
767   text.args_ptr = &ap;
768   text.format_spec = _(msgid);
769   output_do_verbatim (buffer, &text);
770   VA_CLOSE (ap);
771 }
772
773 \f
774 /* Initialize the diagnostic message outputting machinery.  */
775 void
776 diagnostic_initialize (context)
777      diagnostic_context *context;
778 {
779   memset (context, 0, sizeof *context);
780   obstack_init (&context->buffer.obstack);
781
782   /* By default, diagnostics are sent to stderr.  */
783   output_buffer_attached_stream (&context->buffer) = stderr;
784
785   /* By default, we emit prefixes once per message.  */
786   diagnostic_prefixing_rule (context) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
787
788   diagnostic_starter (context) = default_diagnostic_starter;
789   diagnostic_finalizer (context) = default_diagnostic_finalizer;
790   context->warnings_are_errors_message = warnings_are_errors;
791 }
792
793 /* Returns true if the next format specifier in TEXT is a format specifier
794    for a location_t.  If so, update the object pointed by LOCUS to reflect
795    the specified location in *TEXT->args_ptr.  */
796 static bool
797 text_specifies_location (text, locus)
798      text_info *text;
799      location_t *locus;
800 {
801   const char *p;
802   /* Skip any leading text.  */
803   for (p = text->format_spec; *p && *p != '%'; ++p)
804     ;
805
806   /* Extract the location information if any.  */
807   if (*p == '%' && *++p == 'H')
808     {
809       *locus = *va_arg (*text->args_ptr, location_t *);
810       text->format_spec = p + 1;
811       return true;
812     }
813
814   return false;
815 }
816
817 void
818 diagnostic_set_info (diagnostic, msgid, args, file, line, kind)
819      diagnostic_info *diagnostic;
820      const char *msgid;
821      va_list *args;
822      const char *file;
823      int line;
824      diagnostic_t kind;
825 {
826   diagnostic->message.err_no = errno;
827   diagnostic->message.args_ptr = args;
828   diagnostic->message.format_spec = _(msgid);
829   /* If the diagnostic message doesn't specify a location,
830      use FILE and LINE.  */
831   if (!text_specifies_location (&diagnostic->message, &diagnostic->location))
832     {
833       diagnostic->location.file = file;
834       diagnostic->location.line = line;
835     }
836   diagnostic->kind = kind;
837 }
838
839 /* Return a malloc'd string describing a location.  The caller is
840    responsible for freeing the memory.  */
841 char *
842 diagnostic_build_prefix (diagnostic)
843      diagnostic_info *diagnostic;
844 {
845   static const char *const diagnostic_kind_text[] = {
846 #define DEFINE_DIAGNOSTIC_KIND(K, T) (T),
847 #include "diagnostic.def"
848 #undef DEFINE_DIAGNOSTIC_KIND
849     "must-not-happen"
850   };
851    if (diagnostic->kind >= DK_LAST_DIAGNOSTIC_KIND)
852      abort();
853
854   return diagnostic->location.file
855     ? build_message_string ("%s:%d: %s",
856                             diagnostic->location.file,
857                             diagnostic->location.line,
858                             _(diagnostic_kind_text[diagnostic->kind]))
859     : build_message_string ("%s: %s", progname,
860                             _(diagnostic_kind_text[diagnostic->kind]));
861 }
862
863 void
864 diagnostic_flush_buffer (context)
865      diagnostic_context *context;
866 {
867   output_buffer_to_stream (&context->buffer);
868   fflush (output_buffer_attached_stream (&context->buffer));
869 }
870
871 /* Count a diagnostic.  Return true if the message should be printed.  */
872 static bool
873 diagnostic_count_diagnostic (context, diagnostic)
874     diagnostic_context *context;
875     diagnostic_info *diagnostic;
876 {
877   diagnostic_t kind = diagnostic->kind;
878   switch (kind)
879     {
880     default:
881       abort();
882       break;
883
884     case DK_ICE:
885 #ifndef ENABLE_CHECKING
886       /* When not checking, ICEs are converted to fatal errors when an
887          error has already occurred.  This is counteracted by
888          abort_on_error.  */
889       if ((diagnostic_kind_count (context, DK_ERROR) > 0
890            || diagnostic_kind_count (context, DK_SORRY) > 0)
891           && !context->abort_on_error)
892         {
893           fnotice (stderr, "%s:%d: confused by earlier errors, bailing out\n",
894                    diagnostic->location.file, diagnostic->location.line);
895           exit (FATAL_EXIT_CODE);
896         }
897 #endif
898       if (context->internal_error)
899         (*context->internal_error) (diagnostic->message.format_spec,
900                                     diagnostic->message.args_ptr);
901       /* fall through */
902
903     case DK_FATAL: case DK_SORRY:
904     case DK_ANACHRONISM: case DK_NOTE:
905       ++diagnostic_kind_count (context, kind);
906       break;
907
908     case DK_WARNING:
909       if (!diagnostic_report_warnings_p ())
910         return false;
911
912       if (!warnings_are_errors)
913         {
914           ++diagnostic_kind_count (context, DK_WARNING);
915           break;
916         }
917
918       if (context->warnings_are_errors_message)
919         {
920           output_verbatim (&context->buffer,
921                            "%s: warnings being treated as errors\n", progname);
922           context->warnings_are_errors_message = false;
923         }
924
925       /* and fall through */
926     case DK_ERROR:
927       ++diagnostic_kind_count (context, DK_ERROR);
928       break;
929     }
930
931   return true;
932 }
933
934 /* Take any action which is expected to happen after the diagnostic
935    is written out.  This function does not always return.  */
936 static void
937 diagnostic_action_after_output (context, diagnostic)
938      diagnostic_context *context;
939      diagnostic_info *diagnostic;
940 {
941   switch (diagnostic->kind)
942     {
943     case DK_DEBUG:
944     case DK_NOTE:
945     case DK_ANACHRONISM:
946     case DK_WARNING:
947       break;
948
949     case DK_ERROR:
950     case DK_SORRY:
951       if (context->abort_on_error)
952         real_abort ();
953       break;
954
955     case DK_ICE:
956       if (context->abort_on_error)
957         real_abort ();
958
959       fnotice (stderr, bug_report_request, bug_report_url);
960       exit (FATAL_EXIT_CODE);
961
962     case DK_FATAL:
963       if (context->abort_on_error)
964         real_abort ();
965
966       fnotice (stderr, "compilation terminated.\n");
967       exit (FATAL_EXIT_CODE);
968
969     default:
970       real_abort ();
971     }
972 }
973
974 /* Called when the start of a function definition is parsed,
975    this function prints on stderr the name of the function.  */
976 void
977 announce_function (decl)
978      tree decl;
979 {
980   if (!quiet_flag)
981     {
982       if (rtl_dump_and_exit)
983         verbatim ("%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));
984       else
985         verbatim (" %s", (*lang_hooks.decl_printable_name) (decl, 2));
986       fflush (stderr);
987       output_needs_newline (&global_dc->buffer) = true;
988       diagnostic_set_last_function (global_dc);
989     }
990 }
991
992 /* The default function to print out name of current function that caused
993    an error.  */
994 void
995 lhd_print_error_function (context, file)
996      diagnostic_context *context;
997      const char *file;
998 {
999   if (diagnostic_last_function_changed (context))
1000     {
1001       const char *old_prefix = output_prefix (&context->buffer);
1002       char *new_prefix = file ? build_message_string ("%s: ", file) : NULL;
1003
1004       output_set_prefix (&context->buffer, new_prefix);
1005
1006       if (current_function_decl == NULL)
1007         output_add_string (&context->buffer, _("At top level:"));
1008       else
1009         {
1010           if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
1011             output_printf
1012               (&context->buffer, "In member function `%s':",
1013                (*lang_hooks.decl_printable_name) (current_function_decl, 2));
1014           else
1015             output_printf
1016               (&context->buffer, "In function `%s':",
1017                (*lang_hooks.decl_printable_name) (current_function_decl, 2));
1018         }
1019       output_add_newline (&context->buffer);
1020
1021       diagnostic_set_last_function (context);
1022       output_buffer_to_stream (&context->buffer);
1023       context->buffer.state.prefix = old_prefix;
1024       free ((char*) new_prefix);
1025     }
1026 }
1027
1028 /* Prints out, if necessary, the name of the current function
1029   that caused an error.  Called from all error and warning functions.
1030   We ignore the FILE parameter, as it cannot be relied upon.  */
1031
1032 void
1033 diagnostic_report_current_function (context)
1034      diagnostic_context *context;
1035 {
1036   diagnostic_report_current_module (context);
1037   (*lang_hooks.print_error_function) (context, input_filename);
1038 }
1039
1040 void
1041 diagnostic_report_current_module (context)
1042      diagnostic_context *context;
1043 {
1044   struct file_stack *p;
1045
1046   if (output_needs_newline (&context->buffer))
1047     {
1048       output_add_newline (&context->buffer);
1049       output_needs_newline (&context->buffer) = false;
1050     }
1051
1052   if (input_file_stack && input_file_stack->next != 0
1053       && diagnostic_last_module_changed (context))
1054     {
1055       for (p = input_file_stack->next; p; p = p->next)
1056         if (p == input_file_stack->next)
1057           output_verbatim (&context->buffer,
1058                            "In file included from %s:%d",
1059                            p->location.file, p->location.line);
1060         else
1061           output_verbatim (&context->buffer,
1062                            ",\n                 from %s:%d",
1063                            p->location.file, p->location.line);
1064       output_verbatim (&context->buffer, ":\n");
1065       diagnostic_set_last_module (context);
1066     }
1067 }
1068
1069 static void
1070 default_diagnostic_starter (context, diagnostic)
1071      diagnostic_context *context;
1072      diagnostic_info *diagnostic;
1073 {
1074   diagnostic_report_current_function (context);
1075   output_set_prefix (&context->buffer, diagnostic_build_prefix (diagnostic));
1076 }
1077
1078 static void
1079 default_diagnostic_finalizer (context, diagnostic)
1080      diagnostic_context *context;
1081      diagnostic_info *diagnostic __attribute__((unused));
1082 {
1083   output_destroy_prefix (&context->buffer);
1084 }
1085
1086 /* Report a diagnostic message (an error or a warning) as specified by
1087    DC.  This function is *the* subroutine in terms of which front-ends
1088    should implement their specific diagnostic handling modules.  The
1089    front-end independent format specifiers are exactly those described
1090    in the documentation of output_format.  */
1091
1092 void
1093 diagnostic_report_diagnostic (context, diagnostic)
1094      diagnostic_context *context;
1095      diagnostic_info *diagnostic;
1096 {
1097   if (context->lock++)
1098     error_recursion (context);
1099
1100   if (diagnostic_count_diagnostic (context, diagnostic))
1101     {
1102       (*diagnostic_starter (context)) (context, diagnostic);
1103       output_format (&context->buffer, &diagnostic->message);
1104       (*diagnostic_finalizer (context)) (context, diagnostic);
1105       output_flush (&context->buffer);
1106       diagnostic_action_after_output (context, diagnostic);
1107     }
1108
1109   context->lock--;
1110 }
1111
1112 /* Report a diagnostic MESSAGE at the declaration DECL.
1113    MSG is a format string which uses %s to substitute the declaration
1114    name; subsequent substitutions are a la output_format.  */
1115 static void
1116 diagnostic_for_decl (context, diagnostic, decl)
1117      diagnostic_context *context;
1118      diagnostic_info *diagnostic;
1119      tree decl;
1120 {
1121   if (context->lock++)
1122     error_recursion (context);
1123
1124   if (diagnostic_count_diagnostic (context, diagnostic))
1125     {
1126       (*diagnostic_starter (context)) (context, diagnostic);
1127       format_with_decl (&context->buffer, &diagnostic->message, decl);
1128       (*diagnostic_finalizer (context)) (context, diagnostic);
1129       output_flush (&context->buffer);
1130       diagnostic_action_after_output (context, diagnostic);
1131     }
1132
1133   context->lock--;
1134 }
1135
1136 /* Given a partial pathname as input, return another pathname that
1137    shares no directory elements with the pathname of __FILE__.  This
1138    is used by fancy_abort() to print `Internal compiler error in expr.c'
1139    instead of `Internal compiler error in ../../GCC/gcc/expr.c'.  */
1140
1141 const char *
1142 trim_filename (name)
1143      const char *name;
1144 {
1145   static const char this_file[] = __FILE__;
1146   const char *p = name, *q = this_file;
1147
1148   /* First skip any "../" in each filename.  This allows us to give a proper
1149      reference to a file in a subdirectory.  */
1150   while (p[0] == '.' && p[1] == '.'
1151          && (p[2] == DIR_SEPARATOR
1152 #ifdef DIR_SEPARATOR_2
1153              || p[2] == DIR_SEPARATOR_2
1154 #endif
1155              ))
1156     p += 3;
1157
1158   while (q[0] == '.' && q[1] == '.'
1159          && (q[2] == DIR_SEPARATOR
1160 #ifdef DIR_SEPARATOR_2
1161              || p[2] == DIR_SEPARATOR_2
1162 #endif
1163              ))
1164     q += 3;
1165
1166   /* Now skip any parts the two filenames have in common.  */
1167   while (*p == *q && *p != 0 && *q != 0)
1168     p++, q++;
1169
1170   /* Now go backwards until the previous directory separator.  */
1171   while (p > name && p[-1] != DIR_SEPARATOR
1172 #ifdef DIR_SEPARATOR_2
1173          && p[-1] != DIR_SEPARATOR_2
1174 #endif
1175          )
1176     p--;
1177
1178   return p;
1179 }
1180 \f
1181 /* Standard error reporting routines in increasing order of severity.
1182    All of these take arguments like printf.  */
1183
1184 /* Text to be emitted verbatim to the error message stream; this
1185    produces no prefix and disables line-wrapping.  Use rarely.  */
1186 void
1187 verbatim VPARAMS ((const char *msgid, ...))
1188 {
1189   text_info text;
1190   VA_OPEN (ap, msgid);
1191   VA_FIXEDARG (ap, const char *, msgid);
1192
1193   text.err_no = errno;
1194   text.args_ptr = &ap;
1195   text.format_spec = _(msgid);
1196   output_do_verbatim (&global_dc->buffer, &text);
1197   output_buffer_to_stream (&global_dc->buffer);
1198   VA_CLOSE (ap);
1199 }
1200
1201 /* An informative note.  Use this for additional details on an error
1202    message.  */
1203 void
1204 inform VPARAMS ((const char *msgid, ...))
1205 {
1206   diagnostic_info diagnostic;
1207
1208   VA_OPEN (ap, msgid);
1209   VA_FIXEDARG (ap, const char *, msgid);
1210
1211   diagnostic_set_info (&diagnostic, msgid, &ap, input_filename, input_line,
1212                        DK_NOTE);
1213   report_diagnostic (&diagnostic);
1214   VA_CLOSE (ap);
1215 }
1216
1217 /* A warning.  Use this for code which is correct according to the
1218    relevant language specification but is likely to be buggy anyway.  */
1219 void
1220 warning VPARAMS ((const char *msgid, ...))
1221 {
1222   diagnostic_info diagnostic;
1223
1224   VA_OPEN (ap, msgid);
1225   VA_FIXEDARG (ap, const char *, msgid);
1226
1227   diagnostic_set_info (&diagnostic, msgid, &ap, input_filename, input_line,
1228                        DK_WARNING);
1229   report_diagnostic (&diagnostic);
1230   VA_CLOSE (ap);
1231 }
1232
1233 /* A "pedantic" warning: issues a warning unless -pedantic-errors was
1234    given on the command line, in which case it issues an error.  Use
1235    this for diagnostics required by the relevant language standard,
1236    if you have chosen not to make them errors.
1237
1238    Note that these diagnostics are issued independent of the setting
1239    of the -pedantic command-line switch.  To get a warning enabled
1240    only with that switch, write "if (pedantic) pedwarn (...);"  */
1241 void
1242 pedwarn VPARAMS ((const char *msgid, ...))
1243 {
1244   diagnostic_info diagnostic;
1245   VA_OPEN (ap, msgid);
1246   VA_FIXEDARG (ap, const char *, msgid);
1247
1248   diagnostic_set_info (&diagnostic, msgid, &ap, input_filename, input_line,
1249                        pedantic_error_kind ());
1250   report_diagnostic (&diagnostic);
1251   VA_CLOSE (ap);
1252 }
1253
1254 /* A hard error: the code is definitely ill-formed, and an object file
1255    will not be produced.  */
1256 void
1257 error VPARAMS ((const char *msgid, ...))
1258 {
1259   diagnostic_info diagnostic;
1260
1261   VA_OPEN (ap, msgid);
1262   VA_FIXEDARG (ap, const char *, msgid);
1263
1264   diagnostic_set_info (&diagnostic, msgid, &ap, input_filename, input_line,
1265                        DK_ERROR);
1266   report_diagnostic (&diagnostic);
1267   VA_CLOSE (ap);
1268 }
1269
1270 /* "Sorry, not implemented."  Use for a language feature which is
1271    required by the relevant specification but not implemented by GCC.
1272    An object file will not be produced.  */
1273 void
1274 sorry VPARAMS ((const char *msgid, ...))
1275 {
1276   diagnostic_info diagnostic;
1277
1278   VA_OPEN (ap, msgid);
1279   VA_FIXEDARG (ap, const char *, msgid);
1280
1281   diagnostic_set_info (&diagnostic, msgid, &ap, input_filename, input_line,
1282                        DK_SORRY);
1283   report_diagnostic (&diagnostic);
1284   VA_CLOSE (ap);
1285 }
1286
1287 /* An error which is severe enough that we make no attempt to
1288    continue.  Do not use this for internal consistency checks; that's
1289    internal_error.  Use of this function should be rare.  */
1290 void
1291 fatal_error VPARAMS ((const char *msgid, ...))
1292 {
1293   diagnostic_info diagnostic;
1294
1295   VA_OPEN (ap, msgid);
1296   VA_FIXEDARG (ap, const char *, msgid);
1297
1298   diagnostic_set_info (&diagnostic, msgid, &ap, input_filename, input_line,
1299                        DK_FATAL);
1300   report_diagnostic (&diagnostic);
1301   VA_CLOSE (ap);
1302
1303   /* NOTREACHED */
1304   real_abort ();
1305 }
1306
1307 /* An internal consistency check has failed.  We make no attempt to
1308    continue.  Note that unless there is debugging value to be had from
1309    a more specific message, or some other good reason, you should use
1310    abort () instead of calling this function directly.  */
1311 void
1312 internal_error VPARAMS ((const char *msgid, ...))
1313 {
1314   diagnostic_info diagnostic;
1315
1316   VA_OPEN (ap, msgid);
1317   VA_FIXEDARG (ap, const char *, msgid);
1318
1319   diagnostic_set_info (&diagnostic, msgid, &ap, input_filename, input_line,
1320                        DK_ICE);
1321   report_diagnostic (&diagnostic);
1322   VA_CLOSE (ap);
1323
1324   /* NOTREACHED */
1325   real_abort ();
1326 }
1327 \f
1328 /* Variants of some of the above, which make reference to a particular
1329    DECL node.  These are deprecated.  */
1330
1331 void
1332 warning_with_decl VPARAMS ((tree decl, const char *msgid, ...))
1333 {
1334   diagnostic_info diagnostic;
1335   VA_OPEN (ap, msgid);
1336   VA_FIXEDARG (ap, tree, decl);
1337   VA_FIXEDARG (ap, const char *, msgid);
1338
1339   /* Do not issue a warning about a decl which came from a system header,
1340      unless -Wsystem-headers.  */
1341   if (DECL_IN_SYSTEM_HEADER (decl) && !warn_system_headers)
1342     return;
1343
1344   diagnostic_set_info (&diagnostic, msgid, &ap,
1345                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl),
1346                        DK_WARNING);
1347   diagnostic_for_decl (global_dc, &diagnostic, decl);
1348   VA_CLOSE (ap);
1349 }
1350
1351 void
1352 pedwarn_with_decl VPARAMS ((tree decl, const char *msgid, ...))
1353 {
1354   diagnostic_info diagnostic;
1355   VA_OPEN (ap, msgid);
1356   VA_FIXEDARG (ap, tree, decl);
1357   VA_FIXEDARG (ap, const char *, msgid);
1358
1359   /* Do not issue a warning about a decl which came from a system header,
1360      unless -Wsystem-headers.  */
1361   if (DECL_IN_SYSTEM_HEADER (decl) && !warn_system_headers)
1362     return;
1363
1364   diagnostic_set_info (&diagnostic, msgid, &ap,
1365                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl),
1366                        pedantic_error_kind ());
1367   diagnostic_for_decl (global_dc, &diagnostic, decl);
1368
1369   VA_CLOSE (ap);
1370 }
1371
1372 void
1373 error_with_decl VPARAMS ((tree decl, const char *msgid, ...))
1374 {
1375   diagnostic_info diagnostic;
1376   VA_OPEN (ap, msgid);
1377   VA_FIXEDARG (ap, tree, decl);
1378   VA_FIXEDARG (ap, const char *, msgid);
1379
1380   diagnostic_set_info (&diagnostic, msgid, &ap,
1381                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl),
1382                        DK_ERROR);
1383   diagnostic_for_decl (global_dc, &diagnostic, decl);
1384   VA_CLOSE (ap);
1385 }
1386 \f
1387 /* Special case error functions.  Most are implemented in terms of the
1388    above, or should be.  */
1389
1390 /* Print a diagnostic MSGID on FILE.  This is just fprintf, except it
1391    runs its second argument through gettext.  */
1392 void
1393 fnotice VPARAMS ((FILE *file, const char *msgid, ...))
1394 {
1395   VA_OPEN (ap, msgid);
1396   VA_FIXEDARG (ap, FILE *, file);
1397   VA_FIXEDARG (ap, const char *, msgid);
1398
1399   vfprintf (file, _(msgid), ap);
1400   VA_CLOSE (ap);
1401 }
1402
1403 /* Warn about a use of an identifier which was marked deprecated.  */
1404 void
1405 warn_deprecated_use (node)
1406      tree node;
1407 {
1408   if (node == 0 || !warn_deprecated_decl)
1409     return;
1410
1411   if (DECL_P (node))
1412     warning ("`%s' is deprecated (declared at %s:%d)",
1413              IDENTIFIER_POINTER (DECL_NAME (node)),
1414              DECL_SOURCE_FILE (node), DECL_SOURCE_LINE (node));
1415   else if (TYPE_P (node))
1416     {
1417       const char *what = NULL;
1418       tree decl = TYPE_STUB_DECL (node);
1419
1420       if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
1421         what = IDENTIFIER_POINTER (TYPE_NAME (node));
1422       else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
1423                && DECL_NAME (TYPE_NAME (node)))
1424         what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)));
1425
1426       if (what)
1427         {
1428           if (decl)
1429             warning ("`%s' is deprecated (declared at %s:%d)", what,
1430                      DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
1431           else
1432             warning ("`%s' is deprecated", what);
1433         }
1434       else if (decl)
1435         warning ("type is deprecated (declared at %s:%d)",
1436                  DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
1437       else
1438         warning ("type is deprecated");
1439     }
1440 }
1441
1442 /* Inform the user that an error occurred while trying to report some
1443    other error.  This indicates catastrophic internal inconsistencies,
1444    so give up now.  But do try to flush out the previous error.
1445    This mustn't use internal_error, that will cause infinite recursion.  */
1446
1447 static void
1448 error_recursion (context)
1449      diagnostic_context *context;
1450 {
1451   if (context->lock < 3)
1452     output_flush (&context->buffer);
1453
1454   fnotice (stderr,
1455            "Internal compiler error: Error reporting routines re-entered.\n");
1456   fnotice (stderr, bug_report_request, bug_report_url);
1457   exit (FATAL_EXIT_CODE);
1458 }
1459
1460 /* Report an internal compiler error in a friendly manner.  This is
1461    the function that gets called upon use of abort() in the source
1462    code generally, thanks to a special macro.  */
1463
1464 void
1465 fancy_abort (file, line, function)
1466      const char *file;
1467      int line;
1468      const char *function;
1469 {
1470   internal_error ("in %s, at %s:%d", function, trim_filename (file), line);
1471 }
1472
1473 /* Really call the system 'abort'.  This has to go right at the end of
1474    this file, so that there are no functions after it that call abort
1475    and get the system abort instead of our macro.  */
1476 #undef abort
1477 static void 
1478 real_abort ()
1479 {
1480   abort ();
1481 }