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