1 /* Various declarations for language-independent diagnostics subroutines.
2 Copyright (C) 2000-2020 Free Software Foundation, Inc.
3 Contributed by Gabriel Dos Reis <gdr@codesourcery.com>
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
20
21 #ifndef GCC_DIAGNOSTIC_H
22 #define GCC_DIAGNOSTIC_H
23
24 #include "pretty-print.h"
25 #include "diagnostic-core.h"
26
27 /* Enum for overriding the standard output format. */
28
29 enum diagnostics_output_format
30 {
31 /* The default: textual output. */
32 DIAGNOSTICS_OUTPUT_FORMAT_TEXT,
33
34 /* JSON-based output. */
35 DIAGNOSTICS_OUTPUT_FORMAT_JSON
36 };
37
38 /* An enum for controlling how diagnostic_paths should be printed. */
39 enum diagnostic_path_format
40 {
41 /* Don't print diagnostic_paths. */
42 DPF_NONE,
43
44 /* Print diagnostic_paths by emitting a separate "note" for every event
45 in the path. */
46 DPF_SEPARATE_EVENTS,
47
48 /* Print diagnostic_paths by consolidating events together where they
49 are close enough, and printing such runs of events with multiple
50 calls to diagnostic_show_locus, showing the individual events in
51 each run via labels in the source. */
52 DPF_INLINE_EVENTS
53 };
54
55 /* A diagnostic is described by the MESSAGE to send, the FILE and LINE of
56 its context and its KIND (ice, error, warning, note, ...) See complete
57 list in diagnostic.def. */
58 struct diagnostic_info
59 {
60 /* Text to be formatted. */
61 text_info message;
62
63 /* The location at which the diagnostic is to be reported. */
64 rich_location *richloc;
65
66 /* An optional bundle of metadata associated with the diagnostic
67 (or NULL). */
68 const diagnostic_metadata *metadata;
69
70 /* Auxiliary data for client. */
71 void *x_data;
72 /* The kind of diagnostic it is about. */
73 diagnostic_t kind;
74 /* Which OPT_* directly controls this diagnostic. */
75 int option_index;
76 };
77
78 /* Each time a diagnostic's classification is changed with a pragma,
79 we record the change and the location of the change in an array of
80 these structs. */
81 struct diagnostic_classification_change_t
82 {
83 location_t location;
84 int option;
85 diagnostic_t kind;
86 };
87
88 /* Forward declarations. */
89 typedef void (*diagnostic_starter_fn) (diagnostic_context *,
90 diagnostic_info *);
91
92 typedef void (*diagnostic_start_span_fn) (diagnostic_context *,
93 expanded_location);
94
95 typedef void (*diagnostic_finalizer_fn) (diagnostic_context *,
96 diagnostic_info *,
97 diagnostic_t);
98
99 class edit_context;
100 namespace json { class value; }
101
102 /* This data structure bundles altogether any information relevant to
103 the context of a diagnostic message. */
104 struct diagnostic_context
105 {
106 /* Where most of the diagnostic formatting work is done. */
107 pretty_printer *printer;
108
109 /* The number of times we have issued diagnostics. */
110 int diagnostic_count[DK_LAST_DIAGNOSTIC_KIND];
111
112 /* True if it has been requested that warnings be treated as errors. */
113 bool warning_as_error_requested;
114
115 /* The number of option indexes that can be passed to warning() et
116 al. */
117 int n_opts;
118
119 /* For each option index that can be passed to warning() et al
120 (OPT_* from options.h when using this code with the core GCC
121 options), this array may contain a new kind that the diagnostic
122 should be changed to before reporting, or DK_UNSPECIFIED to leave
123 it as the reported kind, or DK_IGNORED to not report it at
124 all. */
125 diagnostic_t *classify_diagnostic;
126
127 /* History of all changes to the classifications above. This list
128 is stored in location-order, so we can search it, either
129 binary-wise or end-to-front, to find the most recent
130 classification for a given diagnostic, given the location of the
131 diagnostic. */
132 diagnostic_classification_change_t *classification_history;
133
134 /* The size of the above array. */
135 int n_classification_history;
136
137 /* For pragma push/pop. */
138 int *push_list;
139 int n_push;
140
141 /* True if we should print the source line with a caret indicating
142 the location. */
143 bool show_caret;
144
145 /* Maximum width of the source line printed. */
146 int caret_max_width;
147
148 /* Character used for caret diagnostics. */
149 char caret_chars[rich_location::STATICALLY_ALLOCATED_RANGES];
150
151 /* True if we should print any CWE identifiers associated with
152 diagnostics. */
153 bool show_cwe;
154
155 /* How should diagnostic_path objects be printed. */
156 enum diagnostic_path_format path_format;
157
158 /* True if we should print stack depths when printing diagnostic paths. */
159 bool show_path_depths;
160
161 /* True if we should print the command line option which controls
162 each diagnostic, if known. */
163 bool show_option_requested;
164
165 /* True if we should raise a SIGABRT on errors. */
166 bool abort_on_error;
167
168 /* True if we should show the column number on diagnostics. */
169 bool show_column;
170
171 /* True if pedwarns are errors. */
172 bool pedantic_errors;
173
174 /* True if permerrors are warnings. */
175 bool permissive;
176
177 /* The index of the option to associate with turning permerrors into
178 warnings. */
179 int opt_permissive;
180
181 /* True if errors are fatal. */
182 bool fatal_errors;
183
184 /* True if all warnings should be disabled. */
185 bool dc_inhibit_warnings;
186
187 /* True if warnings should be given in system headers. */
188 bool dc_warn_system_headers;
189
190 /* Maximum number of errors to report. */
191 int max_errors;
192
193 /* This function is called before any message is printed out. It is
194 responsible for preparing message prefix and such. For example, it
195 might say:
196 In file included from "/usr/local/include/curses.h:5:
197 from "/home/gdr/src/nifty_printer.h:56:
198 ...
199 */
200 diagnostic_starter_fn begin_diagnostic;
201
202 /* This function is called by diagnostic_show_locus in between
203 disjoint spans of source code, so that the context can print
204 something to indicate that a new span of source code has begun. */
205 diagnostic_start_span_fn start_span;
206
207 /* This function is called after the diagnostic message is printed. */
208 diagnostic_finalizer_fn end_diagnostic;
209
210 /* Client hook to report an internal error. */
211 void (*internal_error) (diagnostic_context *, const char *, va_list *);
212
213 /* Client hook to say whether the option controlling a diagnostic is
214 enabled. Returns nonzero if enabled, zero if disabled. */
215 int (*option_enabled) (int, unsigned, void *);
216
217 /* Client information to pass as second argument to
218 option_enabled. */
219 void *option_state;
220
221 /* Client hook to return the name of an option that controls a
222 diagnostic. Returns malloced memory. The first diagnostic_t
223 argument is the kind of diagnostic before any reclassification
224 (of warnings as errors, etc.); the second is the kind after any
225 reclassification. May return NULL if no name is to be printed.
226 May be passed 0 as well as the index of a particular option. */
227 char *(*option_name) (diagnostic_context *, int, diagnostic_t, diagnostic_t);
228
229 /* Client hook to return a URL describing the option that controls
230 a diagnostic. Returns malloced memory. May return NULL if no URL
231 is available. May be passed 0 as well as the index of a
232 particular option. */
233 char *(*get_option_url) (diagnostic_context *, int);
234
235 void (*print_path) (diagnostic_context *, const diagnostic_path *);
236 json::value *(*make_json_for_path) (diagnostic_context *, const diagnostic_path *);
237
238 /* Auxiliary data for client. */
239 void *x_data;
240
241 /* Used to detect that the last caret was printed at the same location. */
242 location_t last_location;
243
244 /* Used to detect when the input file stack has changed since last
245 described. */
246 const line_map_ordinary *last_module;
247
248 int lock;
249
250 /* A copy of lang_hooks.option_lang_mask (). */
251 unsigned lang_mask;
252
253 bool inhibit_notes_p;
254
255 /* When printing source code, should the characters at carets and ranges
256 be colorized? (assuming colorization is on at all).
257 This should be true for frontends that generate range information
258 (so that the ranges of code are colorized),
259 and false for frontends that merely specify points within the
260 source code (to avoid e.g. colorizing just the first character in
261 a token, which would look strange). */
262 bool colorize_source_p;
263
264 /* When printing source code, should labelled ranges be printed? */
265 bool show_labels_p;
266
267 /* When printing source code, should there be a left-hand margin
268 showing line numbers? */
269 bool show_line_numbers_p;
270
271 /* If printing source code, what should the minimum width of the margin
272 be? Line numbers will be right-aligned, and padded to this width. */
273 int min_margin_width;
274
275 /* Usable by plugins; if true, print a debugging ruler above the
276 source output. */
277 bool show_ruler_p;
278
279 /* If true, print fixits in machine-parseable form after the
280 rest of the diagnostic. */
281 bool parseable_fixits_p;
282
283 /* If non-NULL, an edit_context to which fix-it hints should be
284 applied, for generating patches. */
285 edit_context *edit_context_ptr;
286
287 /* How many diagnostic_group instances are currently alive. */
288 int diagnostic_group_nesting_depth;
289
290 /* How many diagnostics have been emitted since the bottommost
291 diagnostic_group was pushed. */
292 int diagnostic_group_emission_count;
293
294 /* Optional callbacks for handling diagnostic groups. */
295
296 /* If non-NULL, this will be called immediately before the first
297 time a diagnostic is emitted within a stack of groups. */
298 void (*begin_group_cb) (diagnostic_context * context);
299
300 /* If non-NULL, this will be called when a stack of groups is
301 popped if any diagnostics were emitted within that group. */
302 void (*end_group_cb) (diagnostic_context * context);
303
304 /* Callback for final cleanup. */
305 void (*final_cb) (diagnostic_context *context);
306 };
307
308 static inline void
diagnostic_inhibit_notes(diagnostic_context * context)309 diagnostic_inhibit_notes (diagnostic_context * context)
310 {
311 context->inhibit_notes_p = true;
312 }
313
314
315 /* Client supplied function to announce a diagnostic. */
316 #define diagnostic_starter(DC) (DC)->begin_diagnostic
317
318 /* Client supplied function called after a diagnostic message is
319 displayed. */
320 #define diagnostic_finalizer(DC) (DC)->end_diagnostic
321
322 /* Extension hooks for client. */
323 #define diagnostic_context_auxiliary_data(DC) (DC)->x_data
324 #define diagnostic_info_auxiliary_data(DI) (DI)->x_data
325
326 /* Same as pp_format_decoder. Works on 'diagnostic_context *'. */
327 #define diagnostic_format_decoder(DC) ((DC)->printer->format_decoder)
328
329 /* Same as output_prefixing_rule. Works on 'diagnostic_context *'. */
330 #define diagnostic_prefixing_rule(DC) ((DC)->printer->wrapping.rule)
331
332 /* Raise SIGABRT on any diagnostic of severity DK_ERROR or higher. */
333 #define diagnostic_abort_on_error(DC) \
334 (DC)->abort_on_error = true
335
336 /* This diagnostic_context is used by front-ends that directly output
337 diagnostic messages without going through `error', `warning',
338 and similar functions. */
339 extern diagnostic_context *global_dc;
340
341 /* Returns whether the diagnostic framework has been intialized already and is
342 ready for use. */
343 #define diagnostic_ready_p() (global_dc->printer != NULL)
344
345 /* The total count of a KIND of diagnostics emitted so far. */
346 #define diagnostic_kind_count(DC, DK) (DC)->diagnostic_count[(int) (DK)]
347
348 /* The number of errors that have been issued so far. Ideally, these
349 would take a diagnostic_context as an argument. */
350 #define errorcount diagnostic_kind_count (global_dc, DK_ERROR)
351 /* Similarly, but for warnings. */
352 #define warningcount diagnostic_kind_count (global_dc, DK_WARNING)
353 /* Similarly, but for warnings promoted to errors. */
354 #define werrorcount diagnostic_kind_count (global_dc, DK_WERROR)
355 /* Similarly, but for sorrys. */
356 #define sorrycount diagnostic_kind_count (global_dc, DK_SORRY)
357
358 /* Returns nonzero if warnings should be emitted. */
359 #define diagnostic_report_warnings_p(DC, LOC) \
360 (!(DC)->dc_inhibit_warnings \
361 && !(in_system_header_at (LOC) && !(DC)->dc_warn_system_headers))
362
363 /* Override the option index to be used for reporting a
364 diagnostic. */
365
366 static inline void
diagnostic_override_option_index(diagnostic_info * info,int optidx)367 diagnostic_override_option_index (diagnostic_info *info, int optidx)
368 {
369 info->option_index = optidx;
370 }
371
372 /* Diagnostic related functions. */
373 extern void diagnostic_initialize (diagnostic_context *, int);
374 extern void diagnostic_color_init (diagnostic_context *, int value = -1);
375 extern void diagnostic_urls_init (diagnostic_context *, int value = -1);
376 extern void diagnostic_finish (diagnostic_context *);
377 extern void diagnostic_report_current_module (diagnostic_context *, location_t);
378 extern void diagnostic_show_locus (diagnostic_context *,
379 rich_location *richloc,
380 diagnostic_t diagnostic_kind);
381 extern void diagnostic_show_any_path (diagnostic_context *, diagnostic_info *);
382
383 /* Force diagnostics controlled by OPTIDX to be kind KIND. */
384 extern diagnostic_t diagnostic_classify_diagnostic (diagnostic_context *,
385 int /* optidx */,
386 diagnostic_t /* kind */,
387 location_t);
388 extern void diagnostic_push_diagnostics (diagnostic_context *, location_t);
389 extern void diagnostic_pop_diagnostics (diagnostic_context *, location_t);
390 extern bool diagnostic_report_diagnostic (diagnostic_context *,
391 diagnostic_info *);
392 #ifdef ATTRIBUTE_GCC_DIAG
393 extern void diagnostic_set_info (diagnostic_info *, const char *, va_list *,
394 rich_location *, diagnostic_t) ATTRIBUTE_GCC_DIAG(2,0);
395 extern void diagnostic_set_info_translated (diagnostic_info *, const char *,
396 va_list *, rich_location *,
397 diagnostic_t)
398 ATTRIBUTE_GCC_DIAG(2,0);
399 extern void diagnostic_append_note (diagnostic_context *, location_t,
400 const char *, ...) ATTRIBUTE_GCC_DIAG(3,4);
401 #endif
402 extern char *diagnostic_build_prefix (diagnostic_context *, const diagnostic_info *);
403 void default_diagnostic_starter (diagnostic_context *, diagnostic_info *);
404 void default_diagnostic_start_span_fn (diagnostic_context *,
405 expanded_location);
406 void default_diagnostic_finalizer (diagnostic_context *, diagnostic_info *,
407 diagnostic_t);
408 void diagnostic_set_caret_max_width (diagnostic_context *context, int value);
409 void diagnostic_action_after_output (diagnostic_context *, diagnostic_t);
410 void diagnostic_check_max_errors (diagnostic_context *, bool flush = false);
411
412 void diagnostic_file_cache_fini (void);
413
414 int get_terminal_width (void);
415
416 /* Return the location associated to this diagnostic. Parameter WHICH
417 specifies which location. By default, expand the first one. */
418
419 static inline location_t
420 diagnostic_location (const diagnostic_info * diagnostic, int which = 0)
421 {
422 return diagnostic->message.get_location (which);
423 }
424
425 /* Return the number of locations to be printed in DIAGNOSTIC. */
426
427 static inline unsigned int
diagnostic_num_locations(const diagnostic_info * diagnostic)428 diagnostic_num_locations (const diagnostic_info * diagnostic)
429 {
430 return diagnostic->message.m_richloc->get_num_locations ();
431 }
432
433 /* Expand the location of this diagnostic. Use this function for
434 consistency. Parameter WHICH specifies which location. By default,
435 expand the first one. */
436
437 static inline expanded_location
438 diagnostic_expand_location (const diagnostic_info * diagnostic, int which = 0)
439 {
440 return diagnostic->richloc->get_expanded_location (which);
441 }
442
443 /* This is somehow the right-side margin of a caret line, that is, we
444 print at least these many characters after the position pointed at
445 by the caret. */
446 const int CARET_LINE_MARGIN = 10;
447
448 /* Return true if the two locations can be represented within the same
449 caret line. This is used to build a prefix and also to determine
450 whether to print one or two caret lines. */
451
452 static inline bool
diagnostic_same_line(const diagnostic_context * context,expanded_location s1,expanded_location s2)453 diagnostic_same_line (const diagnostic_context *context,
454 expanded_location s1, expanded_location s2)
455 {
456 return s2.column && s1.line == s2.line
457 && context->caret_max_width - CARET_LINE_MARGIN > abs (s1.column - s2.column);
458 }
459
460 extern const char *diagnostic_get_color_for_kind (diagnostic_t kind);
461
462 /* Pure text formatting support functions. */
463 extern char *file_name_as_prefix (diagnostic_context *, const char *);
464
465 extern char *build_message_string (const char *, ...) ATTRIBUTE_PRINTF_1;
466
467 extern void diagnostic_output_format_init (diagnostic_context *,
468 enum diagnostics_output_format);
469
470 /* Compute the number of digits in the decimal representation of an integer. */
471 extern int num_digits (int);
472
473 extern json::value *json_from_expanded_location (location_t loc);
474
475 #endif /* ! GCC_DIAGNOSTIC_H */
476