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, unsigned, 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   /* Client hook to return a URL describing the option that controls
 198      a diagnostic.  Returns malloced memory.  May return NULL if no URL
 199      is available.  May be passed 0 as well as the index of a
 200      particular option.  */
 201   char *(*get_option_url) (diagnostic_context *, int);
 202
 203   /* Auxiliary data for client.  */
 204   void *x_data;
 205
 206   /* Used to detect that the last caret was printed at the same location.  */
 207   location_t last_location;
 208
 209   /* Used to detect when the input file stack has changed since last
 210      described.  */
 211   const line_map_ordinary *last_module;
 212
 213   int lock;
 214
 215   /* A copy of lang_hooks.option_lang_mask ().  */
 216   unsigned lang_mask;
 217
 218   bool inhibit_notes_p;
 219
 220   /* When printing source code, should the characters at carets and ranges
 221      be colorized? (assuming colorization is on at all).
 222      This should be true for frontends that generate range information
 223      (so that the ranges of code are colorized),
 224      and false for frontends that merely specify points within the
 225      source code (to avoid e.g. colorizing just the first character in
 226      a token, which would look strange).  */
 227   bool colorize_source_p;
 228
 229   /* When printing source code, should labelled ranges be printed?  */
 230   bool show_labels_p;
 231
 232   /* When printing source code, should there be a left-hand margin
 233      showing line numbers?  */
 234   bool show_line_numbers_p;
 235
 236   /* If printing source code, what should the minimum width of the margin
 237      be?  Line numbers will be right-aligned, and padded to this width.  */
 238   int min_margin_width;
 239
 240   /* Usable by plugins; if true, print a debugging ruler above the
 241      source output.  */
 242   bool show_ruler_p;
 243
 244   /* If true, print fixits in machine-parseable form after the
 245      rest of the diagnostic.  */
 246   bool parseable_fixits_p;
 247
 248   /* If non-NULL, an edit_context to which fix-it hints should be
 249      applied, for generating patches.  */
 250   edit_context *edit_context_ptr;
 251
 252   /* How many diagnostic_group instances are currently alive.  */
 253   int diagnostic_group_nesting_depth;
 254
 255   /* How many diagnostics have been emitted since the bottommost
 256      diagnostic_group was pushed.  */
 257   int diagnostic_group_emission_count;
 258
 259   /* Optional callbacks for handling diagnostic groups.  */
 260
 261   /* If non-NULL, this will be called immediately before the first
 262      time a diagnostic is emitted within a stack of groups.  */
 263   void (*begin_group_cb) (diagnostic_context * context);
 264
 265   /* If non-NULL, this will be called when a stack of groups is
 266      popped if any diagnostics were emitted within that group.  */
 267   void (*end_group_cb) (diagnostic_context * context);
 268
 269   /* Callback for final cleanup.  */
 270   void (*final_cb) (diagnostic_context *context);
 271 };
 272
 273 static inline void
 274 diagnostic_inhibit_notes (diagnostic_context * context)
 275 {
 276   context->inhibit_notes_p = true;
 277 }
 278
 279
 280 /* Client supplied function to announce a diagnostic.  */
 281 #define diagnostic_starter(DC) (DC)->begin_diagnostic
 282
 283 /* Client supplied function called after a diagnostic message is
 284    displayed.  */
 285 #define diagnostic_finalizer(DC) (DC)->end_diagnostic
 286
 287 /* Extension hooks for client.  */
 288 #define diagnostic_context_auxiliary_data(DC) (DC)->x_data
 289 #define diagnostic_info_auxiliary_data(DI) (DI)->x_data
 290
 291 /* Same as pp_format_decoder.  Works on 'diagnostic_context *'.  */
 292 #define diagnostic_format_decoder(DC) ((DC)->printer->format_decoder)
 293
 294 /* Same as output_prefixing_rule.  Works on 'diagnostic_context *'.  */
 295 #define diagnostic_prefixing_rule(DC) ((DC)->printer->wrapping.rule)
 296
 297 /* Raise SIGABRT on any diagnostic of severity DK_ERROR or higher.  */
 298 #define diagnostic_abort_on_error(DC) \
 299   (DC)->abort_on_error = true
 300
 301 /* This diagnostic_context is used by front-ends that directly output
 302    diagnostic messages without going through `error', `warning',
 303    and similar functions.  */
 304 extern diagnostic_context *global_dc;
 305
 306 /* Returns whether the diagnostic framework has been intialized already and is
 307    ready for use.  */
 308 #define diagnostic_ready_p() (global_dc->printer != NULL)
 309
 310 /* The total count of a KIND of diagnostics emitted so far.  */
 311 #define diagnostic_kind_count(DC, DK) (DC)->diagnostic_count[(int) (DK)]
 312
 313 /* The number of errors that have been issued so far.  Ideally, these
 314    would take a diagnostic_context as an argument.  */
 315 #define errorcount diagnostic_kind_count (global_dc, DK_ERROR)
 316 /* Similarly, but for warnings.  */
 317 #define warningcount diagnostic_kind_count (global_dc, DK_WARNING)
 318 /* Similarly, but for warnings promoted to errors.  */
 319 #define werrorcount diagnostic_kind_count (global_dc, DK_WERROR)
 320 /* Similarly, but for sorrys.  */
 321 #define sorrycount diagnostic_kind_count (global_dc, DK_SORRY)
 322
 323 /* Returns nonzero if warnings should be emitted.  */
 324 #define diagnostic_report_warnings_p(DC, LOC)                           \
 325   (!(DC)->dc_inhibit_warnings                                           \
 326    && !(in_system_header_at (LOC) && !(DC)->dc_warn_system_headers))
 327
 328 /* Override the option index to be used for reporting a
 329    diagnostic.  */
 330
 331 static inline void
 332 diagnostic_override_option_index (diagnostic_info *info, int optidx)
 333 {
 334   info->option_index = optidx;
 335 }
 336
 337 /* Diagnostic related functions.  */
 338 extern void diagnostic_initialize (diagnostic_context *, int);
 339 extern void diagnostic_color_init (diagnostic_context *, int value = -1);
 340 extern void diagnostic_urls_init (diagnostic_context *, int value = -1);
 341 extern void diagnostic_finish (diagnostic_context *);
 342 extern void diagnostic_report_current_module (diagnostic_context *, location_t);
 343 extern void diagnostic_show_locus (diagnostic_context *,
 344                                    rich_location *richloc,
 345                                    diagnostic_t diagnostic_kind);
 346
 347 /* Force diagnostics controlled by OPTIDX to be kind KIND.  */
 348 extern diagnostic_t diagnostic_classify_diagnostic (diagnostic_context *,
 349                                                     int /* optidx */,
 350                                                     diagnostic_t /* kind */,
 351                                                     location_t);
 352 extern void diagnostic_push_diagnostics (diagnostic_context *, location_t);
 353 extern void diagnostic_pop_diagnostics (diagnostic_context *, location_t);
 354 extern bool diagnostic_report_diagnostic (diagnostic_context *,
 355                                           diagnostic_info *);
 356 #ifdef ATTRIBUTE_GCC_DIAG
 357 extern void diagnostic_set_info (diagnostic_info *, const char *, va_list *,
 358                                  rich_location *, diagnostic_t) ATTRIBUTE_GCC_DIAG(2,0);
 359 extern void diagnostic_set_info_translated (diagnostic_info *, const char *,
 360                                             va_list *, rich_location *,
 361                                             diagnostic_t)
 362      ATTRIBUTE_GCC_DIAG(2,0);
 363 extern void diagnostic_append_note (diagnostic_context *, location_t,
 364                                     const char *, ...) ATTRIBUTE_GCC_DIAG(3,4);
 365 #endif
 366 extern char *diagnostic_build_prefix (diagnostic_context *, const diagnostic_info *);
 367 void default_diagnostic_starter (diagnostic_context *, diagnostic_info *);
 368 void default_diagnostic_start_span_fn (diagnostic_context *,
 369                                        expanded_location);
 370 void default_diagnostic_finalizer (diagnostic_context *, diagnostic_info *,
 371                                    diagnostic_t);
 372 void diagnostic_set_caret_max_width (diagnostic_context *context, int value);
 373 void diagnostic_action_after_output (diagnostic_context *, diagnostic_t);
 374 void diagnostic_check_max_errors (diagnostic_context *, bool flush = false);
 375
 376 void diagnostic_file_cache_fini (void);
 377
 378 int get_terminal_width (void);
 379
 380 /* Return the location associated to this diagnostic. Parameter WHICH
 381    specifies which location. By default, expand the first one.  */
 382
 383 static inline location_t
 384 diagnostic_location (const diagnostic_info * diagnostic, int which = 0)
 385 {
 386   return diagnostic->message.get_location (which);
 387 }
 388
 389 /* Return the number of locations to be printed in DIAGNOSTIC.  */
 390
 391 static inline unsigned int
 392 diagnostic_num_locations (const diagnostic_info * diagnostic)
 393 {
 394   return diagnostic->message.m_richloc->get_num_locations ();
 395 }
 396
 397 /* Expand the location of this diagnostic. Use this function for
 398    consistency.  Parameter WHICH specifies which location. By default,
 399    expand the first one.  */
 400
 401 static inline expanded_location
 402 diagnostic_expand_location (const diagnostic_info * diagnostic, int which = 0)
 403 {
 404   return diagnostic->richloc->get_expanded_location (which);
 405 }
 406
 407 /* This is somehow the right-side margin of a caret line, that is, we
 408    print at least these many characters after the position pointed at
 409    by the caret.  */
 410 const int CARET_LINE_MARGIN = 10;
 411
 412 /* Return true if the two locations can be represented within the same
 413    caret line.  This is used to build a prefix and also to determine
 414    whether to print one or two caret lines.  */
 415
 416 static inline bool
 417 diagnostic_same_line (const diagnostic_context *context,
 418                        expanded_location s1, expanded_location s2)
 419 {
 420   return s2.column && s1.line == s2.line
 421     && context->caret_max_width - CARET_LINE_MARGIN > abs (s1.column - s2.column);
 422 }
 423
 424 extern const char *diagnostic_get_color_for_kind (diagnostic_t kind);
 425
 426 /* Pure text formatting support functions.  */
 427 extern char *file_name_as_prefix (diagnostic_context *, const char *);
 428
 429 extern char *build_message_string (const char *, ...) ATTRIBUTE_PRINTF_1;
 430
 431 extern void diagnostic_output_format_init (diagnostic_context *,
 432                                            enum diagnostics_output_format);
 433
 434 /* Compute the number of digits in the decimal representation of an integer.  */
 435 extern int num_digits (int);
 436
 437 #endif /* ! GCC_DIAGNOSTIC_H */