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>
5 This file is part of GCC.
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
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
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
23 /* This file implements the language independent aspect of diagnostic
27 #undef FLOAT /* This is for hpux. They should change hpux. */
28 #undef FFS /* Some systems define this in param.h. */
30 #include "coretypes.h"
38 #include "diagnostic.h"
39 #include "langhooks.h"
40 #include "langhooks-def.h"
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
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
*));
54 static char *vbuild_message_string
PARAMS ((const char *, va_list))
55 ATTRIBUTE_PRINTF (1, 0);
56 static char *build_message_string
PARAMS ((const char *, ...))
58 static void format_with_decl
PARAMS ((output_buffer
*, text_info
*, tree
));
59 static void diagnostic_for_decl
PARAMS ((diagnostic_info
*, tree
));
60 static void set_real_maximum_length
PARAMS ((output_buffer
*));
62 static void output_unsigned_decimal
PARAMS ((output_buffer
*, unsigned int));
63 static void output_long_decimal
PARAMS ((output_buffer
*, long int));
64 static void output_long_unsigned_decimal
PARAMS ((output_buffer
*,
66 static void output_octal
PARAMS ((output_buffer
*, unsigned int));
67 static void output_long_octal
PARAMS ((output_buffer
*, unsigned long int));
68 static void output_hexadecimal
PARAMS ((output_buffer
*, unsigned int));
69 static void output_long_hexadecimal
PARAMS ((output_buffer
*,
71 static void output_append_r
PARAMS ((output_buffer
*, const char *, int));
72 static void wrap_text
PARAMS ((output_buffer
*, const char *, const char *));
73 static void maybe_wrap_text
PARAMS ((output_buffer
*, const char *,
75 static void output_clear_data
PARAMS ((output_buffer
*));
77 static void default_diagnostic_starter
PARAMS ((diagnostic_context
*,
79 static void default_diagnostic_finalizer
PARAMS ((diagnostic_context
*,
82 static void error_recursion
PARAMS ((diagnostic_context
*)) ATTRIBUTE_NORETURN
;
83 static bool text_specifies_location
PARAMS ((text_info
*, location_t
*));
84 static void real_abort
PARAMS ((void)) ATTRIBUTE_NORETURN
;
86 extern int rtl_dump_and_exit
;
87 extern int warnings_are_errors
;
89 /* A diagnostic_context surrogate for stderr. */
90 static diagnostic_context global_diagnostic_context
;
91 diagnostic_context
*global_dc
= &global_diagnostic_context
;
94 /* Subroutine of output_set_maximum_length. Set up BUFFER's
95 internal maximum characters per line. */
97 set_real_maximum_length (buffer
)
98 output_buffer
*buffer
;
100 /* If we're told not to wrap lines then do the obvious thing. In case
101 we'll emit prefix only once per diagnostic message, it is appropriate
102 not to increase unnecessarily the line-length cut-off. */
103 if (!output_is_line_wrapping (buffer
)
104 || output_prefixing_rule (buffer
) == DIAGNOSTICS_SHOW_PREFIX_ONCE
105 || output_prefixing_rule (buffer
) == DIAGNOSTICS_SHOW_PREFIX_NEVER
)
106 line_wrap_cutoff (buffer
) = output_line_cutoff (buffer
);
109 int prefix_length
= buffer
->state
.prefix
?
110 strlen (buffer
->state
.prefix
) : 0;
111 /* If the prefix is ridiculously too long, output at least
113 if (output_line_cutoff (buffer
) - prefix_length
< 32)
114 line_wrap_cutoff (buffer
) = output_line_cutoff (buffer
) + 32;
116 line_wrap_cutoff (buffer
) = output_line_cutoff (buffer
);
120 /* Sets the number of maximum characters per line BUFFER can output
121 in line-wrapping mode. A LENGTH value 0 suppresses line-wrapping. */
123 output_set_maximum_length (buffer
, length
)
124 output_buffer
*buffer
;
127 output_line_cutoff (buffer
) = length
;
128 set_real_maximum_length (buffer
);
131 /* Sets BUFFER's PREFIX. */
133 output_set_prefix (buffer
, prefix
)
134 output_buffer
*buffer
;
137 buffer
->state
.prefix
= prefix
;
138 set_real_maximum_length (buffer
);
139 prefix_was_emitted_for (buffer
) = false;
140 output_indentation (buffer
) = 0;
143 /* Return a pointer to the last character emitted in the output
144 BUFFER area. A NULL pointer means no character available. */
146 output_last_position (buffer
)
147 const output_buffer
*buffer
;
149 const char *p
= NULL
;
151 if (obstack_base (&buffer
->obstack
) != obstack_next_free (&buffer
->obstack
))
152 p
= ((const char *) obstack_next_free (&buffer
->obstack
)) - 1;
156 /* Free BUFFER's prefix, a previously malloc'd string. */
158 output_destroy_prefix (buffer
)
159 output_buffer
*buffer
;
161 if (buffer
->state
.prefix
!= NULL
)
163 free ((char *) buffer
->state
.prefix
);
164 buffer
->state
.prefix
= NULL
;
168 /* Zero out any text output so far in BUFFER. */
170 output_clear_message_text (buffer
)
171 output_buffer
*buffer
;
173 obstack_free (&buffer
->obstack
, obstack_base (&buffer
->obstack
));
174 output_text_length (buffer
) = 0;
177 /* Zero out any formatting data used so far by BUFFER. */
179 output_clear_data (buffer
)
180 output_buffer
*buffer
;
182 prefix_was_emitted_for (buffer
) = false;
183 output_indentation (buffer
) = 0;
186 /* Construct an output BUFFER with PREFIX and of MAXIMUM_LENGTH
187 characters per line. */
189 init_output_buffer (buffer
, prefix
, maximum_length
)
190 output_buffer
*buffer
;
194 memset (buffer
, 0, sizeof (output_buffer
));
195 obstack_init (&buffer
->obstack
);
196 output_buffer_attached_stream (buffer
) = stderr
;
197 output_line_cutoff (buffer
) = maximum_length
;
198 output_prefixing_rule (buffer
) = diagnostic_prefixing_rule (global_dc
);
199 output_set_prefix (buffer
, prefix
);
200 output_text_length (buffer
) = 0;
201 output_clear_data (buffer
);
204 /* Reinitialize BUFFER. */
206 output_clear (buffer
)
207 output_buffer
*buffer
;
209 output_clear_message_text (buffer
);
210 output_clear_data (buffer
);
213 /* Finishes constructing a NULL-terminated character string representing
214 the BUFFERed message. */
216 output_finalize_message (buffer
)
217 output_buffer
*buffer
;
219 obstack_1grow (&buffer
->obstack
, '\0');
220 return output_message_text (buffer
);
223 /* Return the amount of characters BUFFER can accept to
226 output_space_left (buffer
)
227 const output_buffer
*buffer
;
229 return line_wrap_cutoff (buffer
) - output_text_length (buffer
);
232 /* Write out BUFFER's prefix. */
234 output_emit_prefix (buffer
)
235 output_buffer
*buffer
;
237 if (buffer
->state
.prefix
!= NULL
)
239 switch (output_prefixing_rule (buffer
))
242 case DIAGNOSTICS_SHOW_PREFIX_NEVER
:
245 case DIAGNOSTICS_SHOW_PREFIX_ONCE
:
246 if (prefix_was_emitted_for (buffer
))
248 output_indent (buffer
);
251 output_indentation (buffer
) += 3;
254 case DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE
:
256 int prefix_length
= strlen (buffer
->state
.prefix
);
257 output_append_r (buffer
, buffer
->state
.prefix
, prefix_length
);
258 prefix_was_emitted_for (buffer
) = true;
265 /* Have BUFFER start a new line. */
267 output_add_newline (buffer
)
268 output_buffer
*buffer
;
270 obstack_1grow (&buffer
->obstack
, '\n');
271 output_text_length (buffer
) = 0;
274 /* Appends a character to BUFFER. */
276 output_add_character (buffer
, c
)
277 output_buffer
*buffer
;
280 if (output_is_line_wrapping (buffer
) && output_space_left (buffer
) <= 0)
281 output_add_newline (buffer
);
282 obstack_1grow (&buffer
->obstack
, c
);
283 ++output_text_length (buffer
);
286 /* Adds a space to BUFFER. */
288 output_add_space (buffer
)
289 output_buffer
*buffer
;
291 if (output_is_line_wrapping (buffer
) && output_space_left (buffer
) <= 0)
293 output_add_newline (buffer
);
296 obstack_1grow (&buffer
->obstack
, ' ');
297 ++output_text_length (buffer
);
300 /* These functions format an INTEGER into BUFFER as suggested by their
303 output_decimal (buffer
, i
)
304 output_buffer
*buffer
;
307 output_formatted_scalar (buffer
, "%d", i
);
311 output_long_decimal (output_buffer
*buffer
, long int i
)
313 output_formatted_scalar (buffer
, "%ld", i
);
317 output_unsigned_decimal (output_buffer
*buffer
, unsigned int i
)
319 output_formatted_scalar (buffer
, "%u", i
);
323 output_long_unsigned_decimal (output_buffer
*buffer
, long unsigned int i
)
325 output_formatted_scalar (buffer
, "%lu", i
);
329 output_octal (output_buffer
*buffer
, unsigned int i
)
331 output_formatted_scalar (buffer
, "%o", i
);
335 output_long_octal (output_buffer
*buffer
, long unsigned int i
)
337 output_formatted_scalar (buffer
, "%lo", i
);
341 output_hexadecimal (output_buffer
*buffer
, unsigned int i
)
343 output_formatted_scalar (buffer
, "%x", i
);
347 output_long_hexadecimal (output_buffer
*buffer
, long unsigned int i
)
349 output_formatted_scalar (buffer
, "%lx", i
);
353 output_pointer (output_buffer
*buffer
, void *p
)
355 output_formatted_scalar (buffer
, HOST_PTR_PRINTF
, p
);
358 /* Append to BUFFER a string specified by its STARTING character
361 output_append_r (buffer
, start
, length
)
362 output_buffer
*buffer
;
366 obstack_grow (&buffer
->obstack
, start
, length
);
367 output_text_length (buffer
) += length
;
370 /* Append a string deliminated by START and END to BUFFER. No wrapping is
371 done. However, if beginning a new line then emit BUFFER->state.prefix
372 and skip any leading whitespace if appropriate. The caller must ensure
373 that it is safe to do so. */
375 output_append (buffer
, start
, end
)
376 output_buffer
*buffer
;
380 /* Emit prefix and skip whitespace if we're starting a new line. */
381 if (is_starting_newline (buffer
))
383 output_emit_prefix (buffer
);
384 if (output_is_line_wrapping (buffer
))
385 while (start
!= end
&& *start
== ' ')
388 output_append_r (buffer
, start
, end
- start
);
392 output_indent (buffer
)
393 output_buffer
*buffer
;
395 int n
= output_indentation (buffer
);
398 for (i
= 0; i
< n
; ++i
)
399 output_add_character (buffer
, ' ');
402 /* Wrap a text delimited by START and END into BUFFER. */
404 wrap_text (buffer
, start
, end
)
405 output_buffer
*buffer
;
409 bool is_wrapping
= output_is_line_wrapping (buffer
);
413 /* Dump anything bordered by whitespaces. */
415 const char *p
= start
;
416 while (p
!= end
&& *p
!= ' ' && *p
!= '\n')
418 if (is_wrapping
&& p
- start
>= output_space_left (buffer
))
419 output_add_newline (buffer
);
420 output_append (buffer
, start
, p
);
424 if (start
!= end
&& *start
== ' ')
426 output_add_space (buffer
);
429 if (start
!= end
&& *start
== '\n')
431 output_add_newline (buffer
);
437 /* Same as wrap_text but wrap text only when in line-wrapping mode. */
439 maybe_wrap_text (buffer
, start
, end
)
440 output_buffer
*buffer
;
444 if (output_is_line_wrapping (buffer
))
445 wrap_text (buffer
, start
, end
);
447 output_append (buffer
, start
, end
);
451 /* Append a STRING to BUFFER; the STRING might be line-wrapped if in
454 output_add_string (buffer
, str
)
455 output_buffer
*buffer
;
458 maybe_wrap_text (buffer
, str
, str
+ (str
? strlen (str
) : 0));
461 /* Append an identifier ID to BUFFER. */
463 output_add_identifier (buffer
, id
)
464 output_buffer
*buffer
;
467 output_append (buffer
, IDENTIFIER_POINTER (id
),
468 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
471 /* Flush the content of BUFFER onto the attached stream,
475 output_buffer_to_stream (buffer
)
476 output_buffer
*buffer
;
478 const char *text
= output_finalize_message (buffer
);
479 fputs (text
, output_buffer_attached_stream (buffer
));
480 output_clear_message_text (buffer
);
483 /* Format a message pointed to by TEXT. The following format specifiers are
484 recognized as being language independent:
485 %d, %i: (signed) integer in base ten.
486 %u: unsigned integer in base ten.
487 %o: unsigned integer in base eight.
488 %x: unsigned integer in base sixteen.
489 %ld, %li, %lo, %lu, %lx: long versions of the above.
494 %*.s: a substring the length of which is specified by an integer.
497 output_format (buffer
, text
)
498 output_buffer
*buffer
;
501 for (; *text
->format_spec
; ++text
->format_spec
)
503 bool long_integer
= 0;
507 const char *p
= text
->format_spec
;
508 while (*p
&& *p
!= '%')
510 wrap_text (buffer
, text
->format_spec
, p
);
511 text
->format_spec
= p
;
514 if (*text
->format_spec
== '\0')
517 /* We got a '%'. Let's see what happens. Record whether we're
518 parsing a long integer format specifier. */
519 if (*++text
->format_spec
== 'l')
525 /* Handle %c, %d, %i, %ld, %li, %lo, %lu, %lx, %o, %s, %u,
526 %x, %p, %.*s; %%. And nothing else. Front-ends should install
527 printers to grok language specific format specifiers. */
528 switch (*text
->format_spec
)
531 output_add_character (buffer
, va_arg (*text
->args_ptr
, int));
537 output_long_decimal (buffer
, va_arg (*text
->args_ptr
, long int));
539 output_decimal (buffer
, va_arg (*text
->args_ptr
, int));
544 output_long_octal (buffer
,
545 va_arg (*text
->args_ptr
, unsigned long int));
547 output_octal (buffer
, va_arg (*text
->args_ptr
, unsigned int));
551 output_add_string (buffer
, va_arg (*text
->args_ptr
, const char *));
555 output_pointer (buffer
, va_arg (*text
->args_ptr
, void *));
560 output_long_unsigned_decimal
561 (buffer
, va_arg (*text
->args_ptr
, long unsigned int));
563 output_unsigned_decimal
564 (buffer
, va_arg (*text
->args_ptr
, unsigned int));
569 output_long_hexadecimal
570 (buffer
, va_arg (*text
->args_ptr
, unsigned long int));
573 (buffer
, va_arg (*text
->args_ptr
, unsigned int));
577 output_add_character (buffer
, '%');
582 const location_t
*locus
= va_arg (*text
->args_ptr
, location_t
*);
583 output_add_string (buffer
, "file '");
584 output_add_string (buffer
, locus
->file
);
585 output_add_string (buffer
, "', line ");
586 output_decimal (buffer
, locus
->line
);
594 /* We handle no precision specifier but `%.*s'. */
595 if (*++text
->format_spec
!= '*')
597 else if (*++text
->format_spec
!= 's')
599 n
= va_arg (*text
->args_ptr
, int);
600 s
= va_arg (*text
->args_ptr
, const char *);
601 output_append (buffer
, s
, s
+ n
);
606 if (!buffer
->format_decoder
607 || !(*buffer
->format_decoder
) (buffer
, text
))
609 /* Hmmm. The front-end failed to install a format translator
610 but called us with an unrecognized format. Or, maybe, the
611 translated string just contains an invalid format, or
612 has formats in the wrong order. Sorry. */
620 vbuild_message_string (msg
, ap
)
626 vasprintf (&str
, msg
, ap
);
630 /* Return a malloc'd string containing MSG formatted a la
631 printf. The caller is responsible for freeing the memory. */
633 build_message_string
VPARAMS ((const char *msg
, ...))
638 VA_FIXEDARG (ap
, const char *, msg
);
640 str
= vbuild_message_string (msg
, ap
);
647 /* Same as diagnostic_build_prefix, but only the source FILE is given. */
649 file_name_as_prefix (f
)
652 return build_message_string ("%s: ", f
);
655 /* Format a message into BUFFER a la printf. */
657 output_printf
VPARAMS ((struct output_buffer
*buffer
, const char *msgid
, ...))
661 VA_FIXEDARG (ap
, output_buffer
*, buffer
);
662 VA_FIXEDARG (ap
, const char *, msgid
);
665 text
.format_spec
= _(msgid
);
666 output_format (buffer
, &text
);
670 /* Print a message relevant to the given DECL. */
672 format_with_decl (buffer
, text
, decl
)
673 output_buffer
*buffer
;
679 /* Do magic to get around lack of varargs support for insertion
680 of arguments into existing list. We know that the decl is first;
681 we ass_u_me that it will be printed with "%s". */
682 for (p
= text
->format_spec
; *p
; ++p
)
688 else if (*(p
+ 1) != 's')
695 /* Print the left-hand substring. */
696 maybe_wrap_text (buffer
, text
->format_spec
, p
);
698 if (*p
== '%') /* Print the name. */
700 const char *const n
= (DECL_NAME (decl
)
701 ? (*lang_hooks
.decl_printable_name
) (decl
, 2)
702 : _("((anonymous))"));
703 output_add_string (buffer
, n
);
707 if (ISALPHA (*(p
- 1) & 0xFF))
712 if (*p
) /* Print the rest of the message. */
714 text
->format_spec
= p
;
715 output_format (buffer
, text
);
719 /* Flush the content of BUFFER onto the attached stream. */
721 output_flush (buffer
)
722 output_buffer
*buffer
;
724 output_buffer_to_stream (buffer
);
725 output_clear_data (buffer
);
726 fputc ('\n', output_buffer_attached_stream (buffer
));
727 fflush (output_buffer_attached_stream (buffer
));
730 /* Helper subroutine of output_verbatim and verbatim. Do the appropriate
731 settings needed by BUFFER for a verbatim formatting. */
733 output_do_verbatim (buffer
, text
)
734 output_buffer
*buffer
;
737 diagnostic_prefixing_rule_t rule
= output_prefixing_rule (buffer
);
738 int line_cutoff
= output_line_cutoff (buffer
);
740 /* Set verbatim mode. */
741 output_prefixing_rule (buffer
) = DIAGNOSTICS_SHOW_PREFIX_NEVER
;
742 output_line_cutoff (buffer
) = 0;
743 /* Do the actual formatting. */
744 output_format (buffer
, text
);
745 /* Restore previous settings. */
746 output_prefixing_rule (buffer
) = rule
;
747 output_line_cutoff (buffer
) = line_cutoff
;
750 /* Output MESSAGE verbatim into BUFFER. */
752 output_verbatim
VPARAMS ((output_buffer
*buffer
, const char *msgid
, ...))
756 VA_FIXEDARG (ap
, output_buffer
*, buffer
);
757 VA_FIXEDARG (ap
, const char *, msgid
);
759 text
.format_spec
= msgid
;
761 output_do_verbatim (buffer
, &text
);
766 /* Initialize the diagnostic message outputting machinery. */
768 diagnostic_initialize (context
)
769 diagnostic_context
*context
;
771 memset (context
, 0, sizeof *context
);
772 obstack_init (&context
->buffer
.obstack
);
774 /* By default, diagnostics are sent to stderr. */
775 output_buffer_attached_stream (&context
->buffer
) = stderr
;
777 /* By default, we emit prefixes once per message. */
778 diagnostic_prefixing_rule (context
) = DIAGNOSTICS_SHOW_PREFIX_ONCE
;
780 diagnostic_starter (context
) = default_diagnostic_starter
;
781 diagnostic_finalizer (context
) = default_diagnostic_finalizer
;
782 context
->warnings_are_errors_message
= warnings_are_errors
;
785 /* Returns true if the next format specifier in TEXT is a format specifier
786 for a location_t. If so, update the object pointed by LOCUS to reflect
787 the specified location in *TEXT->args_ptr. */
789 text_specifies_location (text
, locus
)
794 /* Skip any leading text. */
795 for (p
= text
->format_spec
; *p
&& *p
!= '%'; ++p
)
798 /* Extract the location information if any. */
799 if (*p
== '%' && *++p
== 'H')
801 *locus
= *va_arg (*text
->args_ptr
, location_t
*);
802 text
->format_spec
= p
+ 1;
810 diagnostic_set_info (diagnostic
, msgid
, args
, file
, line
, kind
)
811 diagnostic_info
*diagnostic
;
818 diagnostic
->message
.format_spec
= msgid
;
819 diagnostic
->message
.args_ptr
= args
;
820 /* If the diagnostic message doesn't specify a location,
821 use FILE and LINE. */
822 if (!text_specifies_location (&diagnostic
->message
, &diagnostic
->location
))
824 diagnostic
->location
.file
= file
;
825 diagnostic
->location
.line
= line
;
827 diagnostic
->kind
= kind
;
830 /* Return a malloc'd string describing a location. The caller is
831 responsible for freeing the memory. */
833 diagnostic_build_prefix (diagnostic
)
834 diagnostic_info
*diagnostic
;
836 static const char *const diagnostic_kind_text
[] = {
837 #define DEFINE_DIAGNOSTIC_KIND(K, T) (T),
838 #include "diagnostic.def"
839 #undef DEFINE_DIAGNOSTIC_KIND
842 if (diagnostic
->kind
>= DK_LAST_DIAGNOSTIC_KIND
)
845 return diagnostic
->location
.file
846 ? build_message_string ("%s:%d: %s",
847 diagnostic
->location
.file
,
848 diagnostic
->location
.line
,
849 _(diagnostic_kind_text
[diagnostic
->kind
]))
850 : build_message_string ("%s: %s", progname
,
851 _(diagnostic_kind_text
[diagnostic
->kind
]));
854 /* Report a diagnostic MESSAGE at the declaration DECL.
855 MSG is a format string which uses %s to substitute the declaration
856 name; subsequent substitutions are a la output_format. */
858 diagnostic_for_decl (diagnostic
, decl
)
859 diagnostic_info
*diagnostic
;
862 if (global_dc
->lock
++)
863 error_recursion (global_dc
);
865 if (diagnostic_count_diagnostic (global_dc
, diagnostic
->kind
))
867 diagnostic_report_current_function (global_dc
);
869 (&global_dc
->buffer
, diagnostic_build_prefix (diagnostic
));
870 format_with_decl (&global_dc
->buffer
, &diagnostic
->message
, decl
);
871 output_flush (&global_dc
->buffer
);
872 output_destroy_prefix (&global_dc
->buffer
);
878 diagnostic_flush_buffer (context
)
879 diagnostic_context
*context
;
881 output_buffer_to_stream (&context
->buffer
);
882 fflush (output_buffer_attached_stream (&context
->buffer
));
885 /* Count a diagnostic. Return true if the message should be printed. */
887 diagnostic_count_diagnostic (context
, kind
)
888 diagnostic_context
*context
;
897 case DK_FATAL
: case DK_ICE
: case DK_SORRY
:
898 case DK_ANACHRONISM
: case DK_NOTE
:
899 ++diagnostic_kind_count (context
, kind
);
903 if (!diagnostic_report_warnings_p ())
905 else if (!warnings_are_errors
)
907 ++diagnostic_kind_count (context
, DK_WARNING
);
910 /* else fall through. */
913 if (kind
== DK_WARNING
&& context
->warnings_are_errors_message
)
915 output_verbatim (&context
->buffer
,
916 "%s: warnings being treated as errors\n", progname
);
917 context
->warnings_are_errors_message
= false;
919 ++diagnostic_kind_count (context
, DK_ERROR
);
926 /* Print a diagnostic MSGID on FILE. This is just fprintf, except it
927 runs its second argument through gettext. */
929 fnotice
VPARAMS ((FILE *file
, const char *msgid
, ...))
932 VA_FIXEDARG (ap
, FILE *, file
);
933 VA_FIXEDARG (ap
, const char *, msgid
);
935 vfprintf (file
, _(msgid
), ap
);
940 /* Print a fatal I/O error message. Argument are like printf.
941 Also include a system error message based on `errno'. */
943 fatal_io_error
VPARAMS ((const char *msgid
, ...))
947 VA_FIXEDARG (ap
, const char *, msgid
);
949 text
.format_spec
= _(msgid
);
951 output_printf (&global_dc
->buffer
, "%s: %s: ", progname
, xstrerror (errno
));
952 output_format (&global_dc
->buffer
, &text
);
953 output_flush (&global_dc
->buffer
);
955 exit (FATAL_EXIT_CODE
);
958 /* Issue a pedantic warning MSGID. */
960 pedwarn
VPARAMS ((const char *msgid
, ...))
962 diagnostic_info diagnostic
;
964 VA_FIXEDARG (ap
, const char *, msgid
);
966 diagnostic_set_info (&diagnostic
, _(msgid
), &ap
, input_filename
, input_line
,
967 pedantic_error_kind ());
968 report_diagnostic (&diagnostic
);
972 /* Issue a pedantic warning about DECL. */
974 pedwarn_with_decl
VPARAMS ((tree decl
, const char *msgid
, ...))
976 diagnostic_info diagnostic
;
978 VA_FIXEDARG (ap
, tree
, decl
);
979 VA_FIXEDARG (ap
, const char *, msgid
);
981 diagnostic_set_info (&diagnostic
, _(msgid
), &ap
,
982 DECL_SOURCE_FILE (decl
), DECL_SOURCE_LINE (decl
),
983 pedantic_error_kind ());
985 /* We don't want -pedantic-errors to cause the compilation to fail from
986 "errors" in system header files. Sometimes fixincludes can't fix what's
987 broken (eg: unsigned char bitfields - fixing it may change the alignment
988 which will cause programs to mysteriously fail because the C library
989 or kernel uses the original layout). There's no point in issuing a
990 warning either, it's just unnecessary noise. */
991 if (!DECL_IN_SYSTEM_HEADER (decl
))
992 diagnostic_for_decl (&diagnostic
, decl
);
996 /* Same as above but within the context FILE and LINE. */
998 pedwarn_with_file_and_line
VPARAMS ((const char *file
, int line
,
999 const char *msgid
, ...))
1001 diagnostic_info diagnostic
;
1002 VA_OPEN (ap
, msgid
);
1003 VA_FIXEDARG (ap
, const char *, file
);
1004 VA_FIXEDARG (ap
, int, line
);
1005 VA_FIXEDARG (ap
, const char *, msgid
);
1007 diagnostic_set_info (&diagnostic
, _(msgid
), &ap
, file
, line
,
1008 pedantic_error_kind ());
1009 report_diagnostic (&diagnostic
);
1013 /* Just apologize with MSGID. */
1015 sorry
VPARAMS ((const char *msgid
, ...))
1017 diagnostic_info diagnostic
;
1019 VA_OPEN (ap
, msgid
);
1020 VA_FIXEDARG (ap
, const char *, msgid
);
1023 diagnostic_set_info (&diagnostic
, _(msgid
), &ap
,
1024 input_filename
, input_line
, DK_SORRY
);
1027 (&global_dc
->buffer
, diagnostic_build_prefix (&diagnostic
));
1028 output_format (&global_dc
->buffer
, &diagnostic
.message
);
1029 output_flush (&global_dc
->buffer
);
1033 /* Called when the start of a function definition is parsed,
1034 this function prints on stderr the name of the function. */
1036 announce_function (decl
)
1041 if (rtl_dump_and_exit
)
1042 verbatim ("%s ", IDENTIFIER_POINTER (DECL_NAME (decl
)));
1044 verbatim (" %s", (*lang_hooks
.decl_printable_name
) (decl
, 2));
1046 output_needs_newline (&global_dc
->buffer
) = true;
1047 diagnostic_set_last_function (global_dc
);
1051 /* The default function to print out name of current function that caused
1054 lhd_print_error_function (context
, file
)
1055 diagnostic_context
*context
;
1058 if (diagnostic_last_function_changed (context
))
1060 const char *old_prefix
= output_prefix (&context
->buffer
);
1061 char *new_prefix
= file
? build_message_string ("%s: ", file
) : NULL
;
1063 output_set_prefix (&context
->buffer
, new_prefix
);
1065 if (current_function_decl
== NULL
)
1066 output_add_string (&context
->buffer
, _("At top level:"));
1069 if (TREE_CODE (TREE_TYPE (current_function_decl
)) == METHOD_TYPE
)
1071 (&context
->buffer
, "In member function `%s':",
1072 (*lang_hooks
.decl_printable_name
) (current_function_decl
, 2));
1075 (&context
->buffer
, "In function `%s':",
1076 (*lang_hooks
.decl_printable_name
) (current_function_decl
, 2));
1078 output_add_newline (&context
->buffer
);
1080 diagnostic_set_last_function (context
);
1081 output_buffer_to_stream (&context
->buffer
);
1082 context
->buffer
.state
.prefix
= old_prefix
;
1083 free ((char*) new_prefix
);
1087 /* Prints out, if necessary, the name of the current function
1088 that caused an error. Called from all error and warning functions.
1089 We ignore the FILE parameter, as it cannot be relied upon. */
1092 diagnostic_report_current_function (context
)
1093 diagnostic_context
*context
;
1095 diagnostic_report_current_module (context
);
1096 (*lang_hooks
.print_error_function
) (context
, input_filename
);
1100 error_with_file_and_line
VPARAMS ((const char *file
, int line
,
1101 const char *msgid
, ...))
1103 diagnostic_info diagnostic
;
1105 VA_OPEN (ap
, msgid
);
1106 VA_FIXEDARG (ap
, const char *, file
);
1107 VA_FIXEDARG (ap
, int, line
);
1108 VA_FIXEDARG (ap
, const char *, msgid
);
1110 diagnostic_set_info (&diagnostic
, msgid
, &ap
, file
, line
, DK_ERROR
);
1111 report_diagnostic (&diagnostic
);
1116 error_with_decl
VPARAMS ((tree decl
, const char *msgid
, ...))
1118 diagnostic_info diagnostic
;
1119 VA_OPEN (ap
, msgid
);
1120 VA_FIXEDARG (ap
, tree
, decl
);
1121 VA_FIXEDARG (ap
, const char *, msgid
);
1123 diagnostic_set_info (&diagnostic
, msgid
, &ap
,
1124 DECL_SOURCE_FILE (decl
), DECL_SOURCE_LINE (decl
),
1126 diagnostic_for_decl (&diagnostic
, decl
);
1131 /* Report an error message. The arguments are like that of printf. */
1134 error
VPARAMS ((const char *msgid
, ...))
1136 diagnostic_info diagnostic
;
1138 VA_OPEN (ap
, msgid
);
1139 VA_FIXEDARG (ap
, const char *, msgid
);
1141 diagnostic_set_info (&diagnostic
, msgid
, &ap
, input_filename
, input_line
,
1143 report_diagnostic (&diagnostic
);
1147 /* Likewise, except that the compilation is terminated after printing the
1151 fatal_error
VPARAMS ((const char *msgid
, ...))
1153 diagnostic_info diagnostic
;
1155 VA_OPEN (ap
, msgid
);
1156 VA_FIXEDARG (ap
, const char *, msgid
);
1158 diagnostic_set_info (&diagnostic
, msgid
, &ap
, input_filename
, input_line
,
1160 report_diagnostic (&diagnostic
);
1163 fnotice (stderr
, "compilation terminated.\n");
1164 exit (FATAL_EXIT_CODE
);
1168 internal_error
VPARAMS ((const char *msgid
, ...))
1170 diagnostic_info diagnostic
;
1172 VA_OPEN (ap
, msgid
);
1173 VA_FIXEDARG (ap
, const char *, msgid
);
1175 if (global_dc
->lock
)
1176 error_recursion (global_dc
);
1178 #ifndef ENABLE_CHECKING
1179 if (errorcount
> 0 || sorrycount
> 0)
1181 fnotice (stderr
, "%s:%d: confused by earlier errors, bailing out\n",
1182 input_filename
, input_line
);
1183 exit (FATAL_EXIT_CODE
);
1187 if (global_dc
->internal_error
!= 0)
1188 (*global_dc
->internal_error
) (_(msgid
), &ap
);
1190 diagnostic_set_info (&diagnostic
, msgid
, &ap
, input_filename
, input_line
,
1192 report_diagnostic (&diagnostic
);
1196 "Please submit a full bug report,\n\
1197 with preprocessed source if appropriate.\n\
1198 See %s for instructions.\n", bug_report_url
);
1199 exit (FATAL_EXIT_CODE
);
1203 warning_with_file_and_line
VPARAMS ((const char *file
, int line
,
1204 const char *msgid
, ...))
1206 diagnostic_info diagnostic
;
1208 VA_OPEN (ap
, msgid
);
1209 VA_FIXEDARG (ap
, const char *, file
);
1210 VA_FIXEDARG (ap
, int, line
);
1211 VA_FIXEDARG (ap
, const char *, msgid
);
1213 diagnostic_set_info (&diagnostic
, msgid
, &ap
, file
, line
, DK_WARNING
);
1214 report_diagnostic (&diagnostic
);
1219 warning_with_decl
VPARAMS ((tree decl
, const char *msgid
, ...))
1221 diagnostic_info diagnostic
;
1222 VA_OPEN (ap
, msgid
);
1223 VA_FIXEDARG (ap
, tree
, decl
);
1224 VA_FIXEDARG (ap
, const char *, msgid
);
1226 diagnostic_set_info (&diagnostic
, msgid
, &ap
,
1227 DECL_SOURCE_FILE (decl
), DECL_SOURCE_LINE (decl
),
1229 diagnostic_for_decl (&diagnostic
, decl
);
1234 warning
VPARAMS ((const char *msgid
, ...))
1236 diagnostic_info diagnostic
;
1238 VA_OPEN (ap
, msgid
);
1239 VA_FIXEDARG (ap
, const char *, msgid
);
1241 diagnostic_set_info (&diagnostic
, msgid
, &ap
, input_filename
, input_line
,
1243 report_diagnostic (&diagnostic
);
1248 /* Same as above but use diagnostic_buffer. */
1251 verbatim
VPARAMS ((const char *msgid
, ...))
1254 VA_OPEN (ap
, msgid
);
1255 VA_FIXEDARG (ap
, const char *, msgid
);
1257 text
.format_spec
= _(msgid
);
1258 text
.args_ptr
= &ap
;
1259 output_do_verbatim (&global_dc
->buffer
, &text
);
1260 output_buffer_to_stream (&global_dc
->buffer
);
1264 /* Report a diagnostic message (an error or a warning) as specified by
1265 DC. This function is *the* subroutine in terms of which front-ends
1266 should implement their specific diagnostic handling modules. The
1267 front-end independent format specifiers are exactly those described
1268 in the documentation of output_format. */
1271 diagnostic_report_diagnostic (context
, diagnostic
)
1272 diagnostic_context
*context
;
1273 diagnostic_info
*diagnostic
;
1275 if (context
->lock
++)
1276 error_recursion (context
);
1278 if (diagnostic_count_diagnostic (context
, diagnostic
->kind
))
1280 (*diagnostic_starter (context
)) (context
, diagnostic
);
1281 output_format (&context
->buffer
, &diagnostic
->message
);
1282 (*diagnostic_finalizer (context
)) (context
, diagnostic
);
1283 output_flush (&context
->buffer
);
1286 if (context
->abort_on_error
&& diagnostic
->kind
<= DK_ERROR
)
1291 /* Inform the user that an error occurred while trying to report some
1292 other error. This indicates catastrophic internal inconsistencies,
1293 so give up now. But do try to flush out the previous error.
1294 This mustn't use internal_error, that will cause infinite recursion. */
1297 error_recursion (context
)
1298 diagnostic_context
*context
;
1300 if (context
->lock
< 3)
1301 output_flush (&context
->buffer
);
1304 "Internal compiler error: Error reporting routines re-entered.\n");
1306 "Please submit a full bug report,\n\
1307 with preprocessed source if appropriate.\n\
1308 See %s for instructions.\n", bug_report_url
);
1309 exit (FATAL_EXIT_CODE
);
1312 /* Given a partial pathname as input, return another pathname that
1313 shares no directory elements with the pathname of __FILE__. This
1314 is used by fancy_abort() to print `Internal compiler error in expr.c'
1315 instead of `Internal compiler error in ../../GCC/gcc/expr.c'. */
1318 trim_filename (name
)
1321 static const char this_file
[] = __FILE__
;
1322 const char *p
= name
, *q
= this_file
;
1324 /* First skip any "../" in each filename. This allows us to give a proper
1325 reference to a file in a subdirectory. */
1326 while (p
[0] == '.' && p
[1] == '.'
1327 && (p
[2] == DIR_SEPARATOR
1328 #ifdef DIR_SEPARATOR_2
1329 || p
[2] == DIR_SEPARATOR_2
1334 while (q
[0] == '.' && q
[1] == '.'
1335 && (q
[2] == DIR_SEPARATOR
1336 #ifdef DIR_SEPARATOR_2
1337 || p
[2] == DIR_SEPARATOR_2
1342 /* Now skip any parts the two filenames have in common. */
1343 while (*p
== *q
&& *p
!= 0 && *q
!= 0)
1346 /* Now go backwards until the previous directory separator. */
1347 while (p
> name
&& p
[-1] != DIR_SEPARATOR
1348 #ifdef DIR_SEPARATOR_2
1349 && p
[-1] != DIR_SEPARATOR_2
1357 /* Report an internal compiler error in a friendly manner and without
1361 fancy_abort (file
, line
, function
)
1364 const char *function
;
1366 internal_error ("in %s, at %s:%d", function
, trim_filename (file
), line
);
1370 diagnostic_report_current_module (context
)
1371 diagnostic_context
*context
;
1373 struct file_stack
*p
;
1375 if (output_needs_newline (&context
->buffer
))
1377 output_add_newline (&context
->buffer
);
1378 output_needs_newline (&context
->buffer
) = false;
1381 if (input_file_stack
&& input_file_stack
->next
!= 0
1382 && diagnostic_last_module_changed (context
))
1384 for (p
= input_file_stack
->next
; p
; p
= p
->next
)
1385 if (p
== input_file_stack
->next
)
1386 output_verbatim (&context
->buffer
,
1387 "In file included from %s:%d",
1388 p
->location
.file
, p
->location
.line
);
1390 output_verbatim (&context
->buffer
,
1392 p
->location
.file
, p
->location
.line
);
1393 output_verbatim (&context
->buffer
, ":\n");
1394 diagnostic_set_last_module (context
);
1399 default_diagnostic_starter (context
, diagnostic
)
1400 diagnostic_context
*context
;
1401 diagnostic_info
*diagnostic
;
1403 diagnostic_report_current_function (context
);
1404 output_set_prefix (&context
->buffer
, diagnostic_build_prefix (diagnostic
));
1408 default_diagnostic_finalizer (context
, diagnostic
)
1409 diagnostic_context
*context
;
1410 diagnostic_info
*diagnostic
__attribute__((unused
));
1412 output_destroy_prefix (&context
->buffer
);
1416 inform
VPARAMS ((const char *msgid
, ...))
1418 diagnostic_info diagnostic
;
1420 VA_OPEN (ap
, msgid
);
1421 VA_FIXEDARG (ap
, const char *, msgid
);
1423 diagnostic_set_info (&diagnostic
, msgid
, &ap
, input_filename
, input_line
,
1425 report_diagnostic (&diagnostic
);
1430 warn_deprecated_use (node
)
1433 if (node
== 0 || !warn_deprecated_decl
)
1437 warning ("`%s' is deprecated (declared at %s:%d)",
1438 IDENTIFIER_POINTER (DECL_NAME (node
)),
1439 DECL_SOURCE_FILE (node
), DECL_SOURCE_LINE (node
));
1440 else if (TYPE_P (node
))
1442 const char *what
= NULL
;
1443 tree decl
= TYPE_STUB_DECL (node
);
1445 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
1446 what
= IDENTIFIER_POINTER (TYPE_NAME (node
));
1447 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
1448 && DECL_NAME (TYPE_NAME (node
)))
1449 what
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node
)));
1454 warning ("`%s' is deprecated (declared at %s:%d)", what
,
1455 DECL_SOURCE_FILE (decl
), DECL_SOURCE_LINE (decl
));
1457 warning ("`%s' is deprecated", what
);
1460 warning ("type is deprecated (declared at %s:%d)",
1461 DECL_SOURCE_FILE (decl
), DECL_SOURCE_LINE (decl
));
1463 warning ("type is deprecated");
1467 /* Really call the system 'abort'. This has to go right at the end of
1468 this file, so that there are no functions after it that call abort
1469 and get the system abort instead of our macro. */