PR c++/85952
[official-gcc.git] / gcc / diagnostic.c
blobe22c17bc02cf8b105416eea60981d5b9e4f77f7c
1 /* Language-independent diagnostic subroutines for the GNU Compiler Collection
2 Copyright (C) 1999-2018 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 3, or (at your option) any later
10 version.
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.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* This file implements the language independent aspect of diagnostic
23 message module. */
25 #include "config.h"
26 #include "system.h"
27 #include "coretypes.h"
28 #include "version.h"
29 #include "demangle.h"
30 #include "intl.h"
31 #include "backtrace.h"
32 #include "diagnostic.h"
33 #include "diagnostic-color.h"
34 #include "edit-context.h"
35 #include "selftest.h"
36 #include "selftest-diagnostic.h"
38 #ifdef HAVE_TERMIOS_H
39 # include <termios.h>
40 #endif
42 #ifdef GWINSZ_IN_SYS_IOCTL
43 # include <sys/ioctl.h>
44 #endif
46 #define pedantic_warning_kind(DC) \
47 ((DC)->pedantic_errors ? DK_ERROR : DK_WARNING)
48 #define permissive_error_kind(DC) ((DC)->permissive ? DK_WARNING : DK_ERROR)
49 #define permissive_error_option(DC) ((DC)->opt_permissive)
51 /* Prototypes. */
52 static bool diagnostic_impl (rich_location *, int, const char *,
53 va_list *, diagnostic_t) ATTRIBUTE_GCC_DIAG(3,0);
54 static bool diagnostic_n_impl (rich_location *, int, unsigned HOST_WIDE_INT,
55 const char *, const char *, va_list *,
56 diagnostic_t) ATTRIBUTE_GCC_DIAG(5,0);
58 static void error_recursion (diagnostic_context *) ATTRIBUTE_NORETURN;
59 static void real_abort (void) ATTRIBUTE_NORETURN;
61 /* Name of program invoked, sans directories. */
63 const char *progname;
65 /* A diagnostic_context surrogate for stderr. */
66 static diagnostic_context global_diagnostic_context;
67 diagnostic_context *global_dc = &global_diagnostic_context;
69 /* Return a malloc'd string containing MSG formatted a la printf. The
70 caller is responsible for freeing the memory. */
71 char *
72 build_message_string (const char *msg, ...)
74 char *str;
75 va_list ap;
77 va_start (ap, msg);
78 str = xvasprintf (msg, ap);
79 va_end (ap);
81 return str;
84 /* Same as diagnostic_build_prefix, but only the source FILE is given. */
85 char *
86 file_name_as_prefix (diagnostic_context *context, const char *f)
88 const char *locus_cs
89 = colorize_start (pp_show_color (context->printer), "locus");
90 const char *locus_ce = colorize_stop (pp_show_color (context->printer));
91 return build_message_string ("%s%s:%s ", locus_cs, f, locus_ce);
96 /* Return the value of the getenv("COLUMNS") as an integer. If the
97 value is not set to a positive integer, use ioctl to get the
98 terminal width. If it fails, return INT_MAX. */
99 int
100 get_terminal_width (void)
102 const char * s = getenv ("COLUMNS");
103 if (s != NULL) {
104 int n = atoi (s);
105 if (n > 0)
106 return n;
109 #ifdef TIOCGWINSZ
110 struct winsize w;
111 w.ws_col = 0;
112 if (ioctl (0, TIOCGWINSZ, &w) == 0 && w.ws_col > 0)
113 return w.ws_col;
114 #endif
116 return INT_MAX;
119 /* Set caret_max_width to value. */
120 void
121 diagnostic_set_caret_max_width (diagnostic_context *context, int value)
123 /* One minus to account for the leading empty space. */
124 value = value ? value - 1
125 : (isatty (fileno (pp_buffer (context->printer)->stream))
126 ? get_terminal_width () - 1: INT_MAX);
128 if (value <= 0)
129 value = INT_MAX;
131 context->caret_max_width = value;
134 /* Initialize the diagnostic message outputting machinery. */
135 void
136 diagnostic_initialize (diagnostic_context *context, int n_opts)
138 int i;
140 /* Allocate a basic pretty-printer. Clients will replace this a
141 much more elaborated pretty-printer if they wish. */
142 context->printer = XNEW (pretty_printer);
143 new (context->printer) pretty_printer ();
145 memset (context->diagnostic_count, 0, sizeof context->diagnostic_count);
146 context->warning_as_error_requested = false;
147 context->n_opts = n_opts;
148 context->classify_diagnostic = XNEWVEC (diagnostic_t, n_opts);
149 for (i = 0; i < n_opts; i++)
150 context->classify_diagnostic[i] = DK_UNSPECIFIED;
151 context->show_caret = false;
152 diagnostic_set_caret_max_width (context, pp_line_cutoff (context->printer));
153 for (i = 0; i < rich_location::STATICALLY_ALLOCATED_RANGES; i++)
154 context->caret_chars[i] = '^';
155 context->show_option_requested = false;
156 context->abort_on_error = false;
157 context->show_column = false;
158 context->pedantic_errors = false;
159 context->permissive = false;
160 context->opt_permissive = 0;
161 context->fatal_errors = false;
162 context->dc_inhibit_warnings = false;
163 context->dc_warn_system_headers = false;
164 context->max_errors = 0;
165 context->internal_error = NULL;
166 diagnostic_starter (context) = default_diagnostic_starter;
167 context->start_span = default_diagnostic_start_span_fn;
168 diagnostic_finalizer (context) = default_diagnostic_finalizer;
169 context->option_enabled = NULL;
170 context->option_state = NULL;
171 context->option_name = NULL;
172 context->last_location = UNKNOWN_LOCATION;
173 context->last_module = 0;
174 context->x_data = NULL;
175 context->lock = 0;
176 context->inhibit_notes_p = false;
177 context->colorize_source_p = false;
178 context->show_ruler_p = false;
179 context->parseable_fixits_p = false;
180 context->edit_context_ptr = NULL;
183 /* Maybe initialize the color support. We require clients to do this
184 explicitly, since most clients don't want color. When called
185 without a VALUE, it initializes with DIAGNOSTICS_COLOR_DEFAULT. */
187 void
188 diagnostic_color_init (diagnostic_context *context, int value /*= -1 */)
190 /* value == -1 is the default value. */
191 if (value < 0)
193 /* If DIAGNOSTICS_COLOR_DEFAULT is -1, default to
194 -fdiagnostics-color=auto if GCC_COLORS is in the environment,
195 otherwise default to -fdiagnostics-color=never, for other
196 values default to that
197 -fdiagnostics-color={never,auto,always}. */
198 if (DIAGNOSTICS_COLOR_DEFAULT == -1)
200 if (!getenv ("GCC_COLORS"))
201 return;
202 value = DIAGNOSTICS_COLOR_AUTO;
204 else
205 value = DIAGNOSTICS_COLOR_DEFAULT;
207 pp_show_color (context->printer)
208 = colorize_init ((diagnostic_color_rule_t) value);
211 /* Do any cleaning up required after the last diagnostic is emitted. */
213 void
214 diagnostic_finish (diagnostic_context *context)
216 /* Some of the errors may actually have been warnings. */
217 if (diagnostic_kind_count (context, DK_WERROR))
219 /* -Werror was given. */
220 if (context->warning_as_error_requested)
221 pp_verbatim (context->printer,
222 _("%s: all warnings being treated as errors"),
223 progname);
224 /* At least one -Werror= was given. */
225 else
226 pp_verbatim (context->printer,
227 _("%s: some warnings being treated as errors"),
228 progname);
229 pp_newline_and_flush (context->printer);
232 diagnostic_file_cache_fini ();
234 XDELETEVEC (context->classify_diagnostic);
235 context->classify_diagnostic = NULL;
237 /* diagnostic_initialize allocates context->printer using XNEW
238 and placement-new. */
239 context->printer->~pretty_printer ();
240 XDELETE (context->printer);
241 context->printer = NULL;
243 if (context->edit_context_ptr)
245 delete context->edit_context_ptr;
246 context->edit_context_ptr = NULL;
250 /* Initialize DIAGNOSTIC, where the message MSG has already been
251 translated. */
252 void
253 diagnostic_set_info_translated (diagnostic_info *diagnostic, const char *msg,
254 va_list *args, rich_location *richloc,
255 diagnostic_t kind)
257 gcc_assert (richloc);
258 diagnostic->message.err_no = errno;
259 diagnostic->message.args_ptr = args;
260 diagnostic->message.format_spec = msg;
261 diagnostic->message.m_richloc = richloc;
262 diagnostic->richloc = richloc;
263 diagnostic->kind = kind;
264 diagnostic->option_index = 0;
267 /* Initialize DIAGNOSTIC, where the message GMSGID has not yet been
268 translated. */
269 void
270 diagnostic_set_info (diagnostic_info *diagnostic, const char *gmsgid,
271 va_list *args, rich_location *richloc,
272 diagnostic_t kind)
274 gcc_assert (richloc);
275 diagnostic_set_info_translated (diagnostic, _(gmsgid), args, richloc, kind);
278 static const char *const diagnostic_kind_color[] = {
279 #define DEFINE_DIAGNOSTIC_KIND(K, T, C) (C),
280 #include "diagnostic.def"
281 #undef DEFINE_DIAGNOSTIC_KIND
282 NULL
285 /* Get a color name for diagnostics of type KIND
286 Result could be NULL. */
288 const char *
289 diagnostic_get_color_for_kind (diagnostic_t kind)
291 return diagnostic_kind_color[kind];
294 /* Return a formatted line and column ':%line:%column'. Elided if
295 zero. The result is a statically allocated buffer. */
297 static const char *
298 maybe_line_and_column (int line, int col)
300 static char result[32];
302 if (line)
304 size_t l = snprintf (result, sizeof (result),
305 col ? ":%d:%d" : ":%d", line, col);
306 gcc_checking_assert (l < sizeof (result));
308 else
309 result[0] = 0;
310 return result;
313 /* Return a malloc'd string describing a location e.g. "foo.c:42:10".
314 The caller is responsible for freeing the memory. */
316 static char *
317 diagnostic_get_location_text (diagnostic_context *context,
318 expanded_location s)
320 pretty_printer *pp = context->printer;
321 const char *locus_cs = colorize_start (pp_show_color (pp), "locus");
322 const char *locus_ce = colorize_stop (pp_show_color (pp));
323 const char *file = s.file ? s.file : progname;
324 int line = strcmp (file, N_("<built-in>")) ? s.line : 0;
325 int col = context->show_column ? s.column : 0;
327 const char *line_col = maybe_line_and_column (line, col);
328 return build_message_string ("%s%s%s:%s", locus_cs, file,
329 line_col, locus_ce);
332 /* Return a malloc'd string describing a location and the severity of the
333 diagnostic, e.g. "foo.c:42:10: error: ". The caller is responsible for
334 freeing the memory. */
335 char *
336 diagnostic_build_prefix (diagnostic_context *context,
337 const diagnostic_info *diagnostic)
339 static const char *const diagnostic_kind_text[] = {
340 #define DEFINE_DIAGNOSTIC_KIND(K, T, C) (T),
341 #include "diagnostic.def"
342 #undef DEFINE_DIAGNOSTIC_KIND
343 "must-not-happen"
345 gcc_assert (diagnostic->kind < DK_LAST_DIAGNOSTIC_KIND);
347 const char *text = _(diagnostic_kind_text[diagnostic->kind]);
348 const char *text_cs = "", *text_ce = "";
349 pretty_printer *pp = context->printer;
351 if (diagnostic_kind_color[diagnostic->kind])
353 text_cs = colorize_start (pp_show_color (pp),
354 diagnostic_kind_color[diagnostic->kind]);
355 text_ce = colorize_stop (pp_show_color (pp));
358 expanded_location s = diagnostic_expand_location (diagnostic);
359 char *location_text = diagnostic_get_location_text (context, s);
361 char *result = build_message_string ("%s %s%s%s", location_text,
362 text_cs, text, text_ce);
363 free (location_text);
364 return result;
367 /* Functions at which to stop the backtrace print. It's not
368 particularly helpful to print the callers of these functions. */
370 static const char * const bt_stop[] =
372 "main",
373 "toplev::main",
374 "execute_one_pass",
375 "compile_file",
378 /* A callback function passed to the backtrace_full function. */
380 static int
381 bt_callback (void *data, uintptr_t pc, const char *filename, int lineno,
382 const char *function)
384 int *pcount = (int *) data;
386 /* If we don't have any useful information, don't print
387 anything. */
388 if (filename == NULL && function == NULL)
389 return 0;
391 /* Skip functions in diagnostic.c. */
392 if (*pcount == 0
393 && filename != NULL
394 && strcmp (lbasename (filename), "diagnostic.c") == 0)
395 return 0;
397 /* Print up to 20 functions. We could make this a --param, but
398 since this is only for debugging just use a constant for now. */
399 if (*pcount >= 20)
401 /* Returning a non-zero value stops the backtrace. */
402 return 1;
404 ++*pcount;
406 char *alc = NULL;
407 if (function != NULL)
409 char *str = cplus_demangle_v3 (function,
410 (DMGL_VERBOSE | DMGL_ANSI
411 | DMGL_GNU_V3 | DMGL_PARAMS));
412 if (str != NULL)
414 alc = str;
415 function = str;
418 for (size_t i = 0; i < ARRAY_SIZE (bt_stop); ++i)
420 size_t len = strlen (bt_stop[i]);
421 if (strncmp (function, bt_stop[i], len) == 0
422 && (function[len] == '\0' || function[len] == '('))
424 if (alc != NULL)
425 free (alc);
426 /* Returning a non-zero value stops the backtrace. */
427 return 1;
432 fprintf (stderr, "0x%lx %s\n\t%s:%d\n",
433 (unsigned long) pc,
434 function == NULL ? "???" : function,
435 filename == NULL ? "???" : filename,
436 lineno);
438 if (alc != NULL)
439 free (alc);
441 return 0;
444 /* A callback function passed to the backtrace_full function. This is
445 called if backtrace_full has an error. */
447 static void
448 bt_err_callback (void *data ATTRIBUTE_UNUSED, const char *msg, int errnum)
450 if (errnum < 0)
452 /* This means that no debug info was available. Just quietly
453 skip printing backtrace info. */
454 return;
456 fprintf (stderr, "%s%s%s\n", msg, errnum == 0 ? "" : ": ",
457 errnum == 0 ? "" : xstrerror (errnum));
460 /* Check if we've met the maximum error limit, and if so fatally exit
461 with a message. CONTEXT is the context to check, and FLUSH
462 indicates whether a diagnostic_finish call is needed. */
464 void
465 diagnostic_check_max_errors (diagnostic_context *context, bool flush)
467 if (!context->max_errors)
468 return;
470 int count = (diagnostic_kind_count (context, DK_ERROR)
471 + diagnostic_kind_count (context, DK_SORRY)
472 + diagnostic_kind_count (context, DK_WERROR));
474 if (count >= context->max_errors)
476 fnotice (stderr,
477 "compilation terminated due to -fmax-errors=%u.\n",
478 context->max_errors);
479 if (flush)
480 diagnostic_finish (context);
481 exit (FATAL_EXIT_CODE);
485 /* Take any action which is expected to happen after the diagnostic
486 is written out. This function does not always return. */
487 void
488 diagnostic_action_after_output (diagnostic_context *context,
489 diagnostic_t diag_kind)
491 switch (diag_kind)
493 case DK_DEBUG:
494 case DK_NOTE:
495 case DK_ANACHRONISM:
496 case DK_WARNING:
497 break;
499 case DK_ERROR:
500 case DK_SORRY:
501 if (context->abort_on_error)
502 real_abort ();
503 if (context->fatal_errors)
505 fnotice (stderr, "compilation terminated due to -Wfatal-errors.\n");
506 diagnostic_finish (context);
507 exit (FATAL_EXIT_CODE);
509 break;
511 case DK_ICE:
512 case DK_ICE_NOBT:
514 struct backtrace_state *state = NULL;
515 if (diag_kind == DK_ICE)
516 state = backtrace_create_state (NULL, 0, bt_err_callback, NULL);
517 int count = 0;
518 if (state != NULL)
519 backtrace_full (state, 2, bt_callback, bt_err_callback,
520 (void *) &count);
522 if (context->abort_on_error)
523 real_abort ();
525 fnotice (stderr, "Please submit a full bug report,\n"
526 "with preprocessed source if appropriate.\n");
527 if (count > 0)
528 fnotice (stderr,
529 ("Please include the complete backtrace "
530 "with any bug report.\n"));
531 fnotice (stderr, "See %s for instructions.\n", bug_report_url);
533 exit (ICE_EXIT_CODE);
536 case DK_FATAL:
537 if (context->abort_on_error)
538 real_abort ();
539 diagnostic_finish (context);
540 fnotice (stderr, "compilation terminated.\n");
541 exit (FATAL_EXIT_CODE);
543 default:
544 gcc_unreachable ();
548 /* True if the last module or file in which a diagnostic was reported is
549 different from the current one. */
551 static bool
552 last_module_changed_p (diagnostic_context *context,
553 const line_map_ordinary *map)
555 return context->last_module != map;
558 /* Remember the current module or file as being the last one in which we
559 report a diagnostic. */
561 static void
562 set_last_module (diagnostic_context *context, const line_map_ordinary *map)
564 context->last_module = map;
567 void
568 diagnostic_report_current_module (diagnostic_context *context, location_t where)
570 const line_map_ordinary *map = NULL;
572 if (pp_needs_newline (context->printer))
574 pp_newline (context->printer);
575 pp_needs_newline (context->printer) = false;
578 if (where <= BUILTINS_LOCATION)
579 return;
581 linemap_resolve_location (line_table, where,
582 LRK_MACRO_DEFINITION_LOCATION,
583 &map);
585 if (map && last_module_changed_p (context, map))
587 set_last_module (context, map);
588 if (! MAIN_FILE_P (map))
590 map = INCLUDED_FROM (line_table, map);
591 const char *line_col
592 = maybe_line_and_column (LAST_SOURCE_LINE (map),
593 context->show_column
594 ? LAST_SOURCE_COLUMN (map) : 0);
595 pp_verbatim (context->printer,
596 "In file included from %r%s%s%R", "locus",
597 LINEMAP_FILE (map), line_col);
598 while (! MAIN_FILE_P (map))
600 map = INCLUDED_FROM (line_table, map);
601 line_col = maybe_line_and_column (LAST_SOURCE_LINE (map), 0);
602 pp_verbatim (context->printer,
603 ",\n from %r%s%s%R", "locus",
604 LINEMAP_FILE (map), line_col);
606 pp_verbatim (context->printer, ":");
607 pp_newline (context->printer);
612 void
613 default_diagnostic_starter (diagnostic_context *context,
614 diagnostic_info *diagnostic)
616 diagnostic_report_current_module (context, diagnostic_location (diagnostic));
617 pp_set_prefix (context->printer, diagnostic_build_prefix (context,
618 diagnostic));
621 void
622 default_diagnostic_start_span_fn (diagnostic_context *context,
623 expanded_location exploc)
625 pp_set_prefix (context->printer,
626 diagnostic_get_location_text (context, exploc));
627 pp_string (context->printer, "");
628 pp_newline (context->printer);
631 void
632 default_diagnostic_finalizer (diagnostic_context *context,
633 diagnostic_info *diagnostic)
635 diagnostic_show_locus (context, diagnostic->richloc, diagnostic->kind);
636 pp_destroy_prefix (context->printer);
637 pp_flush (context->printer);
640 /* Interface to specify diagnostic kind overrides. Returns the
641 previous setting, or DK_UNSPECIFIED if the parameters are out of
642 range. If OPTION_INDEX is zero, the new setting is for all the
643 diagnostics. */
644 diagnostic_t
645 diagnostic_classify_diagnostic (diagnostic_context *context,
646 int option_index,
647 diagnostic_t new_kind,
648 location_t where)
650 diagnostic_t old_kind;
652 if (option_index < 0
653 || option_index >= context->n_opts
654 || new_kind >= DK_LAST_DIAGNOSTIC_KIND)
655 return DK_UNSPECIFIED;
657 old_kind = context->classify_diagnostic[option_index];
659 /* Handle pragmas separately, since we need to keep track of *where*
660 the pragmas were. */
661 if (where != UNKNOWN_LOCATION)
663 int i;
665 /* Record the command-line status, so we can reset it back on DK_POP. */
666 if (old_kind == DK_UNSPECIFIED)
668 old_kind = !context->option_enabled (option_index,
669 context->option_state)
670 ? DK_IGNORED : (context->warning_as_error_requested
671 ? DK_ERROR : DK_WARNING);
672 context->classify_diagnostic[option_index] = old_kind;
675 for (i = context->n_classification_history - 1; i >= 0; i --)
676 if (context->classification_history[i].option == option_index)
678 old_kind = context->classification_history[i].kind;
679 break;
682 i = context->n_classification_history;
683 context->classification_history =
684 (diagnostic_classification_change_t *) xrealloc (context->classification_history, (i + 1)
685 * sizeof (diagnostic_classification_change_t));
686 context->classification_history[i].location = where;
687 context->classification_history[i].option = option_index;
688 context->classification_history[i].kind = new_kind;
689 context->n_classification_history ++;
691 else
692 context->classify_diagnostic[option_index] = new_kind;
694 return old_kind;
697 /* Save all diagnostic classifications in a stack. */
698 void
699 diagnostic_push_diagnostics (diagnostic_context *context, location_t where ATTRIBUTE_UNUSED)
701 context->push_list = (int *) xrealloc (context->push_list, (context->n_push + 1) * sizeof (int));
702 context->push_list[context->n_push ++] = context->n_classification_history;
705 /* Restore the topmost classification set off the stack. If the stack
706 is empty, revert to the state based on command line parameters. */
707 void
708 diagnostic_pop_diagnostics (diagnostic_context *context, location_t where)
710 int jump_to;
711 int i;
713 if (context->n_push)
714 jump_to = context->push_list [-- context->n_push];
715 else
716 jump_to = 0;
718 i = context->n_classification_history;
719 context->classification_history =
720 (diagnostic_classification_change_t *) xrealloc (context->classification_history, (i + 1)
721 * sizeof (diagnostic_classification_change_t));
722 context->classification_history[i].location = where;
723 context->classification_history[i].option = jump_to;
724 context->classification_history[i].kind = DK_POP;
725 context->n_classification_history ++;
728 /* Helper function for print_parseable_fixits. Print TEXT to PP, obeying the
729 escaping rules for -fdiagnostics-parseable-fixits. */
731 static void
732 print_escaped_string (pretty_printer *pp, const char *text)
734 gcc_assert (pp);
735 gcc_assert (text);
737 pp_character (pp, '"');
738 for (const char *ch = text; *ch; ch++)
740 switch (*ch)
742 case '\\':
743 /* Escape backslash as two backslashes. */
744 pp_string (pp, "\\\\");
745 break;
746 case '\t':
747 /* Escape tab as "\t". */
748 pp_string (pp, "\\t");
749 break;
750 case '\n':
751 /* Escape newline as "\n". */
752 pp_string (pp, "\\n");
753 break;
754 case '"':
755 /* Escape doublequotes as \". */
756 pp_string (pp, "\\\"");
757 break;
758 default:
759 if (ISPRINT (*ch))
760 pp_character (pp, *ch);
761 else
762 /* Use octal for non-printable chars. */
764 unsigned char c = (*ch & 0xff);
765 pp_printf (pp, "\\%o%o%o", (c / 64), (c / 8) & 007, c & 007);
767 break;
770 pp_character (pp, '"');
773 /* Implementation of -fdiagnostics-parseable-fixits. Print a
774 machine-parseable version of all fixits in RICHLOC to PP. */
776 static void
777 print_parseable_fixits (pretty_printer *pp, rich_location *richloc)
779 gcc_assert (pp);
780 gcc_assert (richloc);
782 for (unsigned i = 0; i < richloc->get_num_fixit_hints (); i++)
784 const fixit_hint *hint = richloc->get_fixit_hint (i);
785 source_location start_loc = hint->get_start_loc ();
786 expanded_location start_exploc = expand_location (start_loc);
787 pp_string (pp, "fix-it:");
788 print_escaped_string (pp, start_exploc.file);
789 /* For compatibility with clang, print as a half-open range. */
790 source_location next_loc = hint->get_next_loc ();
791 expanded_location next_exploc = expand_location (next_loc);
792 pp_printf (pp, ":{%i:%i-%i:%i}:",
793 start_exploc.line, start_exploc.column,
794 next_exploc.line, next_exploc.column);
795 print_escaped_string (pp, hint->get_string ());
796 pp_newline (pp);
800 /* Update the diag_class of DIAGNOSTIC based on its location
801 relative to any
802 #pragma GCC diagnostic
803 directives recorded within CONTEXT.
805 Return the new diag_class of DIAGNOSTIC if it was updated, or
806 DK_UNSPECIFIED otherwise. */
808 static diagnostic_t
809 update_effective_level_from_pragmas (diagnostic_context *context,
810 diagnostic_info *diagnostic)
812 diagnostic_t diag_class = DK_UNSPECIFIED;
814 if (context->n_classification_history > 0)
816 location_t location = diagnostic_location (diagnostic);
818 /* FIXME: Stupid search. Optimize later. */
819 for (int i = context->n_classification_history - 1; i >= 0; i --)
821 if (linemap_location_before_p
822 (line_table,
823 context->classification_history[i].location,
824 location))
826 if (context->classification_history[i].kind == (int) DK_POP)
828 i = context->classification_history[i].option;
829 continue;
831 int option = context->classification_history[i].option;
832 /* The option 0 is for all the diagnostics. */
833 if (option == 0 || option == diagnostic->option_index)
835 diag_class = context->classification_history[i].kind;
836 if (diag_class != DK_UNSPECIFIED)
837 diagnostic->kind = diag_class;
838 break;
844 return diag_class;
847 /* Print any metadata about the option used to control DIAGNOSTIC to CONTEXT's
848 printer, e.g. " [-Werror=uninitialized]".
849 Subroutine of diagnostic_report_diagnostic. */
851 static void
852 print_option_information (diagnostic_context *context,
853 const diagnostic_info *diagnostic,
854 diagnostic_t orig_diag_kind)
856 char *option_text;
858 option_text = context->option_name (context, diagnostic->option_index,
859 orig_diag_kind, diagnostic->kind);
861 if (option_text)
863 pretty_printer *pp = context->printer;
864 pp_string (pp, " [");
865 pp_string (pp, colorize_start (pp_show_color (pp),
866 diagnostic_kind_color[diagnostic->kind]));
867 pp_string (pp, option_text);
868 pp_string (pp, colorize_stop (pp_show_color (pp)));
869 pp_character (pp, ']');
870 free (option_text);
874 /* Report a diagnostic message (an error or a warning) as specified by
875 DC. This function is *the* subroutine in terms of which front-ends
876 should implement their specific diagnostic handling modules. The
877 front-end independent format specifiers are exactly those described
878 in the documentation of output_format.
879 Return true if a diagnostic was printed, false otherwise. */
881 bool
882 diagnostic_report_diagnostic (diagnostic_context *context,
883 diagnostic_info *diagnostic)
885 location_t location = diagnostic_location (diagnostic);
886 diagnostic_t orig_diag_kind = diagnostic->kind;
888 /* Give preference to being able to inhibit warnings, before they
889 get reclassified to something else. */
890 if ((diagnostic->kind == DK_WARNING || diagnostic->kind == DK_PEDWARN)
891 && !diagnostic_report_warnings_p (context, location))
892 return false;
894 if (diagnostic->kind == DK_PEDWARN)
896 diagnostic->kind = pedantic_warning_kind (context);
897 /* We do this to avoid giving the message for -pedantic-errors. */
898 orig_diag_kind = diagnostic->kind;
901 if (diagnostic->kind == DK_NOTE && context->inhibit_notes_p)
902 return false;
904 if (context->lock > 0)
906 /* If we're reporting an ICE in the middle of some other error,
907 try to flush out the previous error, then let this one
908 through. Don't do this more than once. */
909 if ((diagnostic->kind == DK_ICE || diagnostic->kind == DK_ICE_NOBT)
910 && context->lock == 1)
911 pp_newline_and_flush (context->printer);
912 else
913 error_recursion (context);
916 /* If the user requested that warnings be treated as errors, so be
917 it. Note that we do this before the next block so that
918 individual warnings can be overridden back to warnings with
919 -Wno-error=*. */
920 if (context->warning_as_error_requested
921 && diagnostic->kind == DK_WARNING)
922 diagnostic->kind = DK_ERROR;
924 if (diagnostic->option_index
925 && diagnostic->option_index != permissive_error_option (context))
927 /* This tests if the user provided the appropriate -Wfoo or
928 -Wno-foo option. */
929 if (! context->option_enabled (diagnostic->option_index,
930 context->option_state))
931 return false;
933 /* This tests for #pragma diagnostic changes. */
934 diagnostic_t diag_class
935 = update_effective_level_from_pragmas (context, diagnostic);
937 /* This tests if the user provided the appropriate -Werror=foo
938 option. */
939 if (diag_class == DK_UNSPECIFIED
940 && (context->classify_diagnostic[diagnostic->option_index]
941 != DK_UNSPECIFIED))
942 diagnostic->kind
943 = context->classify_diagnostic[diagnostic->option_index];
945 /* This allows for future extensions, like temporarily disabling
946 warnings for ranges of source code. */
947 if (diagnostic->kind == DK_IGNORED)
948 return false;
951 if (diagnostic->kind != DK_NOTE)
952 diagnostic_check_max_errors (context);
954 context->lock++;
956 if (diagnostic->kind == DK_ICE || diagnostic->kind == DK_ICE_NOBT)
958 /* When not checking, ICEs are converted to fatal errors when an
959 error has already occurred. This is counteracted by
960 abort_on_error. */
961 if (!CHECKING_P
962 && (diagnostic_kind_count (context, DK_ERROR) > 0
963 || diagnostic_kind_count (context, DK_SORRY) > 0)
964 && !context->abort_on_error)
966 expanded_location s
967 = expand_location (diagnostic_location (diagnostic));
968 fnotice (stderr, "%s:%d: confused by earlier errors, bailing out\n",
969 s.file, s.line);
970 exit (ICE_EXIT_CODE);
972 if (context->internal_error)
973 (*context->internal_error) (context,
974 diagnostic->message.format_spec,
975 diagnostic->message.args_ptr);
977 if (diagnostic->kind == DK_ERROR && orig_diag_kind == DK_WARNING)
978 ++diagnostic_kind_count (context, DK_WERROR);
979 else
980 ++diagnostic_kind_count (context, diagnostic->kind);
982 diagnostic->message.x_data = &diagnostic->x_data;
983 diagnostic->x_data = NULL;
984 pp_format (context->printer, &diagnostic->message);
985 (*diagnostic_starter (context)) (context, diagnostic);
986 pp_output_formatted_text (context->printer);
987 if (context->show_option_requested)
988 print_option_information (context, diagnostic, orig_diag_kind);
989 (*diagnostic_finalizer (context)) (context, diagnostic);
990 if (context->parseable_fixits_p)
992 print_parseable_fixits (context->printer, diagnostic->richloc);
993 pp_flush (context->printer);
995 diagnostic_action_after_output (context, diagnostic->kind);
996 diagnostic->x_data = NULL;
998 if (context->edit_context_ptr)
999 if (diagnostic->richloc->fixits_can_be_auto_applied_p ())
1000 context->edit_context_ptr->add_fixits (diagnostic->richloc);
1002 context->lock--;
1004 return true;
1007 /* Given a partial pathname as input, return another pathname that
1008 shares no directory elements with the pathname of __FILE__. This
1009 is used by fancy_abort() to print `Internal compiler error in expr.c'
1010 instead of `Internal compiler error in ../../GCC/gcc/expr.c'. */
1012 const char *
1013 trim_filename (const char *name)
1015 static const char this_file[] = __FILE__;
1016 const char *p = name, *q = this_file;
1018 /* First skip any "../" in each filename. This allows us to give a proper
1019 reference to a file in a subdirectory. */
1020 while (p[0] == '.' && p[1] == '.' && IS_DIR_SEPARATOR (p[2]))
1021 p += 3;
1023 while (q[0] == '.' && q[1] == '.' && IS_DIR_SEPARATOR (q[2]))
1024 q += 3;
1026 /* Now skip any parts the two filenames have in common. */
1027 while (*p == *q && *p != 0 && *q != 0)
1028 p++, q++;
1030 /* Now go backwards until the previous directory separator. */
1031 while (p > name && !IS_DIR_SEPARATOR (p[-1]))
1032 p--;
1034 return p;
1037 /* Standard error reporting routines in increasing order of severity.
1038 All of these take arguments like printf. */
1040 /* Text to be emitted verbatim to the error message stream; this
1041 produces no prefix and disables line-wrapping. Use rarely. */
1042 void
1043 verbatim (const char *gmsgid, ...)
1045 text_info text;
1046 va_list ap;
1048 va_start (ap, gmsgid);
1049 text.err_no = errno;
1050 text.args_ptr = &ap;
1051 text.format_spec = _(gmsgid);
1052 text.x_data = NULL;
1053 pp_format_verbatim (global_dc->printer, &text);
1054 pp_newline_and_flush (global_dc->printer);
1055 va_end (ap);
1058 /* Add a note with text GMSGID and with LOCATION to the diagnostic CONTEXT. */
1059 void
1060 diagnostic_append_note (diagnostic_context *context,
1061 location_t location,
1062 const char * gmsgid, ...)
1064 diagnostic_info diagnostic;
1065 va_list ap;
1066 const char *saved_prefix;
1067 rich_location richloc (line_table, location);
1069 va_start (ap, gmsgid);
1070 diagnostic_set_info (&diagnostic, gmsgid, &ap, &richloc, DK_NOTE);
1071 if (context->inhibit_notes_p)
1073 va_end (ap);
1074 return;
1076 saved_prefix = pp_get_prefix (context->printer);
1077 pp_set_prefix (context->printer,
1078 diagnostic_build_prefix (context, &diagnostic));
1079 pp_format (context->printer, &diagnostic.message);
1080 pp_output_formatted_text (context->printer);
1081 pp_destroy_prefix (context->printer);
1082 pp_set_prefix (context->printer, saved_prefix);
1083 diagnostic_show_locus (context, &richloc, DK_NOTE);
1084 va_end (ap);
1087 /* Implement emit_diagnostic, inform, warning, warning_at, pedwarn,
1088 permerror, error, error_at, error_at, sorry, fatal_error, internal_error,
1089 and internal_error_no_backtrace, as documented and defined below. */
1090 static bool
1091 diagnostic_impl (rich_location *richloc, int opt,
1092 const char *gmsgid,
1093 va_list *ap, diagnostic_t kind)
1095 diagnostic_info diagnostic;
1096 if (kind == DK_PERMERROR)
1098 diagnostic_set_info (&diagnostic, gmsgid, ap, richloc,
1099 permissive_error_kind (global_dc));
1100 diagnostic.option_index = permissive_error_option (global_dc);
1102 else
1104 diagnostic_set_info (&diagnostic, gmsgid, ap, richloc, kind);
1105 if (kind == DK_WARNING || kind == DK_PEDWARN)
1106 diagnostic.option_index = opt;
1108 return diagnostic_report_diagnostic (global_dc, &diagnostic);
1111 /* Implement inform_n, warning_n, and error_n, as documented and
1112 defined below. */
1113 static bool
1114 diagnostic_n_impl (rich_location *richloc, int opt, unsigned HOST_WIDE_INT n,
1115 const char *singular_gmsgid,
1116 const char *plural_gmsgid,
1117 va_list *ap, diagnostic_t kind)
1119 diagnostic_info diagnostic;
1120 unsigned long gtn;
1122 if (sizeof n <= sizeof gtn)
1123 gtn = n;
1124 else
1125 /* Use the largest number ngettext can handle, otherwise
1126 preserve the six least significant decimal digits for
1127 languages where the plural form depends on them. */
1128 gtn = n <= ULONG_MAX ? n : n % 1000000LU + 1000000LU;
1130 const char *text = ngettext (singular_gmsgid, plural_gmsgid, gtn);
1131 diagnostic_set_info_translated (&diagnostic, text, ap, richloc, kind);
1132 if (kind == DK_WARNING)
1133 diagnostic.option_index = opt;
1134 return diagnostic_report_diagnostic (global_dc, &diagnostic);
1137 /* Wrapper around diagnostic_impl taking a variable argument list. */
1139 bool
1140 emit_diagnostic (diagnostic_t kind, location_t location, int opt,
1141 const char *gmsgid, ...)
1143 va_list ap;
1144 va_start (ap, gmsgid);
1145 rich_location richloc (line_table, location);
1146 bool ret = diagnostic_impl (&richloc, opt, gmsgid, &ap, kind);
1147 va_end (ap);
1148 return ret;
1151 /* Wrapper around diagnostic_impl taking a va_list parameter. */
1153 bool
1154 emit_diagnostic_valist (diagnostic_t kind, location_t location, int opt,
1155 const char *gmsgid, va_list *ap)
1157 rich_location richloc (line_table, location);
1158 return diagnostic_impl (&richloc, opt, gmsgid, ap, kind);
1161 /* An informative note at LOCATION. Use this for additional details on an error
1162 message. */
1163 void
1164 inform (location_t location, const char *gmsgid, ...)
1166 va_list ap;
1167 va_start (ap, gmsgid);
1168 rich_location richloc (line_table, location);
1169 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_NOTE);
1170 va_end (ap);
1173 /* Same as "inform" above, but at RICHLOC. */
1174 void
1175 inform (rich_location *richloc, const char *gmsgid, ...)
1177 gcc_assert (richloc);
1179 va_list ap;
1180 va_start (ap, gmsgid);
1181 diagnostic_impl (richloc, -1, gmsgid, &ap, DK_NOTE);
1182 va_end (ap);
1185 /* An informative note at LOCATION. Use this for additional details on an
1186 error message. */
1187 void
1188 inform_n (location_t location, unsigned HOST_WIDE_INT n,
1189 const char *singular_gmsgid, const char *plural_gmsgid, ...)
1191 va_list ap;
1192 va_start (ap, plural_gmsgid);
1193 rich_location richloc (line_table, location);
1194 diagnostic_n_impl (&richloc, -1, n, singular_gmsgid, plural_gmsgid,
1195 &ap, DK_NOTE);
1196 va_end (ap);
1199 /* A warning at INPUT_LOCATION. Use this for code which is correct according
1200 to the relevant language specification but is likely to be buggy anyway.
1201 Returns true if the warning was printed, false if it was inhibited. */
1202 bool
1203 warning (int opt, const char *gmsgid, ...)
1205 va_list ap;
1206 va_start (ap, gmsgid);
1207 rich_location richloc (line_table, input_location);
1208 bool ret = diagnostic_impl (&richloc, opt, gmsgid, &ap, DK_WARNING);
1209 va_end (ap);
1210 return ret;
1213 /* A warning at LOCATION. Use this for code which is correct according to the
1214 relevant language specification but is likely to be buggy anyway.
1215 Returns true if the warning was printed, false if it was inhibited. */
1217 bool
1218 warning_at (location_t location, int opt, const char *gmsgid, ...)
1220 va_list ap;
1221 va_start (ap, gmsgid);
1222 rich_location richloc (line_table, location);
1223 bool ret = diagnostic_impl (&richloc, opt, gmsgid, &ap, DK_WARNING);
1224 va_end (ap);
1225 return ret;
1228 /* Same as "warning at" above, but using RICHLOC. */
1230 bool
1231 warning_at (rich_location *richloc, int opt, const char *gmsgid, ...)
1233 gcc_assert (richloc);
1235 va_list ap;
1236 va_start (ap, gmsgid);
1237 bool ret = diagnostic_impl (richloc, opt, gmsgid, &ap, DK_WARNING);
1238 va_end (ap);
1239 return ret;
1242 /* Same as warning_n plural variant below, but using RICHLOC. */
1244 bool
1245 warning_n (rich_location *richloc, int opt, unsigned HOST_WIDE_INT n,
1246 const char *singular_gmsgid, const char *plural_gmsgid, ...)
1248 gcc_assert (richloc);
1250 va_list ap;
1251 va_start (ap, plural_gmsgid);
1252 bool ret = diagnostic_n_impl (richloc, opt, n,
1253 singular_gmsgid, plural_gmsgid,
1254 &ap, DK_WARNING);
1255 va_end (ap);
1256 return ret;
1259 /* A warning at LOCATION. Use this for code which is correct according to the
1260 relevant language specification but is likely to be buggy anyway.
1261 Returns true if the warning was printed, false if it was inhibited. */
1263 bool
1264 warning_n (location_t location, int opt, unsigned HOST_WIDE_INT n,
1265 const char *singular_gmsgid, const char *plural_gmsgid, ...)
1267 va_list ap;
1268 va_start (ap, plural_gmsgid);
1269 rich_location richloc (line_table, location);
1270 bool ret = diagnostic_n_impl (&richloc, opt, n,
1271 singular_gmsgid, plural_gmsgid,
1272 &ap, DK_WARNING);
1273 va_end (ap);
1274 return ret;
1277 /* A "pedantic" warning at LOCATION: issues a warning unless
1278 -pedantic-errors was given on the command line, in which case it
1279 issues an error. Use this for diagnostics required by the relevant
1280 language standard, if you have chosen not to make them errors.
1282 Note that these diagnostics are issued independent of the setting
1283 of the -Wpedantic command-line switch. To get a warning enabled
1284 only with that switch, use either "if (pedantic) pedwarn
1285 (OPT_Wpedantic,...)" or just "pedwarn (OPT_Wpedantic,..)". To get a
1286 pedwarn independently of the -Wpedantic switch use "pedwarn (0,...)".
1288 Returns true if the warning was printed, false if it was inhibited. */
1290 bool
1291 pedwarn (location_t location, int opt, const char *gmsgid, ...)
1293 va_list ap;
1294 va_start (ap, gmsgid);
1295 rich_location richloc (line_table, location);
1296 bool ret = diagnostic_impl (&richloc, opt, gmsgid, &ap, DK_PEDWARN);
1297 va_end (ap);
1298 return ret;
1301 /* Same as pedwarn above, but using RICHLOC. */
1303 bool
1304 pedwarn (rich_location *richloc, int opt, const char *gmsgid, ...)
1306 gcc_assert (richloc);
1308 va_list ap;
1309 va_start (ap, gmsgid);
1310 bool ret = diagnostic_impl (richloc, opt, gmsgid, &ap, DK_PEDWARN);
1311 va_end (ap);
1312 return ret;
1315 /* A "permissive" error at LOCATION: issues an error unless
1316 -fpermissive was given on the command line, in which case it issues
1317 a warning. Use this for things that really should be errors but we
1318 want to support legacy code.
1320 Returns true if the warning was printed, false if it was inhibited. */
1322 bool
1323 permerror (location_t location, const char *gmsgid, ...)
1325 va_list ap;
1326 va_start (ap, gmsgid);
1327 rich_location richloc (line_table, location);
1328 bool ret = diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_PERMERROR);
1329 va_end (ap);
1330 return ret;
1333 /* Same as "permerror" above, but at RICHLOC. */
1335 bool
1336 permerror (rich_location *richloc, const char *gmsgid, ...)
1338 gcc_assert (richloc);
1340 va_list ap;
1341 va_start (ap, gmsgid);
1342 bool ret = diagnostic_impl (richloc, -1, gmsgid, &ap, DK_PERMERROR);
1343 va_end (ap);
1344 return ret;
1347 /* A hard error: the code is definitely ill-formed, and an object file
1348 will not be produced. */
1349 void
1350 error (const char *gmsgid, ...)
1352 va_list ap;
1353 va_start (ap, gmsgid);
1354 rich_location richloc (line_table, input_location);
1355 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_ERROR);
1356 va_end (ap);
1359 /* A hard error: the code is definitely ill-formed, and an object file
1360 will not be produced. */
1361 void
1362 error_n (location_t location, unsigned HOST_WIDE_INT n,
1363 const char *singular_gmsgid, const char *plural_gmsgid, ...)
1365 va_list ap;
1366 va_start (ap, plural_gmsgid);
1367 rich_location richloc (line_table, location);
1368 diagnostic_n_impl (&richloc, -1, n, singular_gmsgid, plural_gmsgid,
1369 &ap, DK_ERROR);
1370 va_end (ap);
1373 /* Same as above, but use location LOC instead of input_location. */
1374 void
1375 error_at (location_t loc, const char *gmsgid, ...)
1377 va_list ap;
1378 va_start (ap, gmsgid);
1379 rich_location richloc (line_table, loc);
1380 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_ERROR);
1381 va_end (ap);
1384 /* Same as above, but use RICH_LOC. */
1386 void
1387 error_at (rich_location *richloc, const char *gmsgid, ...)
1389 gcc_assert (richloc);
1391 va_list ap;
1392 va_start (ap, gmsgid);
1393 diagnostic_impl (richloc, -1, gmsgid, &ap, DK_ERROR);
1394 va_end (ap);
1397 /* "Sorry, not implemented." Use for a language feature which is
1398 required by the relevant specification but not implemented by GCC.
1399 An object file will not be produced. */
1400 void
1401 sorry (const char *gmsgid, ...)
1403 va_list ap;
1404 va_start (ap, gmsgid);
1405 rich_location richloc (line_table, input_location);
1406 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_SORRY);
1407 va_end (ap);
1410 /* Return true if an error or a "sorry" has been seen. Various
1411 processing is disabled after errors. */
1412 bool
1413 seen_error (void)
1415 return errorcount || sorrycount;
1418 /* An error which is severe enough that we make no attempt to
1419 continue. Do not use this for internal consistency checks; that's
1420 internal_error. Use of this function should be rare. */
1421 void
1422 fatal_error (location_t loc, const char *gmsgid, ...)
1424 va_list ap;
1425 va_start (ap, gmsgid);
1426 rich_location richloc (line_table, loc);
1427 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_FATAL);
1428 va_end (ap);
1430 gcc_unreachable ();
1433 /* An internal consistency check has failed. We make no attempt to
1434 continue. Note that unless there is debugging value to be had from
1435 a more specific message, or some other good reason, you should use
1436 abort () instead of calling this function directly. */
1437 void
1438 internal_error (const char *gmsgid, ...)
1440 va_list ap;
1441 va_start (ap, gmsgid);
1442 rich_location richloc (line_table, input_location);
1443 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_ICE);
1444 va_end (ap);
1446 gcc_unreachable ();
1449 /* Like internal_error, but no backtrace will be printed. Used when
1450 the internal error does not happen at the current location, but happened
1451 somewhere else. */
1452 void
1453 internal_error_no_backtrace (const char *gmsgid, ...)
1455 va_list ap;
1456 va_start (ap, gmsgid);
1457 rich_location richloc (line_table, input_location);
1458 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_ICE_NOBT);
1459 va_end (ap);
1461 gcc_unreachable ();
1464 /* Special case error functions. Most are implemented in terms of the
1465 above, or should be. */
1467 /* Print a diagnostic MSGID on FILE. This is just fprintf, except it
1468 runs its second argument through gettext. */
1469 void
1470 fnotice (FILE *file, const char *cmsgid, ...)
1472 va_list ap;
1474 va_start (ap, cmsgid);
1475 vfprintf (file, _(cmsgid), ap);
1476 va_end (ap);
1479 /* Inform the user that an error occurred while trying to report some
1480 other error. This indicates catastrophic internal inconsistencies,
1481 so give up now. But do try to flush out the previous error.
1482 This mustn't use internal_error, that will cause infinite recursion. */
1484 static void
1485 error_recursion (diagnostic_context *context)
1487 if (context->lock < 3)
1488 pp_newline_and_flush (context->printer);
1490 fnotice (stderr,
1491 "Internal compiler error: Error reporting routines re-entered.\n");
1493 /* Call diagnostic_action_after_output to get the "please submit a bug
1494 report" message. */
1495 diagnostic_action_after_output (context, DK_ICE);
1497 /* Do not use gcc_unreachable here; that goes through internal_error
1498 and therefore would cause infinite recursion. */
1499 real_abort ();
1502 /* Report an internal compiler error in a friendly manner. This is
1503 the function that gets called upon use of abort() in the source
1504 code generally, thanks to a special macro. */
1506 void
1507 fancy_abort (const char *file, int line, const char *function)
1509 internal_error ("in %s, at %s:%d", function, trim_filename (file), line);
1512 /* Really call the system 'abort'. This has to go right at the end of
1513 this file, so that there are no functions after it that call abort
1514 and get the system abort instead of our macro. */
1515 #undef abort
1516 static void
1517 real_abort (void)
1519 abort ();
1522 #if CHECKING_P
1524 namespace selftest {
1526 /* Helper function for test_print_escaped_string. */
1528 static void
1529 assert_print_escaped_string (const location &loc, const char *expected_output,
1530 const char *input)
1532 pretty_printer pp;
1533 print_escaped_string (&pp, input);
1534 ASSERT_STREQ_AT (loc, expected_output, pp_formatted_text (&pp));
1537 #define ASSERT_PRINT_ESCAPED_STRING_STREQ(EXPECTED_OUTPUT, INPUT) \
1538 assert_print_escaped_string (SELFTEST_LOCATION, EXPECTED_OUTPUT, INPUT)
1540 /* Tests of print_escaped_string. */
1542 static void
1543 test_print_escaped_string ()
1545 /* Empty string. */
1546 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"\"", "");
1548 /* Non-empty string. */
1549 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"hello world\"", "hello world");
1551 /* Various things that need to be escaped: */
1552 /* Backslash. */
1553 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\\\after\"",
1554 "before\\after");
1555 /* Tab. */
1556 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\tafter\"",
1557 "before\tafter");
1558 /* Newline. */
1559 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\nafter\"",
1560 "before\nafter");
1561 /* Double quote. */
1562 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\\"after\"",
1563 "before\"after");
1565 /* Non-printable characters: BEL: '\a': 0x07 */
1566 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\007after\"",
1567 "before\aafter");
1568 /* Non-printable characters: vertical tab: '\v': 0x0b */
1569 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\013after\"",
1570 "before\vafter");
1573 /* Tests of print_parseable_fixits. */
1575 /* Verify that print_parseable_fixits emits the empty string if there
1576 are no fixits. */
1578 static void
1579 test_print_parseable_fixits_none ()
1581 pretty_printer pp;
1582 rich_location richloc (line_table, UNKNOWN_LOCATION);
1584 print_parseable_fixits (&pp, &richloc);
1585 ASSERT_STREQ ("", pp_formatted_text (&pp));
1588 /* Verify that print_parseable_fixits does the right thing if there
1589 is an insertion fixit hint. */
1591 static void
1592 test_print_parseable_fixits_insert ()
1594 pretty_printer pp;
1595 rich_location richloc (line_table, UNKNOWN_LOCATION);
1597 linemap_add (line_table, LC_ENTER, false, "test.c", 0);
1598 linemap_line_start (line_table, 5, 100);
1599 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
1600 location_t where = linemap_position_for_column (line_table, 10);
1601 richloc.add_fixit_insert_before (where, "added content");
1603 print_parseable_fixits (&pp, &richloc);
1604 ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:10}:\"added content\"\n",
1605 pp_formatted_text (&pp));
1608 /* Verify that print_parseable_fixits does the right thing if there
1609 is an removal fixit hint. */
1611 static void
1612 test_print_parseable_fixits_remove ()
1614 pretty_printer pp;
1615 rich_location richloc (line_table, UNKNOWN_LOCATION);
1617 linemap_add (line_table, LC_ENTER, false, "test.c", 0);
1618 linemap_line_start (line_table, 5, 100);
1619 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
1620 source_range where;
1621 where.m_start = linemap_position_for_column (line_table, 10);
1622 where.m_finish = linemap_position_for_column (line_table, 20);
1623 richloc.add_fixit_remove (where);
1625 print_parseable_fixits (&pp, &richloc);
1626 ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:21}:\"\"\n",
1627 pp_formatted_text (&pp));
1630 /* Verify that print_parseable_fixits does the right thing if there
1631 is an replacement fixit hint. */
1633 static void
1634 test_print_parseable_fixits_replace ()
1636 pretty_printer pp;
1637 rich_location richloc (line_table, UNKNOWN_LOCATION);
1639 linemap_add (line_table, LC_ENTER, false, "test.c", 0);
1640 linemap_line_start (line_table, 5, 100);
1641 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
1642 source_range where;
1643 where.m_start = linemap_position_for_column (line_table, 10);
1644 where.m_finish = linemap_position_for_column (line_table, 20);
1645 richloc.add_fixit_replace (where, "replacement");
1647 print_parseable_fixits (&pp, &richloc);
1648 ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:21}:\"replacement\"\n",
1649 pp_formatted_text (&pp));
1652 /* Verify that
1653 diagnostic_get_location_text (..., SHOW_COLUMN)
1654 generates EXPECTED_LOC_TEXT, given FILENAME, LINE, COLUMN, with
1655 colorization disabled. */
1657 static void
1658 assert_location_text (const char *expected_loc_text,
1659 const char *filename, int line, int column,
1660 bool show_column)
1662 test_diagnostic_context dc;
1663 dc.show_column = show_column;
1665 expanded_location xloc;
1666 xloc.file = filename;
1667 xloc.line = line;
1668 xloc.column = column;
1669 xloc.data = NULL;
1670 xloc.sysp = false;
1672 char *actual_loc_text = diagnostic_get_location_text (&dc, xloc);
1673 ASSERT_STREQ (expected_loc_text, actual_loc_text);
1674 free (actual_loc_text);
1677 /* Verify that diagnostic_get_location_text works as expected. */
1679 static void
1680 test_diagnostic_get_location_text ()
1682 const char *old_progname = progname;
1683 progname = "PROGNAME";
1684 assert_location_text ("PROGNAME:", NULL, 0, 0, true);
1685 assert_location_text ("<built-in>:", "<built-in>", 42, 10, true);
1686 assert_location_text ("foo.c:42:10:", "foo.c", 42, 10, true);
1687 assert_location_text ("foo.c:42:", "foo.c", 42, 0, true);
1688 assert_location_text ("foo.c:", "foo.c", 0, 10, true);
1689 assert_location_text ("foo.c:42:", "foo.c", 42, 10, false);
1690 assert_location_text ("foo.c:", "foo.c", 0, 10, false);
1692 maybe_line_and_column (INT_MAX, INT_MAX);
1693 maybe_line_and_column (INT_MIN, INT_MIN);
1695 progname = old_progname;
1698 /* Run all of the selftests within this file. */
1700 void
1701 diagnostic_c_tests ()
1703 test_print_escaped_string ();
1704 test_print_parseable_fixits_none ();
1705 test_print_parseable_fixits_insert ();
1706 test_print_parseable_fixits_remove ();
1707 test_print_parseable_fixits_replace ();
1708 test_diagnostic_get_location_text ();
1711 } // namespace selftest
1713 #endif /* #if CHECKING_P */