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