gcc/diagnostic.h

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