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
 206 static inline void
 207 diagnostic_inhibit_notes (diagnostic_context * context)
 208 {
 209   context->inhibit_notes_p = true;
 210 }
 211
 212
 213 /* Client supplied function to announce a diagnostic.  */
 214 #define diagnostic_starter(DC) (DC)->begin_diagnostic
 215
 216 /* Client supplied function called after a diagnostic message is
 217    displayed.  */
 218 #define diagnostic_finalizer(DC) (DC)->end_diagnostic
 219
 220 /* Extension hooks for client.  */
 221 #define diagnostic_context_auxiliary_data(DC) (DC)->x_data
 222 #define diagnostic_info_auxiliary_data(DI) (DI)->x_data
 223
 224 /* Same as pp_format_decoder.  Works on 'diagnostic_context *'.  */
 225 #define diagnostic_format_decoder(DC) ((DC)->printer->format_decoder)
 226
 227 /* Same as output_prefixing_rule.  Works on 'diagnostic_context *'.  */
 228 #define diagnostic_prefixing_rule(DC) ((DC)->printer->wrapping.rule)
 229
 230 /* Maximum characters per line in automatic line wrapping mode.
 231    Zero means don't wrap lines.  */
 232 #define diagnostic_line_cutoff(DC) ((DC)->printer->wrapping.line_cutoff)
 233
 234 #define diagnostic_flush_buffer(DC) pp_flush ((DC)->printer)
 235
 236 /* True if the last module or file in which a diagnostic was reported is
 237    different from the current one.  */
 238 #define diagnostic_last_module_changed(DC, MAP) \
 239   ((DC)->last_module != MAP)
 240
 241 /* Remember the current module or file as being the last one in which we
 242    report a diagnostic.  */
 243 #define diagnostic_set_last_module(DC, MAP)     \
 244   (DC)->last_module = MAP
 245
 246 /* Raise SIGABRT on any diagnostic of severity DK_ERROR or higher.  */
 247 #define diagnostic_abort_on_error(DC) \
 248   (DC)->abort_on_error = true
 249
 250 /* This diagnostic_context is used by front-ends that directly output
 251    diagnostic messages without going through `error', `warning',
 252    and similar functions.  */
 253 extern diagnostic_context *global_dc;
 254
 255 /* The total count of a KIND of diagnostics emitted so far.  */
 256 #define diagnostic_kind_count(DC, DK) (DC)->diagnostic_count[(int) (DK)]
 257
 258 /* The number of errors that have been issued so far.  Ideally, these
 259    would take a diagnostic_context as an argument.  */
 260 #define errorcount diagnostic_kind_count (global_dc, DK_ERROR)
 261 /* Similarly, but for warnings.  */
 262 #define warningcount diagnostic_kind_count (global_dc, DK_WARNING)
 263 /* Similarly, but for warnings promoted to errors.  */
 264 #define werrorcount diagnostic_kind_count (global_dc, DK_WERROR)
 265 /* Similarly, but for sorrys.  */
 266 #define sorrycount diagnostic_kind_count (global_dc, DK_SORRY)
 267
 268 /* Returns nonzero if warnings should be emitted.  */
 269 #define diagnostic_report_warnings_p(DC, LOC)                           \
 270   (!(DC)->dc_inhibit_warnings                                           \
 271    && !(in_system_header_at (LOC) && !(DC)->dc_warn_system_headers))
 272
 273 #define report_diagnostic(D) diagnostic_report_diagnostic (global_dc, D)
 274
 275 /* Override the option index to be used for reporting a
 276    diagnostic.  */
 277 #define diagnostic_override_option_index(DI, OPTIDX) \
 278     ((DI)->option_index = (OPTIDX))
 279
 280 /* Diagnostic related functions.  */
 281 extern void diagnostic_initialize (diagnostic_context *, int);
 282 extern void diagnostic_color_init (diagnostic_context *, int value = -1);
 283 extern void diagnostic_finish (diagnostic_context *);
 284 extern void diagnostic_report_current_module (diagnostic_context *, location_t);
 285 extern void diagnostic_show_locus (diagnostic_context *, const diagnostic_info *);
 286
 287 /* Force diagnostics controlled by OPTIDX to be kind KIND.  */
 288 extern diagnostic_t diagnostic_classify_diagnostic (diagnostic_context *,
 289                                                     int /* optidx */,
 290                                                     diagnostic_t /* kind */,
 291                                                     location_t);
 292 extern void diagnostic_push_diagnostics (diagnostic_context *, location_t);
 293 extern void diagnostic_pop_diagnostics (diagnostic_context *, location_t);
 294 extern bool diagnostic_report_diagnostic (diagnostic_context *,
 295                                           diagnostic_info *);
 296 #ifdef ATTRIBUTE_GCC_DIAG
 297 extern void diagnostic_set_info (diagnostic_info *, const char *, va_list *,
 298                                  rich_location *, diagnostic_t) ATTRIBUTE_GCC_DIAG(2,0);
 299 extern void diagnostic_set_info_translated (diagnostic_info *, const char *,
 300                                             va_list *, rich_location *,
 301                                             diagnostic_t)
 302      ATTRIBUTE_GCC_DIAG(2,0);
 303 extern void diagnostic_append_note (diagnostic_context *, location_t,
 304                                     const char *, ...) ATTRIBUTE_GCC_DIAG(3,4);
 305 #endif
 306 extern char *diagnostic_build_prefix (diagnostic_context *, const diagnostic_info *);
 307 void default_diagnostic_starter (diagnostic_context *, diagnostic_info *);
 308 void default_diagnostic_start_span_fn (diagnostic_context *,
 309                                        expanded_location);
 310 void default_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
 311 void diagnostic_set_caret_max_width (diagnostic_context *context, int value);
 312 void diagnostic_action_after_output (diagnostic_context *, diagnostic_t);
 313
 314 void diagnostic_file_cache_fini (void);
 315
 316 int get_terminal_width (void);
 317
 318 /* Return the location associated to this diagnostic. Parameter WHICH
 319    specifies which location. By default, expand the first one.  */
 320
 321 static inline location_t
 322 diagnostic_location (const diagnostic_info * diagnostic, int which = 0)
 323 {
 324   return diagnostic->message.get_location (which);
 325 }
 326
 327 /* Return the number of locations to be printed in DIAGNOSTIC.  */
 328
 329 static inline unsigned int
 330 diagnostic_num_locations (const diagnostic_info * diagnostic)
 331 {
 332   return diagnostic->message.m_richloc->get_num_locations ();
 333 }
 334
 335 /* Expand the location of this diagnostic. Use this function for
 336    consistency.  Parameter WHICH specifies which location. By default,
 337    expand the first one.  */
 338
 339 static inline expanded_location
 340 diagnostic_expand_location (const diagnostic_info * diagnostic, int which = 0)
 341 {
 342   return diagnostic->richloc->get_expanded_location (which);
 343 }
 344
 345 /* This is somehow the right-side margin of a caret line, that is, we
 346    print at least these many characters after the position pointed at
 347    by the caret.  */
 348 #define CARET_LINE_MARGIN 10
 349
 350 /* Return true if the two locations can be represented within the same
 351    caret line.  This is used to build a prefix and also to determine
 352    whether to print one or two caret lines.  */
 353
 354 static inline bool
 355 diagnostic_same_line (const diagnostic_context *context,
 356                        expanded_location s1, expanded_location s2)
 357 {
 358   return s2.column && s1.line == s2.line
 359     && context->caret_max_width - CARET_LINE_MARGIN > abs (s1.column - s2.column);
 360 }
 361
 362 extern const char *diagnostic_get_color_for_kind (diagnostic_t kind);
 363
 364 /* Pure text formatting support functions.  */
 365 extern char *file_name_as_prefix (diagnostic_context *, const char *);
 366
 367 extern char *build_message_string (const char *, ...) ATTRIBUTE_PRINTF_1;
 368
 369
 370 #endif /* ! GCC_DIAGNOSTIC_H */