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
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* This file implements the language independent aspect of diagnostic
27 #include "coretypes.h"
31 #include "backtrace.h"
32 #include "diagnostic.h"
33 #include "diagnostic-color.h"
34 #include "edit-context.h"
36 #include "selftest-diagnostic.h"
42 #ifdef GWINSZ_IN_SYS_IOCTL
43 # include <sys/ioctl.h>
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)
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. */
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. */
72 build_message_string (const char *msg
, ...)
78 str
= xvasprintf (msg
, ap
);
84 /* Same as diagnostic_build_prefix, but only the source FILE is given. */
86 file_name_as_prefix (diagnostic_context
*context
, const char *f
)
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. */
100 get_terminal_width (void)
102 const char * s
= getenv ("COLUMNS");
112 if (ioctl (0, TIOCGWINSZ
, &w
) == 0 && w
.ws_col
> 0)
119 /* Set caret_max_width to value. */
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
);
131 context
->caret_max_width
= value
;
134 /* Initialize the diagnostic message outputting machinery. */
136 diagnostic_initialize (diagnostic_context
*context
, int n_opts
)
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
;
176 context
->inhibit_notes_p
= false;
177 context
->colorize_source_p
= false;
178 context
->show_line_numbers_p
= false;
179 context
->show_ruler_p
= false;
180 context
->parseable_fixits_p
= false;
181 context
->edit_context_ptr
= NULL
;
184 /* Maybe initialize the color support. We require clients to do this
185 explicitly, since most clients don't want color. When called
186 without a VALUE, it initializes with DIAGNOSTICS_COLOR_DEFAULT. */
189 diagnostic_color_init (diagnostic_context
*context
, int value
/*= -1 */)
191 /* value == -1 is the default value. */
194 /* If DIAGNOSTICS_COLOR_DEFAULT is -1, default to
195 -fdiagnostics-color=auto if GCC_COLORS is in the environment,
196 otherwise default to -fdiagnostics-color=never, for other
197 values default to that
198 -fdiagnostics-color={never,auto,always}. */
199 if (DIAGNOSTICS_COLOR_DEFAULT
== -1)
201 if (!getenv ("GCC_COLORS"))
203 value
= DIAGNOSTICS_COLOR_AUTO
;
206 value
= DIAGNOSTICS_COLOR_DEFAULT
;
208 pp_show_color (context
->printer
)
209 = colorize_init ((diagnostic_color_rule_t
) value
);
212 /* Do any cleaning up required after the last diagnostic is emitted. */
215 diagnostic_finish (diagnostic_context
*context
)
217 /* Some of the errors may actually have been warnings. */
218 if (diagnostic_kind_count (context
, DK_WERROR
))
220 /* -Werror was given. */
221 if (context
->warning_as_error_requested
)
222 pp_verbatim (context
->printer
,
223 _("%s: all warnings being treated as errors"),
225 /* At least one -Werror= was given. */
227 pp_verbatim (context
->printer
,
228 _("%s: some warnings being treated as errors"),
230 pp_newline_and_flush (context
->printer
);
233 diagnostic_file_cache_fini ();
235 XDELETEVEC (context
->classify_diagnostic
);
236 context
->classify_diagnostic
= NULL
;
238 /* diagnostic_initialize allocates context->printer using XNEW
239 and placement-new. */
240 context
->printer
->~pretty_printer ();
241 XDELETE (context
->printer
);
242 context
->printer
= NULL
;
244 if (context
->edit_context_ptr
)
246 delete context
->edit_context_ptr
;
247 context
->edit_context_ptr
= NULL
;
251 /* Initialize DIAGNOSTIC, where the message MSG has already been
254 diagnostic_set_info_translated (diagnostic_info
*diagnostic
, const char *msg
,
255 va_list *args
, rich_location
*richloc
,
258 gcc_assert (richloc
);
259 diagnostic
->message
.err_no
= errno
;
260 diagnostic
->message
.args_ptr
= args
;
261 diagnostic
->message
.format_spec
= msg
;
262 diagnostic
->message
.m_richloc
= richloc
;
263 diagnostic
->richloc
= richloc
;
264 diagnostic
->kind
= kind
;
265 diagnostic
->option_index
= 0;
268 /* Initialize DIAGNOSTIC, where the message GMSGID has not yet been
271 diagnostic_set_info (diagnostic_info
*diagnostic
, const char *gmsgid
,
272 va_list *args
, rich_location
*richloc
,
275 gcc_assert (richloc
);
276 diagnostic_set_info_translated (diagnostic
, _(gmsgid
), args
, richloc
, kind
);
279 static const char *const diagnostic_kind_color
[] = {
280 #define DEFINE_DIAGNOSTIC_KIND(K, T, C) (C),
281 #include "diagnostic.def"
282 #undef DEFINE_DIAGNOSTIC_KIND
286 /* Get a color name for diagnostics of type KIND
287 Result could be NULL. */
290 diagnostic_get_color_for_kind (diagnostic_t kind
)
292 return diagnostic_kind_color
[kind
];
295 /* Return a formatted line and column ':%line:%column'. Elided if
296 zero. The result is a statically allocated buffer. */
299 maybe_line_and_column (int line
, int col
)
301 static char result
[32];
305 size_t l
= snprintf (result
, sizeof (result
),
306 col
? ":%d:%d" : ":%d", line
, col
);
307 gcc_checking_assert (l
< sizeof (result
));
314 /* Return a malloc'd string describing a location e.g. "foo.c:42:10".
315 The caller is responsible for freeing the memory. */
318 diagnostic_get_location_text (diagnostic_context
*context
,
321 pretty_printer
*pp
= context
->printer
;
322 const char *locus_cs
= colorize_start (pp_show_color (pp
), "locus");
323 const char *locus_ce
= colorize_stop (pp_show_color (pp
));
324 const char *file
= s
.file
? s
.file
: progname
;
325 int line
= strcmp (file
, N_("<built-in>")) ? s
.line
: 0;
326 int col
= context
->show_column
? s
.column
: 0;
328 const char *line_col
= maybe_line_and_column (line
, col
);
329 return build_message_string ("%s%s%s:%s", locus_cs
, file
,
333 /* Return a malloc'd string describing a location and the severity of the
334 diagnostic, e.g. "foo.c:42:10: error: ". The caller is responsible for
335 freeing the memory. */
337 diagnostic_build_prefix (diagnostic_context
*context
,
338 const diagnostic_info
*diagnostic
)
340 static const char *const diagnostic_kind_text
[] = {
341 #define DEFINE_DIAGNOSTIC_KIND(K, T, C) (T),
342 #include "diagnostic.def"
343 #undef DEFINE_DIAGNOSTIC_KIND
346 gcc_assert (diagnostic
->kind
< DK_LAST_DIAGNOSTIC_KIND
);
348 const char *text
= _(diagnostic_kind_text
[diagnostic
->kind
]);
349 const char *text_cs
= "", *text_ce
= "";
350 pretty_printer
*pp
= context
->printer
;
352 if (diagnostic_kind_color
[diagnostic
->kind
])
354 text_cs
= colorize_start (pp_show_color (pp
),
355 diagnostic_kind_color
[diagnostic
->kind
]);
356 text_ce
= colorize_stop (pp_show_color (pp
));
359 expanded_location s
= diagnostic_expand_location (diagnostic
);
360 char *location_text
= diagnostic_get_location_text (context
, s
);
362 char *result
= build_message_string ("%s %s%s%s", location_text
,
363 text_cs
, text
, text_ce
);
364 free (location_text
);
368 /* Functions at which to stop the backtrace print. It's not
369 particularly helpful to print the callers of these functions. */
371 static const char * const bt_stop
[] =
379 /* A callback function passed to the backtrace_full function. */
382 bt_callback (void *data
, uintptr_t pc
, const char *filename
, int lineno
,
383 const char *function
)
385 int *pcount
= (int *) data
;
387 /* If we don't have any useful information, don't print
389 if (filename
== NULL
&& function
== NULL
)
392 /* Skip functions in diagnostic.c. */
395 && strcmp (lbasename (filename
), "diagnostic.c") == 0)
398 /* Print up to 20 functions. We could make this a --param, but
399 since this is only for debugging just use a constant for now. */
402 /* Returning a non-zero value stops the backtrace. */
408 if (function
!= NULL
)
410 char *str
= cplus_demangle_v3 (function
,
411 (DMGL_VERBOSE
| DMGL_ANSI
412 | DMGL_GNU_V3
| DMGL_PARAMS
));
419 for (size_t i
= 0; i
< ARRAY_SIZE (bt_stop
); ++i
)
421 size_t len
= strlen (bt_stop
[i
]);
422 if (strncmp (function
, bt_stop
[i
], len
) == 0
423 && (function
[len
] == '\0' || function
[len
] == '('))
427 /* Returning a non-zero value stops the backtrace. */
433 fprintf (stderr
, "0x%lx %s\n\t%s:%d\n",
435 function
== NULL
? "???" : function
,
436 filename
== NULL
? "???" : filename
,
445 /* A callback function passed to the backtrace_full function. This is
446 called if backtrace_full has an error. */
449 bt_err_callback (void *data ATTRIBUTE_UNUSED
, const char *msg
, int errnum
)
453 /* This means that no debug info was available. Just quietly
454 skip printing backtrace info. */
457 fprintf (stderr
, "%s%s%s\n", msg
, errnum
== 0 ? "" : ": ",
458 errnum
== 0 ? "" : xstrerror (errnum
));
461 /* Check if we've met the maximum error limit, and if so fatally exit
462 with a message. CONTEXT is the context to check, and FLUSH
463 indicates whether a diagnostic_finish call is needed. */
466 diagnostic_check_max_errors (diagnostic_context
*context
, bool flush
)
468 if (!context
->max_errors
)
471 int count
= (diagnostic_kind_count (context
, DK_ERROR
)
472 + diagnostic_kind_count (context
, DK_SORRY
)
473 + diagnostic_kind_count (context
, DK_WERROR
));
475 if (count
>= context
->max_errors
)
478 "compilation terminated due to -fmax-errors=%u.\n",
479 context
->max_errors
);
481 diagnostic_finish (context
);
482 exit (FATAL_EXIT_CODE
);
486 /* Take any action which is expected to happen after the diagnostic
487 is written out. This function does not always return. */
489 diagnostic_action_after_output (diagnostic_context
*context
,
490 diagnostic_t diag_kind
)
502 if (context
->abort_on_error
)
504 if (context
->fatal_errors
)
506 fnotice (stderr
, "compilation terminated due to -Wfatal-errors.\n");
507 diagnostic_finish (context
);
508 exit (FATAL_EXIT_CODE
);
515 struct backtrace_state
*state
= NULL
;
516 if (diag_kind
== DK_ICE
)
517 state
= backtrace_create_state (NULL
, 0, bt_err_callback
, NULL
);
520 backtrace_full (state
, 2, bt_callback
, bt_err_callback
,
523 if (context
->abort_on_error
)
526 fnotice (stderr
, "Please submit a full bug report,\n"
527 "with preprocessed source if appropriate.\n");
530 ("Please include the complete backtrace "
531 "with any bug report.\n"));
532 fnotice (stderr
, "See %s for instructions.\n", bug_report_url
);
534 exit (ICE_EXIT_CODE
);
538 if (context
->abort_on_error
)
540 diagnostic_finish (context
);
541 fnotice (stderr
, "compilation terminated.\n");
542 exit (FATAL_EXIT_CODE
);
549 /* True if the last module or file in which a diagnostic was reported is
550 different from the current one. */
553 last_module_changed_p (diagnostic_context
*context
,
554 const line_map_ordinary
*map
)
556 return context
->last_module
!= map
;
559 /* Remember the current module or file as being the last one in which we
560 report a diagnostic. */
563 set_last_module (diagnostic_context
*context
, const line_map_ordinary
*map
)
565 context
->last_module
= map
;
569 diagnostic_report_current_module (diagnostic_context
*context
, location_t where
)
571 const line_map_ordinary
*map
= NULL
;
573 if (pp_needs_newline (context
->printer
))
575 pp_newline (context
->printer
);
576 pp_needs_newline (context
->printer
) = false;
579 if (where
<= BUILTINS_LOCATION
)
582 linemap_resolve_location (line_table
, where
,
583 LRK_MACRO_DEFINITION_LOCATION
,
586 if (map
&& last_module_changed_p (context
, map
))
588 set_last_module (context
, map
);
589 if (! MAIN_FILE_P (map
))
594 where
= linemap_included_from (map
);
595 map
= linemap_included_from_linemap (line_table
, map
);
597 = maybe_line_and_column (SOURCE_LINE (map
, where
),
598 first
&& context
->show_column
599 ? SOURCE_COLUMN (map
, where
) : 0);
600 static const char *const msgs
[] =
602 N_("In file included from"),
605 unsigned index
= !first
;
606 pp_verbatim (context
->printer
, "%s%s %r%s%s%R",
607 first
? "" : ",\n", _(msgs
[index
]),
608 "locus", LINEMAP_FILE (map
), line_col
);
611 while (! MAIN_FILE_P (map
));
612 pp_verbatim (context
->printer
, ":");
613 pp_newline (context
->printer
);
619 default_diagnostic_starter (diagnostic_context
*context
,
620 diagnostic_info
*diagnostic
)
622 diagnostic_report_current_module (context
, diagnostic_location (diagnostic
));
623 pp_set_prefix (context
->printer
, diagnostic_build_prefix (context
,
628 default_diagnostic_start_span_fn (diagnostic_context
*context
,
629 expanded_location exploc
)
631 pp_set_prefix (context
->printer
,
632 diagnostic_get_location_text (context
, exploc
));
633 pp_string (context
->printer
, "");
634 pp_newline (context
->printer
);
638 default_diagnostic_finalizer (diagnostic_context
*context
,
639 diagnostic_info
*diagnostic
)
641 diagnostic_show_locus (context
, diagnostic
->richloc
, diagnostic
->kind
);
642 pp_destroy_prefix (context
->printer
);
643 pp_flush (context
->printer
);
646 /* Interface to specify diagnostic kind overrides. Returns the
647 previous setting, or DK_UNSPECIFIED if the parameters are out of
648 range. If OPTION_INDEX is zero, the new setting is for all the
651 diagnostic_classify_diagnostic (diagnostic_context
*context
,
653 diagnostic_t new_kind
,
656 diagnostic_t old_kind
;
659 || option_index
>= context
->n_opts
660 || new_kind
>= DK_LAST_DIAGNOSTIC_KIND
)
661 return DK_UNSPECIFIED
;
663 old_kind
= context
->classify_diagnostic
[option_index
];
665 /* Handle pragmas separately, since we need to keep track of *where*
667 if (where
!= UNKNOWN_LOCATION
)
671 /* Record the command-line status, so we can reset it back on DK_POP. */
672 if (old_kind
== DK_UNSPECIFIED
)
674 old_kind
= !context
->option_enabled (option_index
,
675 context
->option_state
)
676 ? DK_IGNORED
: (context
->warning_as_error_requested
677 ? DK_ERROR
: DK_WARNING
);
678 context
->classify_diagnostic
[option_index
] = old_kind
;
681 for (i
= context
->n_classification_history
- 1; i
>= 0; i
--)
682 if (context
->classification_history
[i
].option
== option_index
)
684 old_kind
= context
->classification_history
[i
].kind
;
688 i
= context
->n_classification_history
;
689 context
->classification_history
=
690 (diagnostic_classification_change_t
*) xrealloc (context
->classification_history
, (i
+ 1)
691 * sizeof (diagnostic_classification_change_t
));
692 context
->classification_history
[i
].location
= where
;
693 context
->classification_history
[i
].option
= option_index
;
694 context
->classification_history
[i
].kind
= new_kind
;
695 context
->n_classification_history
++;
698 context
->classify_diagnostic
[option_index
] = new_kind
;
703 /* Save all diagnostic classifications in a stack. */
705 diagnostic_push_diagnostics (diagnostic_context
*context
, location_t where ATTRIBUTE_UNUSED
)
707 context
->push_list
= (int *) xrealloc (context
->push_list
, (context
->n_push
+ 1) * sizeof (int));
708 context
->push_list
[context
->n_push
++] = context
->n_classification_history
;
711 /* Restore the topmost classification set off the stack. If the stack
712 is empty, revert to the state based on command line parameters. */
714 diagnostic_pop_diagnostics (diagnostic_context
*context
, location_t where
)
720 jump_to
= context
->push_list
[-- context
->n_push
];
724 i
= context
->n_classification_history
;
725 context
->classification_history
=
726 (diagnostic_classification_change_t
*) xrealloc (context
->classification_history
, (i
+ 1)
727 * sizeof (diagnostic_classification_change_t
));
728 context
->classification_history
[i
].location
= where
;
729 context
->classification_history
[i
].option
= jump_to
;
730 context
->classification_history
[i
].kind
= DK_POP
;
731 context
->n_classification_history
++;
734 /* Helper function for print_parseable_fixits. Print TEXT to PP, obeying the
735 escaping rules for -fdiagnostics-parseable-fixits. */
738 print_escaped_string (pretty_printer
*pp
, const char *text
)
743 pp_character (pp
, '"');
744 for (const char *ch
= text
; *ch
; ch
++)
749 /* Escape backslash as two backslashes. */
750 pp_string (pp
, "\\\\");
753 /* Escape tab as "\t". */
754 pp_string (pp
, "\\t");
757 /* Escape newline as "\n". */
758 pp_string (pp
, "\\n");
761 /* Escape doublequotes as \". */
762 pp_string (pp
, "\\\"");
766 pp_character (pp
, *ch
);
768 /* Use octal for non-printable chars. */
770 unsigned char c
= (*ch
& 0xff);
771 pp_printf (pp
, "\\%o%o%o", (c
/ 64), (c
/ 8) & 007, c
& 007);
776 pp_character (pp
, '"');
779 /* Implementation of -fdiagnostics-parseable-fixits. Print a
780 machine-parseable version of all fixits in RICHLOC to PP. */
783 print_parseable_fixits (pretty_printer
*pp
, rich_location
*richloc
)
786 gcc_assert (richloc
);
788 for (unsigned i
= 0; i
< richloc
->get_num_fixit_hints (); i
++)
790 const fixit_hint
*hint
= richloc
->get_fixit_hint (i
);
791 source_location start_loc
= hint
->get_start_loc ();
792 expanded_location start_exploc
= expand_location (start_loc
);
793 pp_string (pp
, "fix-it:");
794 print_escaped_string (pp
, start_exploc
.file
);
795 /* For compatibility with clang, print as a half-open range. */
796 source_location next_loc
= hint
->get_next_loc ();
797 expanded_location next_exploc
= expand_location (next_loc
);
798 pp_printf (pp
, ":{%i:%i-%i:%i}:",
799 start_exploc
.line
, start_exploc
.column
,
800 next_exploc
.line
, next_exploc
.column
);
801 print_escaped_string (pp
, hint
->get_string ());
806 /* Update the diag_class of DIAGNOSTIC based on its location
808 #pragma GCC diagnostic
809 directives recorded within CONTEXT.
811 Return the new diag_class of DIAGNOSTIC if it was updated, or
812 DK_UNSPECIFIED otherwise. */
815 update_effective_level_from_pragmas (diagnostic_context
*context
,
816 diagnostic_info
*diagnostic
)
818 diagnostic_t diag_class
= DK_UNSPECIFIED
;
820 if (context
->n_classification_history
> 0)
822 location_t location
= diagnostic_location (diagnostic
);
824 /* FIXME: Stupid search. Optimize later. */
825 for (int i
= context
->n_classification_history
- 1; i
>= 0; i
--)
827 if (linemap_location_before_p
829 context
->classification_history
[i
].location
,
832 if (context
->classification_history
[i
].kind
== (int) DK_POP
)
834 i
= context
->classification_history
[i
].option
;
837 int option
= context
->classification_history
[i
].option
;
838 /* The option 0 is for all the diagnostics. */
839 if (option
== 0 || option
== diagnostic
->option_index
)
841 diag_class
= context
->classification_history
[i
].kind
;
842 if (diag_class
!= DK_UNSPECIFIED
)
843 diagnostic
->kind
= diag_class
;
853 /* Print any metadata about the option used to control DIAGNOSTIC to CONTEXT's
854 printer, e.g. " [-Werror=uninitialized]".
855 Subroutine of diagnostic_report_diagnostic. */
858 print_option_information (diagnostic_context
*context
,
859 const diagnostic_info
*diagnostic
,
860 diagnostic_t orig_diag_kind
)
864 option_text
= context
->option_name (context
, diagnostic
->option_index
,
865 orig_diag_kind
, diagnostic
->kind
);
869 pretty_printer
*pp
= context
->printer
;
870 pp_string (pp
, " [");
871 pp_string (pp
, colorize_start (pp_show_color (pp
),
872 diagnostic_kind_color
[diagnostic
->kind
]));
873 pp_string (pp
, option_text
);
874 pp_string (pp
, colorize_stop (pp_show_color (pp
)));
875 pp_character (pp
, ']');
880 /* Report a diagnostic message (an error or a warning) as specified by
881 DC. This function is *the* subroutine in terms of which front-ends
882 should implement their specific diagnostic handling modules. The
883 front-end independent format specifiers are exactly those described
884 in the documentation of output_format.
885 Return true if a diagnostic was printed, false otherwise. */
888 diagnostic_report_diagnostic (diagnostic_context
*context
,
889 diagnostic_info
*diagnostic
)
891 location_t location
= diagnostic_location (diagnostic
);
892 diagnostic_t orig_diag_kind
= diagnostic
->kind
;
894 /* Give preference to being able to inhibit warnings, before they
895 get reclassified to something else. */
896 if ((diagnostic
->kind
== DK_WARNING
|| diagnostic
->kind
== DK_PEDWARN
)
897 && !diagnostic_report_warnings_p (context
, location
))
900 if (diagnostic
->kind
== DK_PEDWARN
)
902 diagnostic
->kind
= pedantic_warning_kind (context
);
903 /* We do this to avoid giving the message for -pedantic-errors. */
904 orig_diag_kind
= diagnostic
->kind
;
907 if (diagnostic
->kind
== DK_NOTE
&& context
->inhibit_notes_p
)
910 if (context
->lock
> 0)
912 /* If we're reporting an ICE in the middle of some other error,
913 try to flush out the previous error, then let this one
914 through. Don't do this more than once. */
915 if ((diagnostic
->kind
== DK_ICE
|| diagnostic
->kind
== DK_ICE_NOBT
)
916 && context
->lock
== 1)
917 pp_newline_and_flush (context
->printer
);
919 error_recursion (context
);
922 /* If the user requested that warnings be treated as errors, so be
923 it. Note that we do this before the next block so that
924 individual warnings can be overridden back to warnings with
926 if (context
->warning_as_error_requested
927 && diagnostic
->kind
== DK_WARNING
)
928 diagnostic
->kind
= DK_ERROR
;
930 if (diagnostic
->option_index
931 && diagnostic
->option_index
!= permissive_error_option (context
))
933 /* This tests if the user provided the appropriate -Wfoo or
935 if (! context
->option_enabled (diagnostic
->option_index
,
936 context
->option_state
))
939 /* This tests for #pragma diagnostic changes. */
940 diagnostic_t diag_class
941 = update_effective_level_from_pragmas (context
, diagnostic
);
943 /* This tests if the user provided the appropriate -Werror=foo
945 if (diag_class
== DK_UNSPECIFIED
946 && (context
->classify_diagnostic
[diagnostic
->option_index
]
949 = context
->classify_diagnostic
[diagnostic
->option_index
];
951 /* This allows for future extensions, like temporarily disabling
952 warnings for ranges of source code. */
953 if (diagnostic
->kind
== DK_IGNORED
)
957 if (diagnostic
->kind
!= DK_NOTE
)
958 diagnostic_check_max_errors (context
);
962 if (diagnostic
->kind
== DK_ICE
|| diagnostic
->kind
== DK_ICE_NOBT
)
964 /* When not checking, ICEs are converted to fatal errors when an
965 error has already occurred. This is counteracted by
968 && (diagnostic_kind_count (context
, DK_ERROR
) > 0
969 || diagnostic_kind_count (context
, DK_SORRY
) > 0)
970 && !context
->abort_on_error
)
973 = expand_location (diagnostic_location (diagnostic
));
974 fnotice (stderr
, "%s:%d: confused by earlier errors, bailing out\n",
976 exit (ICE_EXIT_CODE
);
978 if (context
->internal_error
)
979 (*context
->internal_error
) (context
,
980 diagnostic
->message
.format_spec
,
981 diagnostic
->message
.args_ptr
);
983 if (diagnostic
->kind
== DK_ERROR
&& orig_diag_kind
== DK_WARNING
)
984 ++diagnostic_kind_count (context
, DK_WERROR
);
986 ++diagnostic_kind_count (context
, diagnostic
->kind
);
988 diagnostic
->message
.x_data
= &diagnostic
->x_data
;
989 diagnostic
->x_data
= NULL
;
990 pp_format (context
->printer
, &diagnostic
->message
);
991 (*diagnostic_starter (context
)) (context
, diagnostic
);
992 pp_output_formatted_text (context
->printer
);
993 if (context
->show_option_requested
)
994 print_option_information (context
, diagnostic
, orig_diag_kind
);
995 (*diagnostic_finalizer (context
)) (context
, diagnostic
);
996 if (context
->parseable_fixits_p
)
998 print_parseable_fixits (context
->printer
, diagnostic
->richloc
);
999 pp_flush (context
->printer
);
1001 diagnostic_action_after_output (context
, diagnostic
->kind
);
1002 diagnostic
->x_data
= NULL
;
1004 if (context
->edit_context_ptr
)
1005 if (diagnostic
->richloc
->fixits_can_be_auto_applied_p ())
1006 context
->edit_context_ptr
->add_fixits (diagnostic
->richloc
);
1013 /* Given a partial pathname as input, return another pathname that
1014 shares no directory elements with the pathname of __FILE__. This
1015 is used by fancy_abort() to print `Internal compiler error in expr.c'
1016 instead of `Internal compiler error in ../../GCC/gcc/expr.c'. */
1019 trim_filename (const char *name
)
1021 static const char this_file
[] = __FILE__
;
1022 const char *p
= name
, *q
= this_file
;
1024 /* First skip any "../" in each filename. This allows us to give a proper
1025 reference to a file in a subdirectory. */
1026 while (p
[0] == '.' && p
[1] == '.' && IS_DIR_SEPARATOR (p
[2]))
1029 while (q
[0] == '.' && q
[1] == '.' && IS_DIR_SEPARATOR (q
[2]))
1032 /* Now skip any parts the two filenames have in common. */
1033 while (*p
== *q
&& *p
!= 0 && *q
!= 0)
1036 /* Now go backwards until the previous directory separator. */
1037 while (p
> name
&& !IS_DIR_SEPARATOR (p
[-1]))
1043 /* Standard error reporting routines in increasing order of severity.
1044 All of these take arguments like printf. */
1046 /* Text to be emitted verbatim to the error message stream; this
1047 produces no prefix and disables line-wrapping. Use rarely. */
1049 verbatim (const char *gmsgid
, ...)
1054 va_start (ap
, gmsgid
);
1055 text
.err_no
= errno
;
1056 text
.args_ptr
= &ap
;
1057 text
.format_spec
= _(gmsgid
);
1059 pp_format_verbatim (global_dc
->printer
, &text
);
1060 pp_newline_and_flush (global_dc
->printer
);
1064 /* Add a note with text GMSGID and with LOCATION to the diagnostic CONTEXT. */
1066 diagnostic_append_note (diagnostic_context
*context
,
1067 location_t location
,
1068 const char * gmsgid
, ...)
1070 diagnostic_info diagnostic
;
1072 rich_location
richloc (line_table
, location
);
1074 va_start (ap
, gmsgid
);
1075 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, &richloc
, DK_NOTE
);
1076 if (context
->inhibit_notes_p
)
1081 char *saved_prefix
= pp_take_prefix (context
->printer
);
1082 pp_set_prefix (context
->printer
,
1083 diagnostic_build_prefix (context
, &diagnostic
));
1084 pp_format (context
->printer
, &diagnostic
.message
);
1085 pp_output_formatted_text (context
->printer
);
1086 pp_destroy_prefix (context
->printer
);
1087 pp_set_prefix (context
->printer
, saved_prefix
);
1088 diagnostic_show_locus (context
, &richloc
, DK_NOTE
);
1092 /* Implement emit_diagnostic, inform, warning, warning_at, pedwarn,
1093 permerror, error, error_at, error_at, sorry, fatal_error, internal_error,
1094 and internal_error_no_backtrace, as documented and defined below. */
1096 diagnostic_impl (rich_location
*richloc
, int opt
,
1098 va_list *ap
, diagnostic_t kind
)
1100 diagnostic_info diagnostic
;
1101 if (kind
== DK_PERMERROR
)
1103 diagnostic_set_info (&diagnostic
, gmsgid
, ap
, richloc
,
1104 permissive_error_kind (global_dc
));
1105 diagnostic
.option_index
= permissive_error_option (global_dc
);
1109 diagnostic_set_info (&diagnostic
, gmsgid
, ap
, richloc
, kind
);
1110 if (kind
== DK_WARNING
|| kind
== DK_PEDWARN
)
1111 diagnostic
.option_index
= opt
;
1113 return diagnostic_report_diagnostic (global_dc
, &diagnostic
);
1116 /* Implement inform_n, warning_n, and error_n, as documented and
1119 diagnostic_n_impl (rich_location
*richloc
, int opt
, unsigned HOST_WIDE_INT n
,
1120 const char *singular_gmsgid
,
1121 const char *plural_gmsgid
,
1122 va_list *ap
, diagnostic_t kind
)
1124 diagnostic_info diagnostic
;
1127 if (sizeof n
<= sizeof gtn
)
1130 /* Use the largest number ngettext can handle, otherwise
1131 preserve the six least significant decimal digits for
1132 languages where the plural form depends on them. */
1133 gtn
= n
<= ULONG_MAX
? n
: n
% 1000000LU + 1000000LU;
1135 const char *text
= ngettext (singular_gmsgid
, plural_gmsgid
, gtn
);
1136 diagnostic_set_info_translated (&diagnostic
, text
, ap
, richloc
, kind
);
1137 if (kind
== DK_WARNING
)
1138 diagnostic
.option_index
= opt
;
1139 return diagnostic_report_diagnostic (global_dc
, &diagnostic
);
1142 /* Wrapper around diagnostic_impl taking a variable argument list. */
1145 emit_diagnostic (diagnostic_t kind
, location_t location
, int opt
,
1146 const char *gmsgid
, ...)
1149 va_start (ap
, gmsgid
);
1150 rich_location
richloc (line_table
, location
);
1151 bool ret
= diagnostic_impl (&richloc
, opt
, gmsgid
, &ap
, kind
);
1156 /* Wrapper around diagnostic_impl taking a va_list parameter. */
1159 emit_diagnostic_valist (diagnostic_t kind
, location_t location
, int opt
,
1160 const char *gmsgid
, va_list *ap
)
1162 rich_location
richloc (line_table
, location
);
1163 return diagnostic_impl (&richloc
, opt
, gmsgid
, ap
, kind
);
1166 /* An informative note at LOCATION. Use this for additional details on an error
1169 inform (location_t location
, const char *gmsgid
, ...)
1172 va_start (ap
, gmsgid
);
1173 rich_location
richloc (line_table
, location
);
1174 diagnostic_impl (&richloc
, -1, gmsgid
, &ap
, DK_NOTE
);
1178 /* Same as "inform" above, but at RICHLOC. */
1180 inform (rich_location
*richloc
, const char *gmsgid
, ...)
1182 gcc_assert (richloc
);
1185 va_start (ap
, gmsgid
);
1186 diagnostic_impl (richloc
, -1, gmsgid
, &ap
, DK_NOTE
);
1190 /* An informative note at LOCATION. Use this for additional details on an
1193 inform_n (location_t location
, unsigned HOST_WIDE_INT n
,
1194 const char *singular_gmsgid
, const char *plural_gmsgid
, ...)
1197 va_start (ap
, plural_gmsgid
);
1198 rich_location
richloc (line_table
, location
);
1199 diagnostic_n_impl (&richloc
, -1, n
, singular_gmsgid
, plural_gmsgid
,
1204 /* A warning at INPUT_LOCATION. Use this for code which is correct according
1205 to the relevant language specification but is likely to be buggy anyway.
1206 Returns true if the warning was printed, false if it was inhibited. */
1208 warning (int opt
, const char *gmsgid
, ...)
1211 va_start (ap
, gmsgid
);
1212 rich_location
richloc (line_table
, input_location
);
1213 bool ret
= diagnostic_impl (&richloc
, opt
, gmsgid
, &ap
, DK_WARNING
);
1218 /* A warning at LOCATION. Use this for code which is correct according to the
1219 relevant language specification but is likely to be buggy anyway.
1220 Returns true if the warning was printed, false if it was inhibited. */
1223 warning_at (location_t location
, int opt
, const char *gmsgid
, ...)
1226 va_start (ap
, gmsgid
);
1227 rich_location
richloc (line_table
, location
);
1228 bool ret
= diagnostic_impl (&richloc
, opt
, gmsgid
, &ap
, DK_WARNING
);
1233 /* Same as "warning at" above, but using RICHLOC. */
1236 warning_at (rich_location
*richloc
, int opt
, const char *gmsgid
, ...)
1238 gcc_assert (richloc
);
1241 va_start (ap
, gmsgid
);
1242 bool ret
= diagnostic_impl (richloc
, opt
, gmsgid
, &ap
, DK_WARNING
);
1247 /* Same as warning_n plural variant below, but using RICHLOC. */
1250 warning_n (rich_location
*richloc
, int opt
, unsigned HOST_WIDE_INT n
,
1251 const char *singular_gmsgid
, const char *plural_gmsgid
, ...)
1253 gcc_assert (richloc
);
1256 va_start (ap
, plural_gmsgid
);
1257 bool ret
= diagnostic_n_impl (richloc
, opt
, n
,
1258 singular_gmsgid
, plural_gmsgid
,
1264 /* A warning at LOCATION. Use this for code which is correct according to the
1265 relevant language specification but is likely to be buggy anyway.
1266 Returns true if the warning was printed, false if it was inhibited. */
1269 warning_n (location_t location
, int opt
, unsigned HOST_WIDE_INT n
,
1270 const char *singular_gmsgid
, const char *plural_gmsgid
, ...)
1273 va_start (ap
, plural_gmsgid
);
1274 rich_location
richloc (line_table
, location
);
1275 bool ret
= diagnostic_n_impl (&richloc
, opt
, n
,
1276 singular_gmsgid
, plural_gmsgid
,
1282 /* A "pedantic" warning at LOCATION: issues a warning unless
1283 -pedantic-errors was given on the command line, in which case it
1284 issues an error. Use this for diagnostics required by the relevant
1285 language standard, if you have chosen not to make them errors.
1287 Note that these diagnostics are issued independent of the setting
1288 of the -Wpedantic command-line switch. To get a warning enabled
1289 only with that switch, use either "if (pedantic) pedwarn
1290 (OPT_Wpedantic,...)" or just "pedwarn (OPT_Wpedantic,..)". To get a
1291 pedwarn independently of the -Wpedantic switch use "pedwarn (0,...)".
1293 Returns true if the warning was printed, false if it was inhibited. */
1296 pedwarn (location_t location
, int opt
, const char *gmsgid
, ...)
1299 va_start (ap
, gmsgid
);
1300 rich_location
richloc (line_table
, location
);
1301 bool ret
= diagnostic_impl (&richloc
, opt
, gmsgid
, &ap
, DK_PEDWARN
);
1306 /* Same as pedwarn above, but using RICHLOC. */
1309 pedwarn (rich_location
*richloc
, int opt
, const char *gmsgid
, ...)
1311 gcc_assert (richloc
);
1314 va_start (ap
, gmsgid
);
1315 bool ret
= diagnostic_impl (richloc
, opt
, gmsgid
, &ap
, DK_PEDWARN
);
1320 /* A "permissive" error at LOCATION: issues an error unless
1321 -fpermissive was given on the command line, in which case it issues
1322 a warning. Use this for things that really should be errors but we
1323 want to support legacy code.
1325 Returns true if the warning was printed, false if it was inhibited. */
1328 permerror (location_t location
, const char *gmsgid
, ...)
1331 va_start (ap
, gmsgid
);
1332 rich_location
richloc (line_table
, location
);
1333 bool ret
= diagnostic_impl (&richloc
, -1, gmsgid
, &ap
, DK_PERMERROR
);
1338 /* Same as "permerror" above, but at RICHLOC. */
1341 permerror (rich_location
*richloc
, const char *gmsgid
, ...)
1343 gcc_assert (richloc
);
1346 va_start (ap
, gmsgid
);
1347 bool ret
= diagnostic_impl (richloc
, -1, gmsgid
, &ap
, DK_PERMERROR
);
1352 /* A hard error: the code is definitely ill-formed, and an object file
1353 will not be produced. */
1355 error (const char *gmsgid
, ...)
1358 va_start (ap
, gmsgid
);
1359 rich_location
richloc (line_table
, input_location
);
1360 diagnostic_impl (&richloc
, -1, gmsgid
, &ap
, DK_ERROR
);
1364 /* A hard error: the code is definitely ill-formed, and an object file
1365 will not be produced. */
1367 error_n (location_t location
, unsigned HOST_WIDE_INT n
,
1368 const char *singular_gmsgid
, const char *plural_gmsgid
, ...)
1371 va_start (ap
, plural_gmsgid
);
1372 rich_location
richloc (line_table
, location
);
1373 diagnostic_n_impl (&richloc
, -1, n
, singular_gmsgid
, plural_gmsgid
,
1378 /* Same as above, but use location LOC instead of input_location. */
1380 error_at (location_t loc
, const char *gmsgid
, ...)
1383 va_start (ap
, gmsgid
);
1384 rich_location
richloc (line_table
, loc
);
1385 diagnostic_impl (&richloc
, -1, gmsgid
, &ap
, DK_ERROR
);
1389 /* Same as above, but use RICH_LOC. */
1392 error_at (rich_location
*richloc
, const char *gmsgid
, ...)
1394 gcc_assert (richloc
);
1397 va_start (ap
, gmsgid
);
1398 diagnostic_impl (richloc
, -1, gmsgid
, &ap
, DK_ERROR
);
1402 /* "Sorry, not implemented." Use for a language feature which is
1403 required by the relevant specification but not implemented by GCC.
1404 An object file will not be produced. */
1406 sorry (const char *gmsgid
, ...)
1409 va_start (ap
, gmsgid
);
1410 rich_location
richloc (line_table
, input_location
);
1411 diagnostic_impl (&richloc
, -1, gmsgid
, &ap
, DK_SORRY
);
1415 /* Return true if an error or a "sorry" has been seen. Various
1416 processing is disabled after errors. */
1420 return errorcount
|| sorrycount
;
1423 /* An error which is severe enough that we make no attempt to
1424 continue. Do not use this for internal consistency checks; that's
1425 internal_error. Use of this function should be rare. */
1427 fatal_error (location_t loc
, const char *gmsgid
, ...)
1430 va_start (ap
, gmsgid
);
1431 rich_location
richloc (line_table
, loc
);
1432 diagnostic_impl (&richloc
, -1, gmsgid
, &ap
, DK_FATAL
);
1438 /* An internal consistency check has failed. We make no attempt to
1439 continue. Note that unless there is debugging value to be had from
1440 a more specific message, or some other good reason, you should use
1441 abort () instead of calling this function directly. */
1443 internal_error (const char *gmsgid
, ...)
1446 va_start (ap
, gmsgid
);
1447 rich_location
richloc (line_table
, input_location
);
1448 diagnostic_impl (&richloc
, -1, gmsgid
, &ap
, DK_ICE
);
1454 /* Like internal_error, but no backtrace will be printed. Used when
1455 the internal error does not happen at the current location, but happened
1458 internal_error_no_backtrace (const char *gmsgid
, ...)
1461 va_start (ap
, gmsgid
);
1462 rich_location
richloc (line_table
, input_location
);
1463 diagnostic_impl (&richloc
, -1, gmsgid
, &ap
, DK_ICE_NOBT
);
1469 /* Special case error functions. Most are implemented in terms of the
1470 above, or should be. */
1472 /* Print a diagnostic MSGID on FILE. This is just fprintf, except it
1473 runs its second argument through gettext. */
1475 fnotice (FILE *file
, const char *cmsgid
, ...)
1479 va_start (ap
, cmsgid
);
1480 vfprintf (file
, _(cmsgid
), ap
);
1484 /* Inform the user that an error occurred while trying to report some
1485 other error. This indicates catastrophic internal inconsistencies,
1486 so give up now. But do try to flush out the previous error.
1487 This mustn't use internal_error, that will cause infinite recursion. */
1490 error_recursion (diagnostic_context
*context
)
1492 if (context
->lock
< 3)
1493 pp_newline_and_flush (context
->printer
);
1496 "Internal compiler error: Error reporting routines re-entered.\n");
1498 /* Call diagnostic_action_after_output to get the "please submit a bug
1500 diagnostic_action_after_output (context
, DK_ICE
);
1502 /* Do not use gcc_unreachable here; that goes through internal_error
1503 and therefore would cause infinite recursion. */
1507 /* Report an internal compiler error in a friendly manner. This is
1508 the function that gets called upon use of abort() in the source
1509 code generally, thanks to a special macro. */
1512 fancy_abort (const char *file
, int line
, const char *function
)
1514 internal_error ("in %s, at %s:%d", function
, trim_filename (file
), line
);
1517 /* Really call the system 'abort'. This has to go right at the end of
1518 this file, so that there are no functions after it that call abort
1519 and get the system abort instead of our macro. */
1529 namespace selftest
{
1531 /* Helper function for test_print_escaped_string. */
1534 assert_print_escaped_string (const location
&loc
, const char *expected_output
,
1538 print_escaped_string (&pp
, input
);
1539 ASSERT_STREQ_AT (loc
, expected_output
, pp_formatted_text (&pp
));
1542 #define ASSERT_PRINT_ESCAPED_STRING_STREQ(EXPECTED_OUTPUT, INPUT) \
1543 assert_print_escaped_string (SELFTEST_LOCATION, EXPECTED_OUTPUT, INPUT)
1545 /* Tests of print_escaped_string. */
1548 test_print_escaped_string ()
1551 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"\"", "");
1553 /* Non-empty string. */
1554 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"hello world\"", "hello world");
1556 /* Various things that need to be escaped: */
1558 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\\\after\"",
1561 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\tafter\"",
1564 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\nafter\"",
1567 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\\"after\"",
1570 /* Non-printable characters: BEL: '\a': 0x07 */
1571 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\007after\"",
1573 /* Non-printable characters: vertical tab: '\v': 0x0b */
1574 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\013after\"",
1578 /* Tests of print_parseable_fixits. */
1580 /* Verify that print_parseable_fixits emits the empty string if there
1584 test_print_parseable_fixits_none ()
1587 rich_location
richloc (line_table
, UNKNOWN_LOCATION
);
1589 print_parseable_fixits (&pp
, &richloc
);
1590 ASSERT_STREQ ("", pp_formatted_text (&pp
));
1593 /* Verify that print_parseable_fixits does the right thing if there
1594 is an insertion fixit hint. */
1597 test_print_parseable_fixits_insert ()
1600 rich_location
richloc (line_table
, UNKNOWN_LOCATION
);
1602 linemap_add (line_table
, LC_ENTER
, false, "test.c", 0);
1603 linemap_line_start (line_table
, 5, 100);
1604 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
1605 location_t where
= linemap_position_for_column (line_table
, 10);
1606 richloc
.add_fixit_insert_before (where
, "added content");
1608 print_parseable_fixits (&pp
, &richloc
);
1609 ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:10}:\"added content\"\n",
1610 pp_formatted_text (&pp
));
1613 /* Verify that print_parseable_fixits does the right thing if there
1614 is an removal fixit hint. */
1617 test_print_parseable_fixits_remove ()
1620 rich_location
richloc (line_table
, UNKNOWN_LOCATION
);
1622 linemap_add (line_table
, LC_ENTER
, false, "test.c", 0);
1623 linemap_line_start (line_table
, 5, 100);
1624 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
1626 where
.m_start
= linemap_position_for_column (line_table
, 10);
1627 where
.m_finish
= linemap_position_for_column (line_table
, 20);
1628 richloc
.add_fixit_remove (where
);
1630 print_parseable_fixits (&pp
, &richloc
);
1631 ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:21}:\"\"\n",
1632 pp_formatted_text (&pp
));
1635 /* Verify that print_parseable_fixits does the right thing if there
1636 is an replacement fixit hint. */
1639 test_print_parseable_fixits_replace ()
1642 rich_location
richloc (line_table
, UNKNOWN_LOCATION
);
1644 linemap_add (line_table
, LC_ENTER
, false, "test.c", 0);
1645 linemap_line_start (line_table
, 5, 100);
1646 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
1648 where
.m_start
= linemap_position_for_column (line_table
, 10);
1649 where
.m_finish
= linemap_position_for_column (line_table
, 20);
1650 richloc
.add_fixit_replace (where
, "replacement");
1652 print_parseable_fixits (&pp
, &richloc
);
1653 ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:21}:\"replacement\"\n",
1654 pp_formatted_text (&pp
));
1658 diagnostic_get_location_text (..., SHOW_COLUMN)
1659 generates EXPECTED_LOC_TEXT, given FILENAME, LINE, COLUMN, with
1660 colorization disabled. */
1663 assert_location_text (const char *expected_loc_text
,
1664 const char *filename
, int line
, int column
,
1667 test_diagnostic_context dc
;
1668 dc
.show_column
= show_column
;
1670 expanded_location xloc
;
1671 xloc
.file
= filename
;
1673 xloc
.column
= column
;
1677 char *actual_loc_text
= diagnostic_get_location_text (&dc
, xloc
);
1678 ASSERT_STREQ (expected_loc_text
, actual_loc_text
);
1679 free (actual_loc_text
);
1682 /* Verify that diagnostic_get_location_text works as expected. */
1685 test_diagnostic_get_location_text ()
1687 const char *old_progname
= progname
;
1688 progname
= "PROGNAME";
1689 assert_location_text ("PROGNAME:", NULL
, 0, 0, true);
1690 assert_location_text ("<built-in>:", "<built-in>", 42, 10, true);
1691 assert_location_text ("foo.c:42:10:", "foo.c", 42, 10, true);
1692 assert_location_text ("foo.c:42:", "foo.c", 42, 0, true);
1693 assert_location_text ("foo.c:", "foo.c", 0, 10, true);
1694 assert_location_text ("foo.c:42:", "foo.c", 42, 10, false);
1695 assert_location_text ("foo.c:", "foo.c", 0, 10, false);
1697 maybe_line_and_column (INT_MAX
, INT_MAX
);
1698 maybe_line_and_column (INT_MIN
, INT_MIN
);
1700 progname
= old_progname
;
1703 /* Run all of the selftests within this file. */
1706 diagnostic_c_tests ()
1708 test_print_escaped_string ();
1709 test_print_parseable_fixits_none ();
1710 test_print_parseable_fixits_insert ();
1711 test_print_parseable_fixits_remove ();
1712 test_print_parseable_fixits_replace ();
1713 test_diagnostic_get_location_text ();
1716 } // namespace selftest
1718 #endif /* #if CHECKING_P */