[gcc]
[official-gcc.git] / gcc / diagnostic.c
blobbbf5f5ce7a611e5fba0784bcedd8e35f8115d5c1
1 /* Language-independent diagnostic subroutines for the GNU Compiler Collection
2 Copyright (C) 1999-2017 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"
37 #ifdef HAVE_TERMIOS_H
38 # include <termios.h>
39 #endif
41 #ifdef GWINSZ_IN_SYS_IOCTL
42 # include <sys/ioctl.h>
43 #endif
45 #define pedantic_warning_kind(DC) \
46 ((DC)->pedantic_errors ? DK_ERROR : DK_WARNING)
47 #define permissive_error_kind(DC) ((DC)->permissive ? DK_WARNING : DK_ERROR)
48 #define permissive_error_option(DC) ((DC)->opt_permissive)
50 /* Prototypes. */
51 static bool diagnostic_impl (rich_location *, int, const char *,
52 va_list *, diagnostic_t) ATTRIBUTE_GCC_DIAG(3,0);
53 static bool diagnostic_n_impl (location_t, int, int, const char *,
54 const char *, va_list *,
55 diagnostic_t) ATTRIBUTE_GCC_DIAG(5,0);
56 static bool diagnostic_n_impl_richloc (rich_location *, int, int, const char *,
57 const char *, va_list *,
58 diagnostic_t) ATTRIBUTE_GCC_DIAG(5,0);
60 static void error_recursion (diagnostic_context *) ATTRIBUTE_NORETURN;
61 static void real_abort (void) ATTRIBUTE_NORETURN;
63 /* Name of program invoked, sans directories. */
65 const char *progname;
67 /* A diagnostic_context surrogate for stderr. */
68 static diagnostic_context global_diagnostic_context;
69 diagnostic_context *global_dc = &global_diagnostic_context;
71 /* Return a malloc'd string containing MSG formatted a la printf. The
72 caller is responsible for freeing the memory. */
73 char *
74 build_message_string (const char *msg, ...)
76 char *str;
77 va_list ap;
79 va_start (ap, msg);
80 str = xvasprintf (msg, ap);
81 va_end (ap);
83 return str;
86 /* Same as diagnostic_build_prefix, but only the source FILE is given. */
87 char *
88 file_name_as_prefix (diagnostic_context *context, const char *f)
90 const char *locus_cs
91 = colorize_start (pp_show_color (context->printer), "locus");
92 const char *locus_ce = colorize_stop (pp_show_color (context->printer));
93 return build_message_string ("%s%s:%s ", locus_cs, f, locus_ce);
98 /* Return the value of the getenv("COLUMNS") as an integer. If the
99 value is not set to a positive integer, use ioctl to get the
100 terminal width. If it fails, return INT_MAX. */
102 get_terminal_width (void)
104 const char * s = getenv ("COLUMNS");
105 if (s != NULL) {
106 int n = atoi (s);
107 if (n > 0)
108 return n;
111 #ifdef TIOCGWINSZ
112 struct winsize w;
113 w.ws_col = 0;
114 if (ioctl (0, TIOCGWINSZ, &w) == 0 && w.ws_col > 0)
115 return w.ws_col;
116 #endif
118 return INT_MAX;
121 /* Set caret_max_width to value. */
122 void
123 diagnostic_set_caret_max_width (diagnostic_context *context, int value)
125 /* One minus to account for the leading empty space. */
126 value = value ? value - 1
127 : (isatty (fileno (pp_buffer (context->printer)->stream))
128 ? get_terminal_width () - 1: INT_MAX);
130 if (value <= 0)
131 value = INT_MAX;
133 context->caret_max_width = value;
136 /* Initialize the diagnostic message outputting machinery. */
137 void
138 diagnostic_initialize (diagnostic_context *context, int n_opts)
140 int i;
142 /* Allocate a basic pretty-printer. Clients will replace this a
143 much more elaborated pretty-printer if they wish. */
144 context->printer = XNEW (pretty_printer);
145 new (context->printer) pretty_printer ();
147 memset (context->diagnostic_count, 0, sizeof context->diagnostic_count);
148 context->warning_as_error_requested = false;
149 context->n_opts = n_opts;
150 context->classify_diagnostic = XNEWVEC (diagnostic_t, n_opts);
151 for (i = 0; i < n_opts; i++)
152 context->classify_diagnostic[i] = DK_UNSPECIFIED;
153 context->show_caret = false;
154 diagnostic_set_caret_max_width (context, pp_line_cutoff (context->printer));
155 for (i = 0; i < rich_location::STATICALLY_ALLOCATED_RANGES; i++)
156 context->caret_chars[i] = '^';
157 context->show_option_requested = false;
158 context->abort_on_error = false;
159 context->show_column = false;
160 context->pedantic_errors = false;
161 context->permissive = false;
162 context->opt_permissive = 0;
163 context->fatal_errors = false;
164 context->dc_inhibit_warnings = false;
165 context->dc_warn_system_headers = false;
166 context->max_errors = 0;
167 context->internal_error = NULL;
168 diagnostic_starter (context) = default_diagnostic_starter;
169 context->start_span = default_diagnostic_start_span_fn;
170 diagnostic_finalizer (context) = default_diagnostic_finalizer;
171 context->option_enabled = NULL;
172 context->option_state = NULL;
173 context->option_name = NULL;
174 context->last_location = UNKNOWN_LOCATION;
175 context->last_module = 0;
176 context->x_data = NULL;
177 context->lock = 0;
178 context->inhibit_notes_p = false;
179 context->colorize_source_p = false;
180 context->show_ruler_p = false;
181 context->parseable_fixits_p = false;
182 context->edit_context_ptr = NULL;
185 /* Maybe initialize the color support. We require clients to do this
186 explicitly, since most clients don't want color. When called
187 without a VALUE, it initializes with DIAGNOSTICS_COLOR_DEFAULT. */
189 void
190 diagnostic_color_init (diagnostic_context *context, int value /*= -1 */)
192 /* value == -1 is the default value. */
193 if (value < 0)
195 /* If DIAGNOSTICS_COLOR_DEFAULT is -1, default to
196 -fdiagnostics-color=auto if GCC_COLORS is in the environment,
197 otherwise default to -fdiagnostics-color=never, for other
198 values default to that
199 -fdiagnostics-color={never,auto,always}. */
200 if (DIAGNOSTICS_COLOR_DEFAULT == -1)
202 if (!getenv ("GCC_COLORS"))
203 return;
204 value = DIAGNOSTICS_COLOR_AUTO;
206 else
207 value = DIAGNOSTICS_COLOR_DEFAULT;
209 pp_show_color (context->printer)
210 = colorize_init ((diagnostic_color_rule_t) value);
213 /* Do any cleaning up required after the last diagnostic is emitted. */
215 void
216 diagnostic_finish (diagnostic_context *context)
218 /* Some of the errors may actually have been warnings. */
219 if (diagnostic_kind_count (context, DK_WERROR))
221 /* -Werror was given. */
222 if (context->warning_as_error_requested)
223 pp_verbatim (context->printer,
224 _("%s: all warnings being treated as errors"),
225 progname);
226 /* At least one -Werror= was given. */
227 else
228 pp_verbatim (context->printer,
229 _("%s: some warnings being treated as errors"),
230 progname);
231 pp_newline_and_flush (context->printer);
234 diagnostic_file_cache_fini ();
236 XDELETEVEC (context->classify_diagnostic);
237 context->classify_diagnostic = NULL;
239 /* diagnostic_initialize allocates context->printer using XNEW
240 and placement-new. */
241 context->printer->~pretty_printer ();
242 XDELETE (context->printer);
243 context->printer = NULL;
245 if (context->edit_context_ptr)
247 delete context->edit_context_ptr;
248 context->edit_context_ptr = NULL;
252 /* Initialize DIAGNOSTIC, where the message MSG has already been
253 translated. */
254 void
255 diagnostic_set_info_translated (diagnostic_info *diagnostic, const char *msg,
256 va_list *args, rich_location *richloc,
257 diagnostic_t kind)
259 gcc_assert (richloc);
260 diagnostic->message.err_no = errno;
261 diagnostic->message.args_ptr = args;
262 diagnostic->message.format_spec = msg;
263 diagnostic->message.m_richloc = richloc;
264 diagnostic->richloc = richloc;
265 diagnostic->kind = kind;
266 diagnostic->option_index = 0;
269 /* Initialize DIAGNOSTIC, where the message GMSGID has not yet been
270 translated. */
271 void
272 diagnostic_set_info (diagnostic_info *diagnostic, const char *gmsgid,
273 va_list *args, rich_location *richloc,
274 diagnostic_t kind)
276 gcc_assert (richloc);
277 diagnostic_set_info_translated (diagnostic, _(gmsgid), args, richloc, kind);
280 static const char *const diagnostic_kind_color[] = {
281 #define DEFINE_DIAGNOSTIC_KIND(K, T, C) (C),
282 #include "diagnostic.def"
283 #undef DEFINE_DIAGNOSTIC_KIND
284 NULL
287 /* Get a color name for diagnostics of type KIND
288 Result could be NULL. */
290 const char *
291 diagnostic_get_color_for_kind (diagnostic_t kind)
293 return diagnostic_kind_color[kind];
296 /* Return a malloc'd string describing a location e.g. "foo.c:42:10".
297 The caller is responsible for freeing the memory. */
299 static char *
300 diagnostic_get_location_text (diagnostic_context *context,
301 expanded_location s)
303 pretty_printer *pp = context->printer;
304 const char *locus_cs = colorize_start (pp_show_color (pp), "locus");
305 const char *locus_ce = colorize_stop (pp_show_color (pp));
307 if (s.file == NULL)
308 return build_message_string ("%s%s:%s", locus_cs, progname, locus_ce);
310 if (!strcmp (s.file, N_("<built-in>")))
311 return build_message_string ("%s%s:%s", locus_cs, s.file, locus_ce);
313 if (context->show_column)
314 return build_message_string ("%s%s:%d:%d:%s", locus_cs, s.file, s.line,
315 s.column, locus_ce);
316 else
317 return build_message_string ("%s%s:%d:%s", locus_cs, s.file, s.line,
318 locus_ce);
321 /* Return a malloc'd string describing a location and the severity of the
322 diagnostic, e.g. "foo.c:42:10: error: ". The caller is responsible for
323 freeing the memory. */
324 char *
325 diagnostic_build_prefix (diagnostic_context *context,
326 const diagnostic_info *diagnostic)
328 static const char *const diagnostic_kind_text[] = {
329 #define DEFINE_DIAGNOSTIC_KIND(K, T, C) (T),
330 #include "diagnostic.def"
331 #undef DEFINE_DIAGNOSTIC_KIND
332 "must-not-happen"
334 gcc_assert (diagnostic->kind < DK_LAST_DIAGNOSTIC_KIND);
336 const char *text = _(diagnostic_kind_text[diagnostic->kind]);
337 const char *text_cs = "", *text_ce = "";
338 pretty_printer *pp = context->printer;
340 if (diagnostic_kind_color[diagnostic->kind])
342 text_cs = colorize_start (pp_show_color (pp),
343 diagnostic_kind_color[diagnostic->kind]);
344 text_ce = colorize_stop (pp_show_color (pp));
347 expanded_location s = diagnostic_expand_location (diagnostic);
348 char *location_text = diagnostic_get_location_text (context, s);
350 char *result = build_message_string ("%s %s%s%s", location_text,
351 text_cs, text, text_ce);
352 free (location_text);
353 return result;
356 /* Functions at which to stop the backtrace print. It's not
357 particularly helpful to print the callers of these functions. */
359 static const char * const bt_stop[] =
361 "main",
362 "toplev::main",
363 "execute_one_pass",
364 "compile_file",
367 /* A callback function passed to the backtrace_full function. */
369 static int
370 bt_callback (void *data, uintptr_t pc, const char *filename, int lineno,
371 const char *function)
373 int *pcount = (int *) data;
375 /* If we don't have any useful information, don't print
376 anything. */
377 if (filename == NULL && function == NULL)
378 return 0;
380 /* Skip functions in diagnostic.c. */
381 if (*pcount == 0
382 && filename != NULL
383 && strcmp (lbasename (filename), "diagnostic.c") == 0)
384 return 0;
386 /* Print up to 20 functions. We could make this a --param, but
387 since this is only for debugging just use a constant for now. */
388 if (*pcount >= 20)
390 /* Returning a non-zero value stops the backtrace. */
391 return 1;
393 ++*pcount;
395 char *alc = NULL;
396 if (function != NULL)
398 char *str = cplus_demangle_v3 (function,
399 (DMGL_VERBOSE | DMGL_ANSI
400 | DMGL_GNU_V3 | DMGL_PARAMS));
401 if (str != NULL)
403 alc = str;
404 function = str;
407 for (size_t i = 0; i < ARRAY_SIZE (bt_stop); ++i)
409 size_t len = strlen (bt_stop[i]);
410 if (strncmp (function, bt_stop[i], len) == 0
411 && (function[len] == '\0' || function[len] == '('))
413 if (alc != NULL)
414 free (alc);
415 /* Returning a non-zero value stops the backtrace. */
416 return 1;
421 fprintf (stderr, "0x%lx %s\n\t%s:%d\n",
422 (unsigned long) pc,
423 function == NULL ? "???" : function,
424 filename == NULL ? "???" : filename,
425 lineno);
427 if (alc != NULL)
428 free (alc);
430 return 0;
433 /* A callback function passed to the backtrace_full function. This is
434 called if backtrace_full has an error. */
436 static void
437 bt_err_callback (void *data ATTRIBUTE_UNUSED, const char *msg, int errnum)
439 if (errnum < 0)
441 /* This means that no debug info was available. Just quietly
442 skip printing backtrace info. */
443 return;
445 fprintf (stderr, "%s%s%s\n", msg, errnum == 0 ? "" : ": ",
446 errnum == 0 ? "" : xstrerror (errnum));
449 /* Check if we've met the maximum error limit, and if so fatally exit
450 with a message. CONTEXT is the context to check, and FLUSH
451 indicates whether a diagnostic_finish call is needed. */
453 void
454 diagnostic_check_max_errors (diagnostic_context *context, bool flush)
456 if (!context->max_errors)
457 return;
459 int count = (diagnostic_kind_count (context, DK_ERROR)
460 + diagnostic_kind_count (context, DK_SORRY)
461 + diagnostic_kind_count (context, DK_WERROR));
463 if (count >= context->max_errors)
465 fnotice (stderr,
466 "compilation terminated due to -fmax-errors=%u.\n",
467 context->max_errors);
468 if (flush)
469 diagnostic_finish (context);
470 exit (FATAL_EXIT_CODE);
474 /* Take any action which is expected to happen after the diagnostic
475 is written out. This function does not always return. */
476 void
477 diagnostic_action_after_output (diagnostic_context *context,
478 diagnostic_t diag_kind)
480 switch (diag_kind)
482 case DK_DEBUG:
483 case DK_NOTE:
484 case DK_ANACHRONISM:
485 case DK_WARNING:
486 break;
488 case DK_ERROR:
489 case DK_SORRY:
490 if (context->abort_on_error)
491 real_abort ();
492 if (context->fatal_errors)
494 fnotice (stderr, "compilation terminated due to -Wfatal-errors.\n");
495 diagnostic_finish (context);
496 exit (FATAL_EXIT_CODE);
498 break;
500 case DK_ICE:
501 case DK_ICE_NOBT:
503 struct backtrace_state *state = NULL;
504 if (diag_kind == DK_ICE)
505 state = backtrace_create_state (NULL, 0, bt_err_callback, NULL);
506 int count = 0;
507 if (state != NULL)
508 backtrace_full (state, 2, bt_callback, bt_err_callback,
509 (void *) &count);
511 if (context->abort_on_error)
512 real_abort ();
514 fnotice (stderr, "Please submit a full bug report,\n"
515 "with preprocessed source if appropriate.\n");
516 if (count > 0)
517 fnotice (stderr,
518 ("Please include the complete backtrace "
519 "with any bug report.\n"));
520 fnotice (stderr, "See %s for instructions.\n", bug_report_url);
522 exit (ICE_EXIT_CODE);
525 case DK_FATAL:
526 if (context->abort_on_error)
527 real_abort ();
528 diagnostic_finish (context);
529 fnotice (stderr, "compilation terminated.\n");
530 exit (FATAL_EXIT_CODE);
532 default:
533 gcc_unreachable ();
537 /* True if the last module or file in which a diagnostic was reported is
538 different from the current one. */
540 static bool
541 last_module_changed_p (diagnostic_context *context,
542 const line_map_ordinary *map)
544 return context->last_module != map;
547 /* Remember the current module or file as being the last one in which we
548 report a diagnostic. */
550 static void
551 set_last_module (diagnostic_context *context, const line_map_ordinary *map)
553 context->last_module = map;
556 void
557 diagnostic_report_current_module (diagnostic_context *context, location_t where)
559 const line_map_ordinary *map = NULL;
561 if (pp_needs_newline (context->printer))
563 pp_newline (context->printer);
564 pp_needs_newline (context->printer) = false;
567 if (where <= BUILTINS_LOCATION)
568 return;
570 linemap_resolve_location (line_table, where,
571 LRK_MACRO_DEFINITION_LOCATION,
572 &map);
574 if (map && last_module_changed_p (context, map))
576 set_last_module (context, map);
577 if (! MAIN_FILE_P (map))
579 map = INCLUDED_FROM (line_table, map);
580 if (context->show_column)
581 pp_verbatim (context->printer,
582 "In file included from %r%s:%d:%d%R", "locus",
583 LINEMAP_FILE (map),
584 LAST_SOURCE_LINE (map), LAST_SOURCE_COLUMN (map));
585 else
586 pp_verbatim (context->printer,
587 "In file included from %r%s:%d%R", "locus",
588 LINEMAP_FILE (map), LAST_SOURCE_LINE (map));
589 while (! MAIN_FILE_P (map))
591 map = INCLUDED_FROM (line_table, map);
592 pp_verbatim (context->printer,
593 ",\n from %r%s:%d%R", "locus",
594 LINEMAP_FILE (map), LAST_SOURCE_LINE (map));
596 pp_verbatim (context->printer, ":");
597 pp_newline (context->printer);
602 void
603 default_diagnostic_starter (diagnostic_context *context,
604 diagnostic_info *diagnostic)
606 diagnostic_report_current_module (context, diagnostic_location (diagnostic));
607 pp_set_prefix (context->printer, diagnostic_build_prefix (context,
608 diagnostic));
611 void
612 default_diagnostic_start_span_fn (diagnostic_context *context,
613 expanded_location exploc)
615 pp_set_prefix (context->printer,
616 diagnostic_get_location_text (context, exploc));
617 pp_string (context->printer, "");
618 pp_newline (context->printer);
621 void
622 default_diagnostic_finalizer (diagnostic_context *context,
623 diagnostic_info *diagnostic)
625 diagnostic_show_locus (context, diagnostic->richloc, diagnostic->kind);
626 pp_destroy_prefix (context->printer);
627 pp_flush (context->printer);
630 /* Interface to specify diagnostic kind overrides. Returns the
631 previous setting, or DK_UNSPECIFIED if the parameters are out of
632 range. If OPTION_INDEX is zero, the new setting is for all the
633 diagnostics. */
634 diagnostic_t
635 diagnostic_classify_diagnostic (diagnostic_context *context,
636 int option_index,
637 diagnostic_t new_kind,
638 location_t where)
640 diagnostic_t old_kind;
642 if (option_index < 0
643 || option_index >= context->n_opts
644 || new_kind >= DK_LAST_DIAGNOSTIC_KIND)
645 return DK_UNSPECIFIED;
647 old_kind = context->classify_diagnostic[option_index];
649 /* Handle pragmas separately, since we need to keep track of *where*
650 the pragmas were. */
651 if (where != UNKNOWN_LOCATION)
653 int i;
655 /* Record the command-line status, so we can reset it back on DK_POP. */
656 if (old_kind == DK_UNSPECIFIED)
658 old_kind = !context->option_enabled (option_index,
659 context->option_state)
660 ? DK_IGNORED : (context->warning_as_error_requested
661 ? DK_ERROR : DK_WARNING);
662 context->classify_diagnostic[option_index] = old_kind;
665 for (i = context->n_classification_history - 1; i >= 0; i --)
666 if (context->classification_history[i].option == option_index)
668 old_kind = context->classification_history[i].kind;
669 break;
672 i = context->n_classification_history;
673 context->classification_history =
674 (diagnostic_classification_change_t *) xrealloc (context->classification_history, (i + 1)
675 * sizeof (diagnostic_classification_change_t));
676 context->classification_history[i].location = where;
677 context->classification_history[i].option = option_index;
678 context->classification_history[i].kind = new_kind;
679 context->n_classification_history ++;
681 else
682 context->classify_diagnostic[option_index] = new_kind;
684 return old_kind;
687 /* Save all diagnostic classifications in a stack. */
688 void
689 diagnostic_push_diagnostics (diagnostic_context *context, location_t where ATTRIBUTE_UNUSED)
691 context->push_list = (int *) xrealloc (context->push_list, (context->n_push + 1) * sizeof (int));
692 context->push_list[context->n_push ++] = context->n_classification_history;
695 /* Restore the topmost classification set off the stack. If the stack
696 is empty, revert to the state based on command line parameters. */
697 void
698 diagnostic_pop_diagnostics (diagnostic_context *context, location_t where)
700 int jump_to;
701 int i;
703 if (context->n_push)
704 jump_to = context->push_list [-- context->n_push];
705 else
706 jump_to = 0;
708 i = context->n_classification_history;
709 context->classification_history =
710 (diagnostic_classification_change_t *) xrealloc (context->classification_history, (i + 1)
711 * sizeof (diagnostic_classification_change_t));
712 context->classification_history[i].location = where;
713 context->classification_history[i].option = jump_to;
714 context->classification_history[i].kind = DK_POP;
715 context->n_classification_history ++;
718 /* Helper function for print_parseable_fixits. Print TEXT to PP, obeying the
719 escaping rules for -fdiagnostics-parseable-fixits. */
721 static void
722 print_escaped_string (pretty_printer *pp, const char *text)
724 gcc_assert (pp);
725 gcc_assert (text);
727 pp_character (pp, '"');
728 for (const char *ch = text; *ch; ch++)
730 switch (*ch)
732 case '\\':
733 /* Escape backslash as two backslashes. */
734 pp_string (pp, "\\\\");
735 break;
736 case '\t':
737 /* Escape tab as "\t". */
738 pp_string (pp, "\\t");
739 break;
740 case '\n':
741 /* Escape newline as "\n". */
742 pp_string (pp, "\\n");
743 break;
744 case '"':
745 /* Escape doublequotes as \". */
746 pp_string (pp, "\\\"");
747 break;
748 default:
749 if (ISPRINT (*ch))
750 pp_character (pp, *ch);
751 else
752 /* Use octal for non-printable chars. */
754 unsigned char c = (*ch & 0xff);
755 pp_printf (pp, "\\%o%o%o", (c / 64), (c / 8) & 007, c & 007);
757 break;
760 pp_character (pp, '"');
763 /* Implementation of -fdiagnostics-parseable-fixits. Print a
764 machine-parseable version of all fixits in RICHLOC to PP. */
766 static void
767 print_parseable_fixits (pretty_printer *pp, rich_location *richloc)
769 gcc_assert (pp);
770 gcc_assert (richloc);
772 for (unsigned i = 0; i < richloc->get_num_fixit_hints (); i++)
774 const fixit_hint *hint = richloc->get_fixit_hint (i);
775 source_location start_loc = hint->get_start_loc ();
776 expanded_location start_exploc = expand_location (start_loc);
777 pp_string (pp, "fix-it:");
778 print_escaped_string (pp, start_exploc.file);
779 /* For compatibility with clang, print as a half-open range. */
780 source_location next_loc = hint->get_next_loc ();
781 expanded_location next_exploc = expand_location (next_loc);
782 pp_printf (pp, ":{%i:%i-%i:%i}:",
783 start_exploc.line, start_exploc.column,
784 next_exploc.line, next_exploc.column);
785 print_escaped_string (pp, hint->get_string ());
786 pp_newline (pp);
790 /* Update the diag_class of DIAGNOSTIC based on its location
791 relative to any
792 #pragma GCC diagnostic
793 directives recorded within CONTEXT.
795 Return the new diag_class of DIAGNOSTIC if it was updated, or
796 DK_UNSPECIFIED otherwise. */
798 static diagnostic_t
799 update_effective_level_from_pragmas (diagnostic_context *context,
800 diagnostic_info *diagnostic)
802 diagnostic_t diag_class = DK_UNSPECIFIED;
804 if (context->n_classification_history > 0)
806 location_t location = diagnostic_location (diagnostic);
808 /* FIXME: Stupid search. Optimize later. */
809 for (int i = context->n_classification_history - 1; i >= 0; i --)
811 if (linemap_location_before_p
812 (line_table,
813 context->classification_history[i].location,
814 location))
816 if (context->classification_history[i].kind == (int) DK_POP)
818 i = context->classification_history[i].option;
819 continue;
821 int option = context->classification_history[i].option;
822 /* The option 0 is for all the diagnostics. */
823 if (option == 0 || option == diagnostic->option_index)
825 diag_class = context->classification_history[i].kind;
826 if (diag_class != DK_UNSPECIFIED)
827 diagnostic->kind = diag_class;
828 break;
834 return diag_class;
837 /* Print any metadata about the option used to control DIAGNOSTIC to CONTEXT's
838 printer, e.g. " [-Werror=uninitialized]".
839 Subroutine of diagnostic_report_diagnostic. */
841 static void
842 print_option_information (diagnostic_context *context,
843 const diagnostic_info *diagnostic,
844 diagnostic_t orig_diag_kind)
846 char *option_text;
848 option_text = context->option_name (context, diagnostic->option_index,
849 orig_diag_kind, diagnostic->kind);
851 if (option_text)
853 pretty_printer *pp = context->printer;
854 pp_string (pp, " [");
855 pp_string (pp, colorize_start (pp_show_color (pp),
856 diagnostic_kind_color[diagnostic->kind]));
857 pp_string (pp, option_text);
858 pp_string (pp, colorize_stop (pp_show_color (pp)));
859 pp_character (pp, ']');
860 free (option_text);
864 /* Report a diagnostic message (an error or a warning) as specified by
865 DC. This function is *the* subroutine in terms of which front-ends
866 should implement their specific diagnostic handling modules. The
867 front-end independent format specifiers are exactly those described
868 in the documentation of output_format.
869 Return true if a diagnostic was printed, false otherwise. */
871 bool
872 diagnostic_report_diagnostic (diagnostic_context *context,
873 diagnostic_info *diagnostic)
875 location_t location = diagnostic_location (diagnostic);
876 diagnostic_t orig_diag_kind = diagnostic->kind;
878 /* Give preference to being able to inhibit warnings, before they
879 get reclassified to something else. */
880 if ((diagnostic->kind == DK_WARNING || diagnostic->kind == DK_PEDWARN)
881 && !diagnostic_report_warnings_p (context, location))
882 return false;
884 if (diagnostic->kind == DK_PEDWARN)
886 diagnostic->kind = pedantic_warning_kind (context);
887 /* We do this to avoid giving the message for -pedantic-errors. */
888 orig_diag_kind = diagnostic->kind;
891 if (diagnostic->kind == DK_NOTE && context->inhibit_notes_p)
892 return false;
894 if (context->lock > 0)
896 /* If we're reporting an ICE in the middle of some other error,
897 try to flush out the previous error, then let this one
898 through. Don't do this more than once. */
899 if ((diagnostic->kind == DK_ICE || diagnostic->kind == DK_ICE_NOBT)
900 && context->lock == 1)
901 pp_newline_and_flush (context->printer);
902 else
903 error_recursion (context);
906 /* If the user requested that warnings be treated as errors, so be
907 it. Note that we do this before the next block so that
908 individual warnings can be overridden back to warnings with
909 -Wno-error=*. */
910 if (context->warning_as_error_requested
911 && diagnostic->kind == DK_WARNING)
912 diagnostic->kind = DK_ERROR;
914 if (diagnostic->option_index
915 && diagnostic->option_index != permissive_error_option (context))
917 /* This tests if the user provided the appropriate -Wfoo or
918 -Wno-foo option. */
919 if (! context->option_enabled (diagnostic->option_index,
920 context->option_state))
921 return false;
923 /* This tests for #pragma diagnostic changes. */
924 diagnostic_t diag_class
925 = update_effective_level_from_pragmas (context, diagnostic);
927 /* This tests if the user provided the appropriate -Werror=foo
928 option. */
929 if (diag_class == DK_UNSPECIFIED
930 && (context->classify_diagnostic[diagnostic->option_index]
931 != DK_UNSPECIFIED))
932 diagnostic->kind
933 = context->classify_diagnostic[diagnostic->option_index];
935 /* This allows for future extensions, like temporarily disabling
936 warnings for ranges of source code. */
937 if (diagnostic->kind == DK_IGNORED)
938 return false;
941 if (diagnostic->kind != DK_NOTE)
942 diagnostic_check_max_errors (context);
944 context->lock++;
946 if (diagnostic->kind == DK_ICE || diagnostic->kind == DK_ICE_NOBT)
948 /* When not checking, ICEs are converted to fatal errors when an
949 error has already occurred. This is counteracted by
950 abort_on_error. */
951 if (!CHECKING_P
952 && (diagnostic_kind_count (context, DK_ERROR) > 0
953 || diagnostic_kind_count (context, DK_SORRY) > 0)
954 && !context->abort_on_error)
956 expanded_location s
957 = expand_location (diagnostic_location (diagnostic));
958 fnotice (stderr, "%s:%d: confused by earlier errors, bailing out\n",
959 s.file, s.line);
960 exit (ICE_EXIT_CODE);
962 if (context->internal_error)
963 (*context->internal_error) (context,
964 diagnostic->message.format_spec,
965 diagnostic->message.args_ptr);
967 if (diagnostic->kind == DK_ERROR && orig_diag_kind == DK_WARNING)
968 ++diagnostic_kind_count (context, DK_WERROR);
969 else
970 ++diagnostic_kind_count (context, diagnostic->kind);
972 diagnostic->message.x_data = &diagnostic->x_data;
973 diagnostic->x_data = NULL;
974 pp_format (context->printer, &diagnostic->message);
975 (*diagnostic_starter (context)) (context, diagnostic);
976 pp_output_formatted_text (context->printer);
977 if (context->show_option_requested)
978 print_option_information (context, diagnostic, orig_diag_kind);
979 (*diagnostic_finalizer (context)) (context, diagnostic);
980 if (context->parseable_fixits_p)
982 print_parseable_fixits (context->printer, diagnostic->richloc);
983 pp_flush (context->printer);
985 diagnostic_action_after_output (context, diagnostic->kind);
986 diagnostic->x_data = NULL;
988 if (context->edit_context_ptr)
989 if (diagnostic->richloc->fixits_can_be_auto_applied_p ())
990 context->edit_context_ptr->add_fixits (diagnostic->richloc);
992 context->lock--;
994 return true;
997 /* Given a partial pathname as input, return another pathname that
998 shares no directory elements with the pathname of __FILE__. This
999 is used by fancy_abort() to print `Internal compiler error in expr.c'
1000 instead of `Internal compiler error in ../../GCC/gcc/expr.c'. */
1002 const char *
1003 trim_filename (const char *name)
1005 static const char this_file[] = __FILE__;
1006 const char *p = name, *q = this_file;
1008 /* First skip any "../" in each filename. This allows us to give a proper
1009 reference to a file in a subdirectory. */
1010 while (p[0] == '.' && p[1] == '.' && IS_DIR_SEPARATOR (p[2]))
1011 p += 3;
1013 while (q[0] == '.' && q[1] == '.' && IS_DIR_SEPARATOR (q[2]))
1014 q += 3;
1016 /* Now skip any parts the two filenames have in common. */
1017 while (*p == *q && *p != 0 && *q != 0)
1018 p++, q++;
1020 /* Now go backwards until the previous directory separator. */
1021 while (p > name && !IS_DIR_SEPARATOR (p[-1]))
1022 p--;
1024 return p;
1027 /* Standard error reporting routines in increasing order of severity.
1028 All of these take arguments like printf. */
1030 /* Text to be emitted verbatim to the error message stream; this
1031 produces no prefix and disables line-wrapping. Use rarely. */
1032 void
1033 verbatim (const char *gmsgid, ...)
1035 text_info text;
1036 va_list ap;
1038 va_start (ap, gmsgid);
1039 text.err_no = errno;
1040 text.args_ptr = &ap;
1041 text.format_spec = _(gmsgid);
1042 text.x_data = NULL;
1043 pp_format_verbatim (global_dc->printer, &text);
1044 pp_newline_and_flush (global_dc->printer);
1045 va_end (ap);
1048 /* Add a note with text GMSGID and with LOCATION to the diagnostic CONTEXT. */
1049 void
1050 diagnostic_append_note (diagnostic_context *context,
1051 location_t location,
1052 const char * gmsgid, ...)
1054 diagnostic_info diagnostic;
1055 va_list ap;
1056 const char *saved_prefix;
1057 rich_location richloc (line_table, location);
1059 va_start (ap, gmsgid);
1060 diagnostic_set_info (&diagnostic, gmsgid, &ap, &richloc, DK_NOTE);
1061 if (context->inhibit_notes_p)
1063 va_end (ap);
1064 return;
1066 saved_prefix = pp_get_prefix (context->printer);
1067 pp_set_prefix (context->printer,
1068 diagnostic_build_prefix (context, &diagnostic));
1069 pp_format (context->printer, &diagnostic.message);
1070 pp_output_formatted_text (context->printer);
1071 pp_destroy_prefix (context->printer);
1072 pp_set_prefix (context->printer, saved_prefix);
1073 diagnostic_show_locus (context, &richloc, DK_NOTE);
1074 va_end (ap);
1077 /* Implement emit_diagnostic, inform, inform_at_rich_loc, warning, warning_at,
1078 warning_at_rich_loc, pedwarn, permerror, permerror_at_rich_loc, error,
1079 error_at, error_at_rich_loc, sorry, fatal_error, internal_error, and
1080 internal_error_no_backtrace, as documented and defined below. */
1081 static bool
1082 diagnostic_impl (rich_location *richloc, int opt,
1083 const char *gmsgid,
1084 va_list *ap, diagnostic_t kind)
1086 diagnostic_info diagnostic;
1087 if (kind == DK_PERMERROR)
1089 diagnostic_set_info (&diagnostic, gmsgid, ap, richloc,
1090 permissive_error_kind (global_dc));
1091 diagnostic.option_index = permissive_error_option (global_dc);
1093 else
1095 diagnostic_set_info (&diagnostic, gmsgid, ap, richloc, kind);
1096 if (kind == DK_WARNING || kind == DK_PEDWARN)
1097 diagnostic.option_index = opt;
1099 return diagnostic_report_diagnostic (global_dc, &diagnostic);
1102 /* Same as diagonostic_n_impl taking rich_location instead of location_t. */
1103 static bool
1104 diagnostic_n_impl_richloc (rich_location *richloc, int opt, int n,
1105 const char *singular_gmsgid,
1106 const char *plural_gmsgid,
1107 va_list *ap, diagnostic_t kind)
1109 diagnostic_info diagnostic;
1110 diagnostic_set_info_translated (&diagnostic,
1111 ngettext (singular_gmsgid, plural_gmsgid, n),
1112 ap, richloc, kind);
1113 if (kind == DK_WARNING)
1114 diagnostic.option_index = opt;
1115 return diagnostic_report_diagnostic (global_dc, &diagnostic);
1118 /* Implement inform_n, warning_n, and error_n, as documented and
1119 defined below. */
1120 static bool
1121 diagnostic_n_impl (location_t location, int opt, int n,
1122 const char *singular_gmsgid,
1123 const char *plural_gmsgid,
1124 va_list *ap, diagnostic_t kind)
1126 rich_location richloc (line_table, location);
1127 return diagnostic_n_impl_richloc (&richloc, opt, n,
1128 singular_gmsgid, plural_gmsgid, ap, kind);
1131 bool
1132 emit_diagnostic (diagnostic_t kind, location_t location, int opt,
1133 const char *gmsgid, ...)
1135 va_list ap;
1136 va_start (ap, gmsgid);
1137 rich_location richloc (line_table, location);
1138 bool ret = diagnostic_impl (&richloc, opt, gmsgid, &ap, kind);
1139 va_end (ap);
1140 return ret;
1143 /* An informative note at LOCATION. Use this for additional details on an error
1144 message. */
1145 void
1146 inform (location_t location, const char *gmsgid, ...)
1148 va_list ap;
1149 va_start (ap, gmsgid);
1150 rich_location richloc (line_table, location);
1151 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_NOTE);
1152 va_end (ap);
1155 /* Same as "inform", but at RICHLOC. */
1156 void
1157 inform_at_rich_loc (rich_location *richloc, const char *gmsgid, ...)
1159 va_list ap;
1160 va_start (ap, gmsgid);
1161 diagnostic_impl (richloc, -1, gmsgid, &ap, DK_NOTE);
1162 va_end (ap);
1165 /* An informative note at LOCATION. Use this for additional details on an
1166 error message. */
1167 void
1168 inform_n (location_t location, int n, const char *singular_gmsgid,
1169 const char *plural_gmsgid, ...)
1171 va_list ap;
1172 va_start (ap, plural_gmsgid);
1173 diagnostic_n_impl (location, -1, n, singular_gmsgid, plural_gmsgid,
1174 &ap, DK_NOTE);
1175 va_end (ap);
1178 /* A warning at INPUT_LOCATION. Use this for code which is correct according
1179 to the relevant language specification but is likely to be buggy anyway.
1180 Returns true if the warning was printed, false if it was inhibited. */
1181 bool
1182 warning (int opt, const char *gmsgid, ...)
1184 va_list ap;
1185 va_start (ap, gmsgid);
1186 rich_location richloc (line_table, input_location);
1187 bool ret = diagnostic_impl (&richloc, opt, gmsgid, &ap, DK_WARNING);
1188 va_end (ap);
1189 return ret;
1192 /* A warning at LOCATION. Use this for code which is correct according to the
1193 relevant language specification but is likely to be buggy anyway.
1194 Returns true if the warning was printed, false if it was inhibited. */
1196 bool
1197 warning_at (location_t location, int opt, const char *gmsgid, ...)
1199 va_list ap;
1200 va_start (ap, gmsgid);
1201 rich_location richloc (line_table, location);
1202 bool ret = diagnostic_impl (&richloc, opt, gmsgid, &ap, DK_WARNING);
1203 va_end (ap);
1204 return ret;
1207 /* Same as warning at, but using RICHLOC. */
1209 bool
1210 warning_at_rich_loc (rich_location *richloc, int opt, const char *gmsgid, ...)
1212 va_list ap;
1213 va_start (ap, gmsgid);
1214 bool ret = diagnostic_impl (richloc, opt, gmsgid, &ap, DK_WARNING);
1215 va_end (ap);
1216 return ret;
1219 /* Same as warning_at_rich_loc but for plural variant. */
1221 bool
1222 warning_at_rich_loc_n (rich_location *richloc, int opt, int n,
1223 const char *singular_gmsgid, const char *plural_gmsgid, ...)
1225 va_list ap;
1226 va_start (ap, plural_gmsgid);
1227 bool ret = diagnostic_n_impl_richloc (richloc, opt, n,
1228 singular_gmsgid, plural_gmsgid,
1229 &ap, DK_WARNING);
1230 va_end (ap);
1231 return ret;
1234 /* A warning at LOCATION. Use this for code which is correct according to the
1235 relevant language specification but is likely to be buggy anyway.
1236 Returns true if the warning was printed, false if it was inhibited. */
1238 bool
1239 warning_n (location_t location, int opt, int n, const char *singular_gmsgid,
1240 const char *plural_gmsgid, ...)
1242 va_list ap;
1243 va_start (ap, plural_gmsgid);
1244 bool ret = diagnostic_n_impl (location, opt, n,
1245 singular_gmsgid, plural_gmsgid,
1246 &ap, DK_WARNING);
1247 va_end (ap);
1248 return ret;
1251 /* A "pedantic" warning at LOCATION: issues a warning unless
1252 -pedantic-errors was given on the command line, in which case it
1253 issues an error. Use this for diagnostics required by the relevant
1254 language standard, if you have chosen not to make them errors.
1256 Note that these diagnostics are issued independent of the setting
1257 of the -Wpedantic command-line switch. To get a warning enabled
1258 only with that switch, use either "if (pedantic) pedwarn
1259 (OPT_Wpedantic,...)" or just "pedwarn (OPT_Wpedantic,..)". To get a
1260 pedwarn independently of the -Wpedantic switch use "pedwarn (0,...)".
1262 Returns true if the warning was printed, false if it was inhibited. */
1264 bool
1265 pedwarn (location_t location, int opt, const char *gmsgid, ...)
1267 va_list ap;
1268 va_start (ap, gmsgid);
1269 rich_location richloc (line_table, location);
1270 bool ret = diagnostic_impl (&richloc, opt, gmsgid, &ap, DK_PEDWARN);
1271 va_end (ap);
1272 return ret;
1275 /* Same as pedwarn, but using RICHLOC. */
1277 bool
1278 pedwarn_at_rich_loc (rich_location *richloc, int opt, const char *gmsgid, ...)
1280 va_list ap;
1281 va_start (ap, gmsgid);
1282 bool ret = diagnostic_impl (richloc, opt, gmsgid, &ap, DK_PEDWARN);
1283 va_end (ap);
1284 return ret;
1287 /* A "permissive" error at LOCATION: issues an error unless
1288 -fpermissive was given on the command line, in which case it issues
1289 a warning. Use this for things that really should be errors but we
1290 want to support legacy code.
1292 Returns true if the warning was printed, false if it was inhibited. */
1294 bool
1295 permerror (location_t location, const char *gmsgid, ...)
1297 va_list ap;
1298 va_start (ap, gmsgid);
1299 rich_location richloc (line_table, location);
1300 bool ret = diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_PERMERROR);
1301 va_end (ap);
1302 return ret;
1305 /* Same as "permerror", but at RICHLOC. */
1307 bool
1308 permerror_at_rich_loc (rich_location *richloc, const char *gmsgid, ...)
1310 va_list ap;
1311 va_start (ap, gmsgid);
1312 bool ret = diagnostic_impl (richloc, -1, gmsgid, &ap, DK_PERMERROR);
1313 va_end (ap);
1314 return ret;
1317 /* A hard error: the code is definitely ill-formed, and an object file
1318 will not be produced. */
1319 void
1320 error (const char *gmsgid, ...)
1322 va_list ap;
1323 va_start (ap, gmsgid);
1324 rich_location richloc (line_table, input_location);
1325 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_ERROR);
1326 va_end (ap);
1329 /* A hard error: the code is definitely ill-formed, and an object file
1330 will not be produced. */
1331 void
1332 error_n (location_t location, int n, const char *singular_gmsgid,
1333 const char *plural_gmsgid, ...)
1335 va_list ap;
1336 va_start (ap, plural_gmsgid);
1337 diagnostic_n_impl (location, -1, n, singular_gmsgid, plural_gmsgid,
1338 &ap, DK_ERROR);
1339 va_end (ap);
1342 /* Same as above, but use location LOC instead of input_location. */
1343 void
1344 error_at (location_t loc, const char *gmsgid, ...)
1346 va_list ap;
1347 va_start (ap, gmsgid);
1348 rich_location richloc (line_table, loc);
1349 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_ERROR);
1350 va_end (ap);
1353 /* Same as above, but use RICH_LOC. */
1355 void
1356 error_at_rich_loc (rich_location *richloc, const char *gmsgid, ...)
1358 va_list ap;
1359 va_start (ap, gmsgid);
1360 diagnostic_impl (richloc, -1, gmsgid, &ap, DK_ERROR);
1361 va_end (ap);
1364 /* "Sorry, not implemented." Use for a language feature which is
1365 required by the relevant specification but not implemented by GCC.
1366 An object file will not be produced. */
1367 void
1368 sorry (const char *gmsgid, ...)
1370 va_list ap;
1371 va_start (ap, gmsgid);
1372 rich_location richloc (line_table, input_location);
1373 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_SORRY);
1374 va_end (ap);
1377 /* Return true if an error or a "sorry" has been seen. Various
1378 processing is disabled after errors. */
1379 bool
1380 seen_error (void)
1382 return errorcount || sorrycount;
1385 /* An error which is severe enough that we make no attempt to
1386 continue. Do not use this for internal consistency checks; that's
1387 internal_error. Use of this function should be rare. */
1388 void
1389 fatal_error (location_t loc, const char *gmsgid, ...)
1391 va_list ap;
1392 va_start (ap, gmsgid);
1393 rich_location richloc (line_table, loc);
1394 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_FATAL);
1395 va_end (ap);
1397 gcc_unreachable ();
1400 /* An internal consistency check has failed. We make no attempt to
1401 continue. Note that unless there is debugging value to be had from
1402 a more specific message, or some other good reason, you should use
1403 abort () instead of calling this function directly. */
1404 void
1405 internal_error (const char *gmsgid, ...)
1407 va_list ap;
1408 va_start (ap, gmsgid);
1409 rich_location richloc (line_table, input_location);
1410 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_ICE);
1411 va_end (ap);
1413 gcc_unreachable ();
1416 /* Like internal_error, but no backtrace will be printed. Used when
1417 the internal error does not happen at the current location, but happened
1418 somewhere else. */
1419 void
1420 internal_error_no_backtrace (const char *gmsgid, ...)
1422 va_list ap;
1423 va_start (ap, gmsgid);
1424 rich_location richloc (line_table, input_location);
1425 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_ICE_NOBT);
1426 va_end (ap);
1428 gcc_unreachable ();
1431 /* Special case error functions. Most are implemented in terms of the
1432 above, or should be. */
1434 /* Print a diagnostic MSGID on FILE. This is just fprintf, except it
1435 runs its second argument through gettext. */
1436 void
1437 fnotice (FILE *file, const char *cmsgid, ...)
1439 va_list ap;
1441 va_start (ap, cmsgid);
1442 vfprintf (file, _(cmsgid), ap);
1443 va_end (ap);
1446 /* Inform the user that an error occurred while trying to report some
1447 other error. This indicates catastrophic internal inconsistencies,
1448 so give up now. But do try to flush out the previous error.
1449 This mustn't use internal_error, that will cause infinite recursion. */
1451 static void
1452 error_recursion (diagnostic_context *context)
1454 if (context->lock < 3)
1455 pp_newline_and_flush (context->printer);
1457 fnotice (stderr,
1458 "Internal compiler error: Error reporting routines re-entered.\n");
1460 /* Call diagnostic_action_after_output to get the "please submit a bug
1461 report" message. */
1462 diagnostic_action_after_output (context, DK_ICE);
1464 /* Do not use gcc_unreachable here; that goes through internal_error
1465 and therefore would cause infinite recursion. */
1466 real_abort ();
1469 /* Report an internal compiler error in a friendly manner. This is
1470 the function that gets called upon use of abort() in the source
1471 code generally, thanks to a special macro. */
1473 void
1474 fancy_abort (const char *file, int line, const char *function)
1476 internal_error ("in %s, at %s:%d", function, trim_filename (file), line);
1479 /* Really call the system 'abort'. This has to go right at the end of
1480 this file, so that there are no functions after it that call abort
1481 and get the system abort instead of our macro. */
1482 #undef abort
1483 static void
1484 real_abort (void)
1486 abort ();
1489 #if CHECKING_P
1491 namespace selftest {
1493 /* Helper function for test_print_escaped_string. */
1495 static void
1496 assert_print_escaped_string (const location &loc, const char *expected_output,
1497 const char *input)
1499 pretty_printer pp;
1500 print_escaped_string (&pp, input);
1501 ASSERT_STREQ_AT (loc, expected_output, pp_formatted_text (&pp));
1504 #define ASSERT_PRINT_ESCAPED_STRING_STREQ(EXPECTED_OUTPUT, INPUT) \
1505 assert_print_escaped_string (SELFTEST_LOCATION, EXPECTED_OUTPUT, INPUT)
1507 /* Tests of print_escaped_string. */
1509 static void
1510 test_print_escaped_string ()
1512 /* Empty string. */
1513 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"\"", "");
1515 /* Non-empty string. */
1516 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"hello world\"", "hello world");
1518 /* Various things that need to be escaped: */
1519 /* Backslash. */
1520 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\\\after\"",
1521 "before\\after");
1522 /* Tab. */
1523 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\tafter\"",
1524 "before\tafter");
1525 /* Newline. */
1526 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\nafter\"",
1527 "before\nafter");
1528 /* Double quote. */
1529 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\\"after\"",
1530 "before\"after");
1532 /* Non-printable characters: BEL: '\a': 0x07 */
1533 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\007after\"",
1534 "before\aafter");
1535 /* Non-printable characters: vertical tab: '\v': 0x0b */
1536 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\013after\"",
1537 "before\vafter");
1540 /* Tests of print_parseable_fixits. */
1542 /* Verify that print_parseable_fixits emits the empty string if there
1543 are no fixits. */
1545 static void
1546 test_print_parseable_fixits_none ()
1548 pretty_printer pp;
1549 rich_location richloc (line_table, UNKNOWN_LOCATION);
1551 print_parseable_fixits (&pp, &richloc);
1552 ASSERT_STREQ ("", pp_formatted_text (&pp));
1555 /* Verify that print_parseable_fixits does the right thing if there
1556 is an insertion fixit hint. */
1558 static void
1559 test_print_parseable_fixits_insert ()
1561 pretty_printer pp;
1562 rich_location richloc (line_table, UNKNOWN_LOCATION);
1564 linemap_add (line_table, LC_ENTER, false, "test.c", 0);
1565 linemap_line_start (line_table, 5, 100);
1566 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
1567 location_t where = linemap_position_for_column (line_table, 10);
1568 richloc.add_fixit_insert_before (where, "added content");
1570 print_parseable_fixits (&pp, &richloc);
1571 ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:10}:\"added content\"\n",
1572 pp_formatted_text (&pp));
1575 /* Verify that print_parseable_fixits does the right thing if there
1576 is an removal fixit hint. */
1578 static void
1579 test_print_parseable_fixits_remove ()
1581 pretty_printer pp;
1582 rich_location richloc (line_table, UNKNOWN_LOCATION);
1584 linemap_add (line_table, LC_ENTER, false, "test.c", 0);
1585 linemap_line_start (line_table, 5, 100);
1586 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
1587 source_range where;
1588 where.m_start = linemap_position_for_column (line_table, 10);
1589 where.m_finish = linemap_position_for_column (line_table, 20);
1590 richloc.add_fixit_remove (where);
1592 print_parseable_fixits (&pp, &richloc);
1593 ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:21}:\"\"\n",
1594 pp_formatted_text (&pp));
1597 /* Verify that print_parseable_fixits does the right thing if there
1598 is an replacement fixit hint. */
1600 static void
1601 test_print_parseable_fixits_replace ()
1603 pretty_printer pp;
1604 rich_location richloc (line_table, UNKNOWN_LOCATION);
1606 linemap_add (line_table, LC_ENTER, false, "test.c", 0);
1607 linemap_line_start (line_table, 5, 100);
1608 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
1609 source_range where;
1610 where.m_start = linemap_position_for_column (line_table, 10);
1611 where.m_finish = linemap_position_for_column (line_table, 20);
1612 richloc.add_fixit_replace (where, "replacement");
1614 print_parseable_fixits (&pp, &richloc);
1615 ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:21}:\"replacement\"\n",
1616 pp_formatted_text (&pp));
1619 /* Run all of the selftests within this file. */
1621 void
1622 diagnostic_c_tests ()
1624 test_print_escaped_string ();
1625 test_print_parseable_fixits_none ();
1626 test_print_parseable_fixits_insert ();
1627 test_print_parseable_fixits_remove ();
1628 test_print_parseable_fixits_replace ();
1631 } // namespace selftest
1633 #endif /* #if CHECKING_P */