gcc/diagnostic.h

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