gcc/diagnostic.h

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