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