gcc/diagnostic.h

   1 /* Various declarations for language-independent diagnostics subroutines.
   2    Copyright (C) 2000-2023 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 namespace text_art
  28 {
  29   class theme;
  30 } // namespace text_art
  31
  32 /* An enum for controlling what units to use for the column number
  33    when diagnostics are output, used by the -fdiagnostics-column-unit option.
  34    Tabs will be expanded or not according to the value of -ftabstop.  The origin
  35    (default 1) is controlled by -fdiagnostics-column-origin.  */
  36
  37 enum diagnostics_column_unit
  38 {
  39   /* The default from GCC 11 onwards: display columns.  */
  40   DIAGNOSTICS_COLUMN_UNIT_DISPLAY,
  41
  42   /* The behavior in GCC 10 and earlier: simple bytes.  */
  43   DIAGNOSTICS_COLUMN_UNIT_BYTE
  44 };
  45
  46 /* An enum for controlling how to print non-ASCII characters/bytes when
  47    a diagnostic suggests escaping the source code on output.  */
  48
  49 enum diagnostics_escape_format
  50 {
  51   /* Escape non-ASCII Unicode characters in the form <U+XXXX> and
  52      non-UTF-8 bytes in the form <XX>.  */
  53   DIAGNOSTICS_ESCAPE_FORMAT_UNICODE,
  54
  55   /* Escape non-ASCII bytes in the form <XX> (thus showing the underlying
  56      encoding of non-ASCII Unicode characters).  */
  57   DIAGNOSTICS_ESCAPE_FORMAT_BYTES
  58 };
  59
  60 /* Enum for overriding the standard output format.  */
  61
  62 enum diagnostics_output_format
  63 {
  64   /* The default: textual output.  */
  65   DIAGNOSTICS_OUTPUT_FORMAT_TEXT,
  66
  67   /* JSON-based output, to stderr.  */
  68   DIAGNOSTICS_OUTPUT_FORMAT_JSON_STDERR,
  69
  70   /* JSON-based output, to a file.  */
  71   DIAGNOSTICS_OUTPUT_FORMAT_JSON_FILE,
  72
  73   /* SARIF-based output, to stderr.  */
  74   DIAGNOSTICS_OUTPUT_FORMAT_SARIF_STDERR,
  75
  76   /* SARIF-based output, to a file.  */
  77   DIAGNOSTICS_OUTPUT_FORMAT_SARIF_FILE
  78 };
  79
  80 /* An enum for controlling how diagnostic_paths should be printed.  */
  81 enum diagnostic_path_format
  82 {
  83   /* Don't print diagnostic_paths.  */
  84   DPF_NONE,
  85
  86   /* Print diagnostic_paths by emitting a separate "note" for every event
  87      in the path.  */
  88   DPF_SEPARATE_EVENTS,
  89
  90   /* Print diagnostic_paths by consolidating events together where they
  91      are close enough, and printing such runs of events with multiple
  92      calls to diagnostic_show_locus, showing the individual events in
  93      each run via labels in the source.  */
  94   DPF_INLINE_EVENTS
  95 };
  96
  97 /* An enum for capturing values of GCC_EXTRA_DIAGNOSTIC_OUTPUT,
  98    and for -fdiagnostics-parseable-fixits.  */
  99
 100 enum diagnostics_extra_output_kind
 101 {
 102   /* No extra output, or an unrecognized value.  */
 103   EXTRA_DIAGNOSTIC_OUTPUT_none,
 104
 105   /* Emit fix-it hints using the "fixits-v1" format, equivalent to
 106      -fdiagnostics-parseable-fixits.  */
 107   EXTRA_DIAGNOSTIC_OUTPUT_fixits_v1,
 108
 109   /* Emit fix-it hints using the "fixits-v2" format.  */
 110   EXTRA_DIAGNOSTIC_OUTPUT_fixits_v2
 111 };
 112
 113 /* A diagnostic is described by the MESSAGE to send, the FILE and LINE of
 114    its context and its KIND (ice, error, warning, note, ...)  See complete
 115    list in diagnostic.def.  */
 116 struct diagnostic_info
 117 {
 118   diagnostic_info ()
 119     : message (), richloc (), metadata (), x_data (), kind (), option_index (),
 120       m_iinfo ()
 121   { }
 122
 123   /* Text to be formatted.  */
 124   text_info message;
 125
 126   /* The location at which the diagnostic is to be reported.  */
 127   rich_location *richloc;
 128
 129   /* An optional bundle of metadata associated with the diagnostic
 130      (or NULL).  */
 131   const diagnostic_metadata *metadata;
 132
 133   /* Auxiliary data for client.  */
 134   void *x_data;
 135   /* The kind of diagnostic it is about.  */
 136   diagnostic_t kind;
 137   /* Which OPT_* directly controls this diagnostic.  */
 138   int option_index;
 139
 140   /* Inlining context containing locations for each call site along
 141      the inlining stack.  */
 142   struct inlining_info
 143   {
 144     /* Locations along the inlining stack.  */
 145     auto_vec<location_t, 8> m_ilocs;
 146     /* The abstract origin of the location.  */
 147     void *m_ao;
 148     /* Set if every M_ILOCS element is in a system header.  */
 149     bool m_allsyslocs;
 150   } m_iinfo;
 151 };
 152
 153 /* Each time a diagnostic's classification is changed with a pragma,
 154    we record the change and the location of the change in an array of
 155    these structs.  */
 156 struct diagnostic_classification_change_t
 157 {
 158   location_t location;
 159   int option;
 160   diagnostic_t kind;
 161 };
 162
 163 /*  Forward declarations.  */
 164 typedef void (*diagnostic_starter_fn) (diagnostic_context *,
 165                                        diagnostic_info *);
 166
 167 typedef void (*diagnostic_start_span_fn) (diagnostic_context *,
 168                                           expanded_location);
 169
 170 typedef void (*diagnostic_finalizer_fn) (diagnostic_context *,
 171                                          diagnostic_info *,
 172                                          diagnostic_t);
 173
 174 class edit_context;
 175 namespace json { class value; }
 176 class diagnostic_client_data_hooks;
 177 class logical_location;
 178 class diagnostic_diagram;
 179
 180 /* Abstract base class for a particular output format for diagnostics;
 181    each value of -fdiagnostics-output-format= will have its own
 182    implementation.  */
 183
 184 class diagnostic_output_format
 185 {
 186 public:
 187   virtual ~diagnostic_output_format () {}
 188
 189   virtual void on_begin_group () = 0;
 190   virtual void on_end_group () = 0;
 191   virtual void on_begin_diagnostic (diagnostic_info *) = 0;
 192   virtual void on_end_diagnostic (diagnostic_info *,
 193                                   diagnostic_t orig_diag_kind) = 0;
 194   virtual void on_diagram (const diagnostic_diagram &diagram) = 0;
 195
 196 protected:
 197   diagnostic_output_format (diagnostic_context &context)
 198   : m_context (context)
 199   {}
 200
 201   diagnostic_context &m_context;
 202 };
 203
 204 /* Subclass of diagnostic_output_format for classic text-based output
 205    to stderr.
 206
 207    Uses diagnostic_context.m_text_callbacks to provide client-specific
 208    textual output (e.g. include paths, macro expansions, etc).  */
 209
 210 class diagnostic_text_output_format : public diagnostic_output_format
 211 {
 212 public:
 213   diagnostic_text_output_format (diagnostic_context &context)
 214   : diagnostic_output_format (context)
 215   {}
 216   ~diagnostic_text_output_format ();
 217   void on_begin_group () override {}
 218   void on_end_group () override {}
 219   void on_begin_diagnostic (diagnostic_info *) override;
 220   void on_end_diagnostic (diagnostic_info *,
 221                           diagnostic_t orig_diag_kind) override;
 222   void on_diagram (const diagnostic_diagram &diagram) override;
 223 };
 224
 225 /* This data structure bundles altogether any information relevant to
 226    the context of a diagnostic message.  */
 227 struct diagnostic_context
 228 {
 229   /* Where most of the diagnostic formatting work is done.  */
 230   pretty_printer *printer;
 231
 232   /* Cache of source code.  */
 233   file_cache *m_file_cache;
 234
 235   /* The number of times we have issued diagnostics.  */
 236   int diagnostic_count[DK_LAST_DIAGNOSTIC_KIND];
 237
 238   /* True if it has been requested that warnings be treated as errors.  */
 239   bool warning_as_error_requested;
 240
 241   /* The number of option indexes that can be passed to warning() et
 242      al.  */
 243   int n_opts;
 244
 245   /* For each option index that can be passed to warning() et al
 246      (OPT_* from options.h when using this code with the core GCC
 247      options), this array may contain a new kind that the diagnostic
 248      should be changed to before reporting, or DK_UNSPECIFIED to leave
 249      it as the reported kind, or DK_IGNORED to not report it at
 250      all.  */
 251   diagnostic_t *classify_diagnostic;
 252
 253   /* History of all changes to the classifications above.  This list
 254      is stored in location-order, so we can search it, either
 255      binary-wise or end-to-front, to find the most recent
 256      classification for a given diagnostic, given the location of the
 257      diagnostic.  */
 258   diagnostic_classification_change_t *classification_history;
 259
 260   /* The size of the above array.  */
 261   int n_classification_history;
 262
 263   /* For pragma push/pop.  */
 264   int *push_list;
 265   int n_push;
 266
 267   /* True if we should print any CWE identifiers associated with
 268      diagnostics.  */
 269   bool show_cwe;
 270
 271   /* True if we should print any rules associated with diagnostics.  */
 272   bool show_rules;
 273
 274   /* How should diagnostic_path objects be printed.  */
 275   enum diagnostic_path_format path_format;
 276
 277   /* True if we should print stack depths when printing diagnostic paths.  */
 278   bool show_path_depths;
 279
 280   /* True if we should print the command line option which controls
 281      each diagnostic, if known.  */
 282   bool show_option_requested;
 283
 284   /* True if we should raise a SIGABRT on errors.  */
 285   bool abort_on_error;
 286
 287   /* True if we should show the column number on diagnostics.  */
 288   bool show_column;
 289
 290   /* True if pedwarns are errors.  */
 291   bool pedantic_errors;
 292
 293   /* True if permerrors are warnings.  */
 294   bool permissive;
 295
 296   /* The index of the option to associate with turning permerrors into
 297      warnings.  */
 298   int opt_permissive;
 299
 300   /* True if errors are fatal.  */
 301   bool fatal_errors;
 302
 303   /* True if all warnings should be disabled.  */
 304   bool dc_inhibit_warnings;
 305
 306   /* True if warnings should be given in system headers.  */
 307   bool dc_warn_system_headers;
 308
 309   /* Maximum number of errors to report.  */
 310   int max_errors;
 311
 312   /* Client-supplied callbacks for use in text output.  */
 313   struct {
 314     /* This function is called before any message is printed out.  It is
 315        responsible for preparing message prefix and such.  For example, it
 316        might say:
 317        In file included from "/usr/local/include/curses.h:5:
 318        from "/home/gdr/src/nifty_printer.h:56:
 319        ...
 320     */
 321     diagnostic_starter_fn begin_diagnostic;
 322
 323     /* This function is called by diagnostic_show_locus in between
 324        disjoint spans of source code, so that the context can print
 325        something to indicate that a new span of source code has begun.  */
 326     diagnostic_start_span_fn start_span;
 327
 328     /* This function is called after the diagnostic message is printed.  */
 329     diagnostic_finalizer_fn end_diagnostic;
 330   } m_text_callbacks;
 331
 332   /* Client hook to report an internal error.  */
 333   void (*internal_error) (diagnostic_context *, const char *, va_list *);
 334
 335   /* Client hook to say whether the option controlling a diagnostic is
 336      enabled.  Returns nonzero if enabled, zero if disabled.  */
 337   int (*option_enabled) (int, unsigned, void *);
 338
 339   /* Client information to pass as second argument to
 340      option_enabled.  */
 341   void *option_state;
 342
 343   /* Client hook to return the name of an option that controls a
 344      diagnostic.  Returns malloced memory.  The first diagnostic_t
 345      argument is the kind of diagnostic before any reclassification
 346      (of warnings as errors, etc.); the second is the kind after any
 347      reclassification.  May return NULL if no name is to be printed.
 348      May be passed 0 as well as the index of a particular option.  */
 349   char *(*option_name) (diagnostic_context *, int, diagnostic_t, diagnostic_t);
 350
 351   /* Client hook to return a URL describing the option that controls
 352      a diagnostic.  Returns malloced memory.  May return NULL if no URL
 353      is available.  May be passed 0 as well as the index of a
 354      particular option.  */
 355   char *(*get_option_url) (diagnostic_context *, int);
 356
 357   void (*print_path) (diagnostic_context *, const diagnostic_path *);
 358   json::value *(*make_json_for_path) (diagnostic_context *, const diagnostic_path *);
 359
 360   /* Auxiliary data for client.  */
 361   void *x_data;
 362
 363   /* Used to detect that the last caret was printed at the same location.  */
 364   location_t last_location;
 365
 366   /* Used to detect when the input file stack has changed since last
 367      described.  */
 368   const line_map_ordinary *last_module;
 369
 370   int lock;
 371
 372   /* A copy of lang_hooks.option_lang_mask ().  */
 373   unsigned lang_mask;
 374
 375   bool inhibit_notes_p;
 376
 377   /* Fields relating to printing the user's source code (potentially with
 378      a margin, underlining, labels, etc).  */
 379   struct {
 380
 381     /* True if we should print the source line with a caret indicating
 382        the location.
 383        Corresponds to -fdiagnostics-show-caret.  */
 384     bool enabled;
 385
 386     /* Maximum width of the source line printed.  */
 387     int max_width;
 388
 389     /* Character used at the caret when printing source locations.  */
 390     char caret_chars[rich_location::STATICALLY_ALLOCATED_RANGES];
 391
 392     /* When printing source code, should the characters at carets and ranges
 393        be colorized? (assuming colorization is on at all).
 394        This should be true for frontends that generate range information
 395        (so that the ranges of code are colorized),
 396        and false for frontends that merely specify points within the
 397        source code (to avoid e.g. colorizing just the first character in
 398        a token, which would look strange).  */
 399     bool colorize_source_p;
 400
 401     /* When printing source code, should labelled ranges be printed?
 402        Corresponds to -fdiagnostics-show-labels.  */
 403     bool show_labels_p;
 404
 405     /* When printing source code, should there be a left-hand margin
 406        showing line numbers?
 407        Corresponds to -fdiagnostics-show-line-numbers.  */
 408     bool show_line_numbers_p;
 409
 410     /* If printing source code, what should the minimum width of the margin
 411        be?  Line numbers will be right-aligned, and padded to this width.
 412        Corresponds to -fdiagnostics-minimum-margin-width=VALUE.  */
 413     int min_margin_width;
 414
 415     /* Usable by plugins; if true, print a debugging ruler above the
 416        source output.  */
 417     bool show_ruler_p;
 418
 419   } m_source_printing;
 420
 421   /* True if -freport-bug option is used.  */
 422   bool report_bug;
 423
 424   /* Used to specify additional diagnostic output to be emitted after the
 425      rest of the diagnostic.  This is for implementing
 426      -fdiagnostics-parseable-fixits and GCC_EXTRA_DIAGNOSTIC_OUTPUT.  */
 427   enum diagnostics_extra_output_kind extra_output_kind;
 428
 429   /* What units to use when outputting the column number.  */
 430   enum diagnostics_column_unit column_unit;
 431
 432   /* The origin for the column number (1-based or 0-based typically).  */
 433   int column_origin;
 434
 435   /* The size of the tabstop for tab expansion.  */
 436   int tabstop;
 437
 438   /* How should non-ASCII/non-printable bytes be escaped when
 439      a diagnostic suggests escaping the source code on output.  */
 440   enum diagnostics_escape_format escape_format;
 441
 442   /* If non-NULL, an edit_context to which fix-it hints should be
 443      applied, for generating patches.  */
 444   edit_context *edit_context_ptr;
 445
 446   /* How many diagnostic_group instances are currently alive.  */
 447   int diagnostic_group_nesting_depth;
 448
 449   /* How many diagnostics have been emitted since the bottommost
 450      diagnostic_group was pushed.  */
 451   int diagnostic_group_emission_count;
 452
 453   /* How to output diagnostics (text vs a structured format such as JSON).
 454      Must be non-NULL; owned by context.  */
 455   diagnostic_output_format *m_output_format;
 456
 457   /* Callback to set the locations of call sites along the inlining
 458      stack corresponding to a diagnostic location.  Needed to traverse
 459      the BLOCK_SUPERCONTEXT() chain hanging off the LOCATION_BLOCK()
 460      of a diagnostic's location.  */
 461   void (*set_locations_cb)(diagnostic_context *, diagnostic_info *);
 462
 463   /* Optional callback for attempting to handle ICEs gracefully.  */
 464   void (*ice_handler_cb) (diagnostic_context *context);
 465
 466   /* Include files that diagnostic_report_current_module has already listed the
 467      include path for.  */
 468   hash_set<location_t, false, location_hash> *includes_seen;
 469
 470   /* A bundle of hooks for providing data to the context about its client
 471      e.g. version information, plugins, etc.
 472      Used by SARIF output to give metadata about the client that's
 473      producing diagnostics.  */
 474   diagnostic_client_data_hooks *m_client_data_hooks;
 475
 476   /* Support for diagrams.  */
 477   struct
 478   {
 479     /* Theme to use when generating diagrams.
 480        Can be NULL (if text art is disabled).  */
 481     text_art::theme *m_theme;
 482
 483   } m_diagrams;
 484 };
 485
 486 inline void
 487 diagnostic_inhibit_notes (diagnostic_context * context)
 488 {
 489   context->inhibit_notes_p = true;
 490 }
 491
 492
 493 /* Client supplied function to announce a diagnostic
 494    (for text-based diagnostic output).  */
 495 #define diagnostic_starter(DC) (DC)->m_text_callbacks.begin_diagnostic
 496
 497 /* Client supplied function called after a diagnostic message is
 498    displayed (for text-based diagnostic output).  */
 499 #define diagnostic_finalizer(DC) (DC)->m_text_callbacks.end_diagnostic
 500
 501 /* Extension hooks for client.  */
 502 #define diagnostic_context_auxiliary_data(DC) (DC)->x_data
 503 #define diagnostic_info_auxiliary_data(DI) (DI)->x_data
 504
 505 /* Same as pp_format_decoder.  Works on 'diagnostic_context *'.  */
 506 #define diagnostic_format_decoder(DC) ((DC)->printer->format_decoder)
 507
 508 /* Same as output_prefixing_rule.  Works on 'diagnostic_context *'.  */
 509 #define diagnostic_prefixing_rule(DC) ((DC)->printer->wrapping.rule)
 510
 511 /* Raise SIGABRT on any diagnostic of severity DK_ERROR or higher.  */
 512 #define diagnostic_abort_on_error(DC) \
 513   (DC)->abort_on_error = true
 514
 515 /* This diagnostic_context is used by front-ends that directly output
 516    diagnostic messages without going through `error', `warning',
 517    and similar functions.  */
 518 extern diagnostic_context *global_dc;
 519
 520 /* Returns whether the diagnostic framework has been intialized already and is
 521    ready for use.  */
 522 #define diagnostic_ready_p() (global_dc->printer != NULL)
 523
 524 /* The total count of a KIND of diagnostics emitted so far.  */
 525 #define diagnostic_kind_count(DC, DK) (DC)->diagnostic_count[(int) (DK)]
 526
 527 /* The number of errors that have been issued so far.  Ideally, these
 528    would take a diagnostic_context as an argument.  */
 529 #define errorcount diagnostic_kind_count (global_dc, DK_ERROR)
 530 /* Similarly, but for warnings.  */
 531 #define warningcount diagnostic_kind_count (global_dc, DK_WARNING)
 532 /* Similarly, but for warnings promoted to errors.  */
 533 #define werrorcount diagnostic_kind_count (global_dc, DK_WERROR)
 534 /* Similarly, but for sorrys.  */
 535 #define sorrycount diagnostic_kind_count (global_dc, DK_SORRY)
 536
 537 /* Returns nonzero if warnings should be emitted.  */
 538 #define diagnostic_report_warnings_p(DC, LOC)                           \
 539   (!(DC)->dc_inhibit_warnings                                           \
 540    && !(in_system_header_at (LOC) && !(DC)->dc_warn_system_headers))
 541
 542 /* Override the option index to be used for reporting a
 543    diagnostic.  */
 544
 545 inline void
 546 diagnostic_override_option_index (diagnostic_info *info, int optidx)
 547 {
 548   info->option_index = optidx;
 549 }
 550
 551 /* Diagnostic related functions.  */
 552 extern void diagnostic_initialize (diagnostic_context *, int);
 553 extern void diagnostic_color_init (diagnostic_context *, int value = -1);
 554 extern void diagnostic_urls_init (diagnostic_context *, int value = -1);
 555 extern void diagnostic_finish (diagnostic_context *);
 556 extern void diagnostic_report_current_module (diagnostic_context *, location_t);
 557 extern void diagnostic_show_locus (diagnostic_context *,
 558                                    rich_location *richloc,
 559                                    diagnostic_t diagnostic_kind,
 560                                    pretty_printer *pp = nullptr);
 561 extern void diagnostic_show_any_path (diagnostic_context *, diagnostic_info *);
 562
 563 /* Because we read source files a second time after the frontend did it the
 564    first time, we need to know how the frontend handled things like character
 565    set conversion and UTF-8 BOM stripping, in order to make everything
 566    consistent.  This function needs to be called by each frontend that requires
 567    non-default behavior, to inform the diagnostics infrastructure how input is
 568    to be processed.  The default behavior is to do no conversion and not to
 569    strip a UTF-8 BOM.
 570
 571    The callback should return the input charset to be used to convert the given
 572    file's contents to UTF-8, or it should return NULL if no conversion is needed
 573    for this file.  SHOULD_SKIP_BOM only applies in case no conversion was
 574    performed, and if true, it will cause a UTF-8 BOM to be skipped at the
 575    beginning of the file.  (In case a conversion was performed, the BOM is
 576    rather skipped as part of the conversion process.)  */
 577
 578 void diagnostic_initialize_input_context (diagnostic_context *context,
 579                                           diagnostic_input_charset_callback ccb,
 580                                           bool should_skip_bom);
 581
 582 /* Force diagnostics controlled by OPTIDX to be kind KIND.  */
 583 extern diagnostic_t diagnostic_classify_diagnostic (diagnostic_context *,
 584                                                     int /* optidx */,
 585                                                     diagnostic_t /* kind */,
 586                                                     location_t);
 587 extern void diagnostic_push_diagnostics (diagnostic_context *, location_t);
 588 extern void diagnostic_pop_diagnostics (diagnostic_context *, location_t);
 589 extern bool diagnostic_report_diagnostic (diagnostic_context *,
 590                                           diagnostic_info *);
 591 #ifdef ATTRIBUTE_GCC_DIAG
 592 extern void diagnostic_set_info (diagnostic_info *, const char *, va_list *,
 593                                  rich_location *, diagnostic_t) ATTRIBUTE_GCC_DIAG(2,0);
 594 extern void diagnostic_set_info_translated (diagnostic_info *, const char *,
 595                                             va_list *, rich_location *,
 596                                             diagnostic_t)
 597      ATTRIBUTE_GCC_DIAG(2,0);
 598 extern void diagnostic_append_note (diagnostic_context *, location_t,
 599                                     const char *, ...) ATTRIBUTE_GCC_DIAG(3,4);
 600 #endif
 601 extern char *diagnostic_build_prefix (diagnostic_context *, const diagnostic_info *);
 602 void default_diagnostic_starter (diagnostic_context *, diagnostic_info *);
 603 void default_diagnostic_start_span_fn (diagnostic_context *,
 604                                        expanded_location);
 605 void default_diagnostic_finalizer (diagnostic_context *, diagnostic_info *,
 606                                    diagnostic_t);
 607 void diagnostic_set_caret_max_width (diagnostic_context *context, int value);
 608 void diagnostic_action_after_output (diagnostic_context *, diagnostic_t);
 609 void diagnostic_check_max_errors (diagnostic_context *, bool flush = false);
 610
 611 void diagnostic_file_cache_fini (void);
 612
 613 int get_terminal_width (void);
 614
 615 /* Return the location associated to this diagnostic. Parameter WHICH
 616    specifies which location. By default, expand the first one.  */
 617
 618 inline location_t
 619 diagnostic_location (const diagnostic_info * diagnostic, int which = 0)
 620 {
 621   return diagnostic->message.get_location (which);
 622 }
 623
 624 /* Return the number of locations to be printed in DIAGNOSTIC.  */
 625
 626 inline unsigned int
 627 diagnostic_num_locations (const diagnostic_info * diagnostic)
 628 {
 629   return diagnostic->message.m_richloc->get_num_locations ();
 630 }
 631
 632 /* Expand the location of this diagnostic. Use this function for
 633    consistency.  Parameter WHICH specifies which location. By default,
 634    expand the first one.  */
 635
 636 inline expanded_location
 637 diagnostic_expand_location (const diagnostic_info * diagnostic, int which = 0)
 638 {
 639   return diagnostic->richloc->get_expanded_location (which);
 640 }
 641
 642 /* This is somehow the right-side margin of a caret line, that is, we
 643    print at least these many characters after the position pointed at
 644    by the caret.  */
 645 const int CARET_LINE_MARGIN = 10;
 646
 647 /* Return true if the two locations can be represented within the same
 648    caret line.  This is used to build a prefix and also to determine
 649    whether to print one or two caret lines.  */
 650
 651 inline bool
 652 diagnostic_same_line (const diagnostic_context *context,
 653                        expanded_location s1, expanded_location s2)
 654 {
 655   return (s2.column && s1.line == s2.line
 656           && (context->m_source_printing.max_width - CARET_LINE_MARGIN
 657               > abs (s1.column - s2.column)));
 658 }
 659
 660 extern const char *diagnostic_get_color_for_kind (diagnostic_t kind);
 661 extern int diagnostic_converted_column (diagnostic_context *context,
 662                                         expanded_location s);
 663
 664 /* Pure text formatting support functions.  */
 665 extern char *file_name_as_prefix (diagnostic_context *, const char *);
 666
 667 extern char *build_message_string (const char *, ...) ATTRIBUTE_PRINTF_1;
 668
 669 extern void diagnostic_output_format_init (diagnostic_context *,
 670                                            const char *base_file_name,
 671                                            enum diagnostics_output_format);
 672 extern void diagnostic_output_format_init_json_stderr (diagnostic_context *context);
 673 extern void diagnostic_output_format_init_json_file (diagnostic_context *context,
 674                                                      const char *base_file_name);
 675 extern void diagnostic_output_format_init_sarif_stderr (diagnostic_context *context);
 676 extern void diagnostic_output_format_init_sarif_file (diagnostic_context *context,
 677                                                       const char *base_file_name);
 678 extern void diagnostic_output_format_init_sarif_stream (diagnostic_context *context,
 679                                                         FILE *stream);
 680
 681 /* Compute the number of digits in the decimal representation of an integer.  */
 682 extern int num_digits (int);
 683
 684 extern json::value *json_from_expanded_location (diagnostic_context *context,
 685                                                  location_t loc);
 686
 687 extern bool warning_enabled_at (location_t, int);
 688
 689 extern char *get_cwe_url (int cwe);
 690
 691 extern void diagnostic_emit_diagram (diagnostic_context *context,
 692                                      const diagnostic_diagram &diagram);
 693
 694 #endif /* ! GCC_DIAGNOSTIC_H */