# Objects in libcommon.a, potentially used by all host binaries and with
# no target dependencies.
OBJS-libcommon = diagnostic-spec.o diagnostic.o diagnostic-color.o \
- diagnostic-format-html.o \
- diagnostic-format-sarif.o \
- diagnostic-format-text.o \
diagnostic-global-context.o \
diagnostic-macro-unwinding.o \
diagnostic-show-locus.o \
diagnostics/digraphs.o \
diagnostics/edit-context.o \
diagnostics/output-spec.o \
+ diagnostics/html-sink.o \
+ diagnostics/sarif-sink.o \
+ diagnostics/text-sink.o \
diagnostics/paths.o \
diagnostics/paths-output.o \
diagnostics/state-graphs.o \
#include "analyzer/common.h"
#include "diagnostics/state-graphs.h"
-#include "diagnostic-format-sarif.h"
+#include "diagnostics/sarif-sink.h"
#include "analyzer/region-model.h"
#include "analyzer/program-state.h"
#include "intl.h"
#include "diagnostics/diagram.h"
-#include "diagnostic-format-sarif.h"
+#include "diagnostics/sarif-sink.h"
#include "analyzer/analyzer-logging.h"
#include "analyzer/region-model.h"
*this));
}
- void maybe_add_sarif_properties (sarif_object &result_obj)
+ void
+ maybe_add_sarif_properties (diagnostics::sarif_object &result_obj)
const override
{
- sarif_property_bag &props = result_obj.get_or_create_properties ();
+ auto &props = result_obj.get_or_create_properties ();
#define PROPERTY_PREFIX "gcc/analyzer/out_of_bounds/"
props.set_string (PROPERTY_PREFIX "dir",
get_dir () == access_direction::read ? "read" : "write");
&& m_out_of_bounds_bits == other.m_out_of_bounds_bits);
}
- void maybe_add_sarif_properties (sarif_object &result_obj)
+ void maybe_add_sarif_properties (diagnostics::sarif_object &result_obj)
const override
{
out_of_bounds::maybe_add_sarif_properties (result_obj);
- sarif_property_bag &props = result_obj.get_or_create_properties ();
+ auto &props = result_obj.get_or_create_properties ();
#define PROPERTY_PREFIX "gcc/analyzer/concrete_out_of_bounds/"
props.set (PROPERTY_PREFIX "out_of_bounds_bits",
m_out_of_bounds_bits.to_json ());
*this));
}
- void maybe_add_sarif_properties (sarif_object &result_obj)
+ void maybe_add_sarif_properties (diagnostics::sarif_object &result_obj)
const final override
{
concrete_out_of_bounds::maybe_add_sarif_properties (result_obj);
- sarif_property_bag &props = result_obj.get_or_create_properties ();
+ auto &props = result_obj.get_or_create_properties ();
#define PROPERTY_PREFIX "gcc/analyzer/concrete_past_the_end/"
props.set (PROPERTY_PREFIX "bit_bound",
tree_to_json (m_bit_bound));
&& pending_diagnostic::same_tree_p (m_capacity, other.m_capacity));
}
- void maybe_add_sarif_properties (sarif_object &result_obj)
+ void
+ maybe_add_sarif_properties (diagnostics::sarif_object &result_obj)
const final override
{
out_of_bounds::maybe_add_sarif_properties (result_obj);
- sarif_property_bag &props = result_obj.get_or_create_properties ();
+ auto &props = result_obj.get_or_create_properties ();
#define PROPERTY_PREFIX "gcc/analyzer/symbolic_past_the_end/"
props.set (PROPERTY_PREFIX "offset", tree_to_json (m_offset));
props.set (PROPERTY_PREFIX "num_bytes", tree_to_json (m_num_bytes));
#include "gimple-pretty-print.h"
#include "stringpool.h"
#include "attribs.h"
-#include "diagnostic-format-sarif.h"
+#include "diagnostics/sarif-sink.h"
#include "analyzer/analyzer-logging.h"
#include "analyzer/region-model.h"
return true;
}
- void maybe_add_sarif_properties (sarif_object &result_obj)
+ void maybe_add_sarif_properties (diagnostics::sarif_object &result_obj)
const final override
{
- sarif_property_bag &props = result_obj.get_or_create_properties ();
+ auto &props = result_obj.get_or_create_properties ();
#define PROPERTY_PREFIX "gcc/analyzer/overlapping_buffers/"
props.set (PROPERTY_PREFIX "bytes_range_a",
m_byte_range_a.to_json ());
#include "gimple-iterator.h"
#include "inlining-iterator.h"
#include "tree-logical-location.h"
-#include "diagnostic-format-sarif.h"
+#include "diagnostics/sarif-sink.h"
#include "diagnostics/state-graphs.h"
#include "analyzer/analyzer-logging.h"
void
checker_event::
-maybe_add_sarif_properties (sarif_builder &builder,
- sarif_object &thread_flow_loc_obj) const
+maybe_add_sarif_properties (diagnostics::sarif_builder &builder,
+ diagnostics::sarif_object &thread_flow_loc_obj) const
{
- sarif_property_bag &props = thread_flow_loc_obj.get_or_create_properties ();
+ auto &props = thread_flow_loc_obj.get_or_create_properties ();
#define PROPERTY_PREFIX "gcc/analyzer/checker_event/"
props.set (PROPERTY_PREFIX "emission_id",
diagnostic_event_id_to_json (m_emission_id));
for superedge_event. */
void
-superedge_event::maybe_add_sarif_properties (sarif_builder &builder,
- sarif_object &thread_flow_loc_obj)
+superedge_event::
+maybe_add_sarif_properties (diagnostics::sarif_builder &builder,
+ diagnostics::sarif_object &thread_flow_loc_obj)
const
{
checker_event::maybe_add_sarif_properties (builder, thread_flow_loc_obj);
- sarif_property_bag &props = thread_flow_loc_obj.get_or_create_properties ();
+ auto &props = thread_flow_loc_obj.get_or_create_properties ();
#define PROPERTY_PREFIX "gcc/analyzer/superedge_event/"
if (m_sedge)
props.set (PROPERTY_PREFIX "superedge", m_sedge->to_json ());
}
void
- maybe_add_sarif_properties (sarif_builder &,
- sarif_object &thread_flow_loc_obj) const override;
+ maybe_add_sarif_properties (diagnostics::sarif_builder &,
+ diagnostics::sarif_object &thread_flow_loc_obj)
+ const override;
/* Additional functionality. */
enum event_kind get_kind () const { return m_kind; }
class superedge_event : public checker_event
{
public:
- void maybe_add_sarif_properties (sarif_builder &,
- sarif_object &thread_flow_loc_obj)
+ void
+ maybe_add_sarif_properties (diagnostics::sarif_builder &,
+ diagnostics::sarif_object &thread_flow_loc_obj)
const override;
/* Mark this edge event as being either an interprocedural call or
#include "cgraph.h"
#include "digraph.h"
#include "gcc-rich-location.h"
-#include "diagnostic-format-sarif.h"
+#include "diagnostics/sarif-sink.h"
#include "analyzer/analyzer-logging.h"
#include "analyzer/sm.h"
This extra data is intended for use when debugging the analyzer. */
void
-saved_diagnostic::maybe_add_sarif_properties (sarif_object &result_obj) const
+saved_diagnostic::
+maybe_add_sarif_properties (diagnostics::sarif_object &result_obj) const
{
- sarif_property_bag &props = result_obj.get_or_create_properties ();
+ auto &props = result_obj.get_or_create_properties ();
#define PROPERTY_PREFIX "gcc/analyzer/saved_diagnostic/"
if (m_sm)
props.set_string (PROPERTY_PREFIX "sm", m_sm->get_name ());
auto duplicates_arr = std::make_unique<json::array> ();
for (auto iter : m_duplicates)
{
- auto sd_obj = std::make_unique<sarif_object> ();
+ auto sd_obj = std::make_unique<diagnostics::sarif_object> ();
iter->maybe_add_sarif_properties (*sd_obj);
duplicates_arr->append (std::move (sd_obj));
}
}
void
- maybe_add_sarif_properties (sarif_object &result_obj) const override
+ maybe_add_sarif_properties (diagnostics::sarif_object &result_obj)
+ const override
{
m_sd.maybe_add_sarif_properties (result_obj);
}
void emit_any_notes () const;
- void maybe_add_sarif_properties (sarif_object &result_obj) const;
+ void
+ maybe_add_sarif_properties (diagnostics::sarif_object &result_obj) const;
//private:
const state_machine *m_sm;
#include "gimple-pretty-print.h"
#include "cgraph.h"
#include "digraph.h"
-#include "diagnostic-format-sarif.h"
+#include "diagnostics/sarif-sink.h"
#include "analyzer/analyzer-logging.h"
#include "analyzer/call-string.h"
}
}
- void maybe_add_sarif_properties (sarif_object &result_obj)
+ void
+ maybe_add_sarif_properties (diagnostics::sarif_object &result_obj)
const final override
{
- sarif_property_bag &props = result_obj.get_or_create_properties ();
+ auto &props = result_obj.get_or_create_properties ();
#define PROPERTY_PREFIX "gcc/analyzer/infinite_loop_diagnostic/"
props.set (PROPERTY_PREFIX "inf_loop", m_inf_loop->to_json ());
#undef PROPERTY_PREFIX
#include "gimple-pretty-print.h"
#include "cgraph.h"
#include "digraph.h"
+#include "diagnostics/sarif-sink.h"
#include "analyzer/analyzer-logging.h"
#include "analyzer/call-string.h"
#include "analyzer/exploded-graph.h"
#include "analyzer/checker-path.h"
#include "analyzer/feasible-graph.h"
-#include "diagnostic-format-sarif.h"
/* A subclass of pending_diagnostic for complaining about suspected
infinite recursion. */
return false;
}
- void maybe_add_sarif_properties (sarif_object &result_obj)
+ void
+ maybe_add_sarif_properties (diagnostics::sarif_object &result_obj)
const final override
{
- sarif_property_bag &props = result_obj.get_or_create_properties ();
+ auto &props = result_obj.get_or_create_properties ();
#define PROPERTY_PREFIX "gcc/analyzer/infinite_recursion_diagnostic/"
props.set_integer (PROPERTY_PREFIX "prev_entry_enode",
m_prev_entry_enode->m_index);
the opportunity to add diagnostic-specific properties to the SARIF
"result" object for the diagnostic.
This is intended for use when debugging a diagnostic. */
- virtual void maybe_add_sarif_properties (sarif_object &/*result_obj*/) const
+ virtual void
+ maybe_add_sarif_properties (diagnostics::sarif_object &/*result_obj*/) const
{
/* Default no-op implementation. */
}
#include "is-a.h"
#include "gcc-rich-location.h"
#include "gcc-urlifier.h"
-#include "diagnostic-format-sarif.h"
+#include "diagnostics/sarif-sink.h"
#include "tree-pretty-print.h"
#include "fold-const.h"
#include "selftest-tree.h"
}
void
- maybe_add_sarif_properties (sarif_object &result_obj) const final override
+ maybe_add_sarif_properties (diagnostics::sarif_object &result_obj)
+ const final override
{
- sarif_property_bag &props = result_obj.get_or_create_properties ();
+ auto &props = result_obj.get_or_create_properties ();
#define PROPERTY_PREFIX "gcc/analyzer/poisoned_value_diagnostic/"
props.set (PROPERTY_PREFIX "expr", tree_to_json (m_expr));
props.set_string (PROPERTY_PREFIX "kind", poison_kind_to_str (m_pkind));
interest->add_region_creation (m_rhs);
}
- void maybe_add_sarif_properties (sarif_object &result_obj)
+ void
+ maybe_add_sarif_properties (diagnostics::sarif_object &result_obj)
const final override
{
- sarif_property_bag &props = result_obj.get_or_create_properties ();
+ auto &props = result_obj.get_or_create_properties ();
#define PROPERTY_PREFIX "gcc/analyzer/dubious_allocation_size/"
props.set (PROPERTY_PREFIX "lhs", m_lhs->to_json ());
props.set (PROPERTY_PREFIX "rhs", m_rhs->to_json ());
}
void
- maybe_add_sarif_properties (sarif_object &result_obj) const final override
+ maybe_add_sarif_properties (diagnostics::sarif_object &result_obj)
+ const final override
{
- sarif_property_bag &props = result_obj.get_or_create_properties ();
+ auto &props = result_obj.get_or_create_properties ();
#define PROPERTY_PREFIX "gcc/-Wanalyzer-exposure-through-uninit-copy/"
props.set (PROPERTY_PREFIX "src_region", m_src_region->to_json ());
props.set (PROPERTY_PREFIX "dest_region", m_dest_region->to_json ());
#include "stringpool.h"
#include "attribs.h"
#include "fold-const.h"
-#include "diagnostic-format-sarif.h"
+#include "diagnostics/sarif-sink.h"
#include "gcc-urlifier.h"
#include "analyzer/analyzer-logging.h"
return event::meaning ();
}
- void maybe_add_sarif_properties (sarif_object &result_obj)
+ void
+ maybe_add_sarif_properties (diagnostics::sarif_object &result_obj)
const override
{
- sarif_property_bag &props = result_obj.get_or_create_properties ();
+ auto &props = result_obj.get_or_create_properties ();
#define PROPERTY_PREFIX "gcc/analyzer/taint_diagnostic/"
props.set (PROPERTY_PREFIX "arg", tree_to_json (m_arg));
props.set_string (PROPERTY_PREFIX "has_bounds",
}
}
- void maybe_add_sarif_properties (sarif_object &result_obj)
+ void
+ maybe_add_sarif_properties (diagnostics::sarif_object &result_obj)
const final override
{
taint_diagnostic::maybe_add_sarif_properties (result_obj);
- sarif_property_bag &props = result_obj.get_or_create_properties ();
+ auto &props = result_obj.get_or_create_properties ();
#define PROPERTY_PREFIX "gcc/analyzer/tainted_offset/"
props.set (PROPERTY_PREFIX "offset", m_offset->to_json ());
#undef PROPERTY_PREFIX
}
}
- void maybe_add_sarif_properties (sarif_object &result_obj)
+ void
+ maybe_add_sarif_properties (diagnostics::sarif_object &result_obj)
const final override
{
taint_diagnostic::maybe_add_sarif_properties (result_obj);
- sarif_property_bag &props = result_obj.get_or_create_properties ();
+ auto &props = result_obj.get_or_create_properties ();
#define PROPERTY_PREFIX "gcc/analyzer/tainted_allocation_size/"
props.set (PROPERTY_PREFIX "size_in_bytes", m_size_in_bytes->to_json ());
#undef PROPERTY_PREFIX
#include "dumpfile.h"
#include "file-prefix-map.h" /* add_*_prefix_map() */
#include "context.h"
-#include "diagnostic-format-text.h"
+#include "diagnostics/text-sink.h"
#ifndef DOLLARS_IN_IDENTIFIERS
# define DOLLARS_IN_IDENTIFIERS true
/* Diagnostic finalizer for C/C++/Objective-C/Objective-C++. */
static void
-c_diagnostic_text_finalizer (diagnostic_text_output_format &text_output,
+c_diagnostic_text_finalizer (diagnostics::text_sink &text_output,
const diagnostic_info *diagnostic,
diagnostic_t)
{
struct cl_option_handlers;
class rich_location;
class diagnostic_context;
-class diagnostic_text_output_format;
+namespace diagnostics { class text_sink; }
class pretty_printer;
class diagnostic_event_id_t;
typedef const char * (*diagnostic_input_charset_callback)(const char *);
extern void cxx_print_decl (FILE *, tree, int);
extern void cxx_print_type (FILE *, tree, int);
extern void cxx_print_identifier (FILE *, tree, int);
-extern void cxx_print_error_function (diagnostic_text_output_format &,
+extern void cxx_print_error_function (diagnostics::text_sink &,
const char *,
const diagnostic_info *);
#include "cp-name-hint.h"
#include "attribs.h"
#include "pretty-print-format-impl.h"
-#include "diagnostic-format-text.h"
+#include "diagnostics/text-sink.h"
#define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
#define pp_separate_with_semicolon(PP) pp_cxx_separate_with (PP, ';')
static void dump_template_parms (cxx_pretty_printer *, tree, int, int);
static int get_non_default_template_args_count (tree, int);
static const char *function_category (tree);
-static void maybe_print_constexpr_context (diagnostic_text_output_format &);
-static void maybe_print_instantiation_context (diagnostic_text_output_format &);
-static void print_instantiation_full_context (diagnostic_text_output_format &);
-static void print_instantiation_partial_context (diagnostic_text_output_format &,
+static void maybe_print_constexpr_context (diagnostics::text_sink &);
+static void maybe_print_instantiation_context (diagnostics::text_sink &);
+static void print_instantiation_full_context (diagnostics::text_sink &);
+static void print_instantiation_partial_context (diagnostics::text_sink &,
struct tinst_level *,
location_t);
-static void maybe_print_constraint_context (diagnostic_text_output_format &);
-static void cp_diagnostic_text_starter (diagnostic_text_output_format &,
+static void maybe_print_constraint_context (diagnostics::text_sink &);
+static void cp_diagnostic_text_starter (diagnostics::text_sink &,
const diagnostic_info *);
-static void cp_print_error_function (diagnostic_text_output_format &,
+static void cp_print_error_function (diagnostics::text_sink &,
const diagnostic_info *);
static bool cp_printer (pretty_printer *, text_info *, const char *,
/* Langhook for print_error_function. */
void
-cxx_print_error_function (diagnostic_text_output_format &text_output,
+cxx_print_error_function (diagnostics::text_sink &text_output,
const char *file,
const diagnostic_info *diagnostic)
{
}
static void
-cp_diagnostic_text_starter (diagnostic_text_output_format &text_output,
+cp_diagnostic_text_starter (diagnostics::text_sink &text_output,
const diagnostic_info *diagnostic)
{
pp_set_prefix (text_output.get_printer (),
/* Print current function onto BUFFER, in the process of reporting
a diagnostic message. Called from cp_diagnostic_starter. */
static void
-cp_print_error_function (diagnostic_text_output_format &text_output,
+cp_print_error_function (diagnostics::text_sink &text_output,
const diagnostic_info *diagnostic)
{
/* If we are in an instantiation context, current_function_decl is likely
/* Report the full context of a current template instantiation,
onto BUFFER. */
static void
-print_instantiation_full_context (diagnostic_text_output_format &text_output)
+print_instantiation_full_context (diagnostics::text_sink &text_output)
{
struct tinst_level *p = current_instantiation ();
location_t location = input_location;
}
static void
-print_location (diagnostic_text_output_format &text_output,
+print_location (diagnostics::text_sink &text_output,
location_t loc)
{
expanded_location xloc = expand_location (loc);
}
/* A RAII class for use when emitting a line of contextual information
- via pp_verbatim to a diagnostic_text_output_format to add before/after
+ via pp_verbatim to a diagnostics::text_sink to add before/after
behaviors to the pp_verbatim calls.
If the text output has show_nesting_p (), then the ctor prints
class auto_context_line
{
public:
- auto_context_line (diagnostic_text_output_format &text_output,
+ auto_context_line (diagnostics::text_sink &text_output,
location_t loc,
bool show_locus = false)
: m_text_output (text_output),
}
}
private:
- diagnostic_text_output_format &m_text_output;
+ diagnostics::text_sink &m_text_output;
location_t m_loc;
bool m_show_locus;
};
prints a single line of instantiation context. */
static void
-print_instantiation_partial_context_line (diagnostic_text_output_format &text_output,
+print_instantiation_partial_context_line (diagnostics::text_sink &text_output,
struct tinst_level *t,
location_t loc, bool recursive_p)
{
/* Same as print_instantiation_full_context but less verbose. */
static void
-print_instantiation_partial_context (diagnostic_text_output_format &text_output,
+print_instantiation_partial_context (diagnostics::text_sink &text_output,
struct tinst_level *t0, location_t loc)
{
struct tinst_level *t;
/* Called from cp_thing to print the template context for an error. */
static void
-maybe_print_instantiation_context (diagnostic_text_output_format &text_output)
+maybe_print_instantiation_context (diagnostics::text_sink &text_output)
{
if (!problematic_instantiation_changed () || current_instantiation () == 0)
return;
/* Report what constexpr call(s) we're trying to expand, if any. */
void
-maybe_print_constexpr_context (diagnostic_text_output_format &text_output)
+maybe_print_constexpr_context (diagnostics::text_sink &text_output)
{
vec<tree> call_stack = cx_error_context ();
unsigned ix;
\f
static void
-print_constrained_decl_info (diagnostic_text_output_format &text_output,
+print_constrained_decl_info (diagnostics::text_sink &text_output,
tree decl)
{
auto_context_line sentinel (text_output, DECL_SOURCE_LOCATION (decl));
}
static void
-print_concept_check_info (diagnostic_text_output_format &text_output,
+print_concept_check_info (diagnostics::text_sink &text_output,
tree expr, tree map, tree args)
{
gcc_assert (concept_check_p (expr));
context, if any. */
static tree
-print_constraint_context_head (diagnostic_text_output_format &text_output,
+print_constraint_context_head (diagnostics::text_sink &text_output,
tree cxt, tree args)
{
tree src = TREE_VALUE (cxt);
}
static void
-print_requires_expression_info (diagnostic_text_output_format &text_output,
+print_requires_expression_info (diagnostics::text_sink &text_output,
tree constr, tree args)
{
}
void
-maybe_print_single_constraint_context (diagnostic_text_output_format &text_output,
+maybe_print_single_constraint_context (diagnostics::text_sink &text_output,
tree failed)
{
if (!failed)
}
void
-maybe_print_constraint_context (diagnostic_text_output_format &text_output)
+maybe_print_constraint_context (diagnostics::text_sink &text_output)
{
if (!current_failed_constraint)
return;
#include "coretypes.h"
#include "intl.h"
#include "diagnostic.h"
-#include "diagnostic-format.h"
+#include "diagnostics/sink.h"
/* A diagnostic_context surrogate for stderr. */
static diagnostic_context global_diagnostic_context;
#include "tree.h"
#include "diagnostic.h"
#include "diagnostic-macro-unwinding.h"
-#include "diagnostic-format-text.h"
+#include "diagnostics/text-sink.h"
#include "intl.h"
/* This is a pair made of a location and the line map it originated
function. */
void
-maybe_unwind_expanded_macro_loc (diagnostic_text_output_format &text_output,
+maybe_unwind_expanded_macro_loc (diagnostics::text_sink &text_output,
location_t where)
{
const struct line_map *map;
that is similar to what is done for function call stacks, or
template instantiation contexts. */
void
-virt_loc_aware_diagnostic_finalizer (diagnostic_text_output_format &text_output,
+virt_loc_aware_diagnostic_finalizer (diagnostics::text_sink &text_output,
const diagnostic_info *diagnostic)
{
maybe_unwind_expanded_macro_loc (text_output, diagnostic_location (diagnostic));
#ifndef GCC_DIAGNOSTIC_MACRO_UNWINDING_H
#define GCC_DIAGNOSTIC_MACRO_UNWINDING_H
-void virt_loc_aware_diagnostic_finalizer (diagnostic_text_output_format &,
+void virt_loc_aware_diagnostic_finalizer (diagnostics::text_sink &,
const diagnostic_info *);
-extern void maybe_unwind_expanded_macro_loc (diagnostic_text_output_format &,
+extern void maybe_unwind_expanded_macro_loc (diagnostics::text_sink &,
location_t where);
#endif /* ! GCC_DIAGNOSTIC_MACRO_UNWINDING_H */
template<>
void
-default_diagnostic_start_span_fn<to_text> (const diagnostic_location_print_policy &loc_policy,
- to_text &sink,
- expanded_location exploc)
+diagnostics::default_start_span_fn<to_text> (const diagnostic_location_print_policy &loc_policy,
+ to_text &sink,
+ expanded_location exploc)
{
const diagnostic_column_policy &column_policy
= loc_policy.get_column_policy ();
template<>
void
-default_diagnostic_start_span_fn<to_html> (const diagnostic_location_print_policy &loc_policy,
- to_html &sink,
- expanded_location exploc)
+diagnostics::default_start_span_fn<to_html> (const diagnostic_location_print_policy &loc_policy,
+ to_html &sink,
+ expanded_location exploc)
{
const diagnostic_column_policy &column_policy
= loc_policy.get_column_policy ();
#include "diagnostics/paths.h"
#include "diagnostics/client-data-hooks.h"
#include "diagnostics/diagram.h"
-#include "diagnostic-format.h"
-#include "diagnostic-format-sarif.h"
-#include "diagnostic-format-text.h"
+#include "diagnostics/sink.h"
+#include "diagnostics/sarif-sink.h"
+#include "diagnostics/text-sink.h"
#include "diagnostics/edit-context.h"
#include "selftest.h"
#include "selftest-diagnostic.h"
#include "text-art/theme.h"
#include "pretty-print-urlifier.h"
#include "diagnostics/logical-locations.h"
-#include "diagnostic-buffer.h"
+#include "diagnostics/buffering.h"
#ifdef HAVE_TERMIOS_H
# include <termios.h>
m_max_errors = 0;
m_internal_error = nullptr;
m_adjust_diagnostic_info = nullptr;
- m_text_callbacks.m_begin_diagnostic = default_diagnostic_text_starter;
+ m_text_callbacks.m_begin_diagnostic = diagnostics::default_text_starter;
m_text_callbacks.m_text_start_span
- = default_diagnostic_start_span_fn<to_text>;
+ = diagnostics::default_start_span_fn<to_text>;
m_text_callbacks.m_html_start_span
- = default_diagnostic_start_span_fn<to_html>;
- m_text_callbacks.m_end_diagnostic = default_diagnostic_text_finalizer;
+ = diagnostics::default_start_span_fn<to_html>;
+ m_text_callbacks.m_end_diagnostic = diagnostics::default_text_finalizer;
m_option_mgr = nullptr;
m_urlifier_stack = new auto_vec<urlifier_stack_node> ();
m_last_location = UNKNOWN_LOCATION;
m_diagnostic_groups.m_diagnostic_nesting_level = 0;
m_diagnostic_groups.m_emission_count = 0;
m_diagnostic_groups.m_inhibiting_notes_from = 0;
- m_output_sinks.safe_push
- (new diagnostic_text_output_format (*this, nullptr, true));
+ m_sinks.safe_push (new diagnostics::text_sink (*this, nullptr, true));
m_set_locations_cb = nullptr;
m_client_data_hooks = nullptr;
m_diagrams.m_theme = nullptr;
}
pp_show_color (m_reference_printer)
= colorize_init ((diagnostic_color_rule_t) value);
- for (auto sink : m_output_sinks)
- if (sink->follows_reference_printer_p ())
- pp_show_color (sink->get_printer ())
+ for (auto sink_ : m_sinks)
+ if (sink_->follows_reference_printer_p ())
+ pp_show_color (sink_->get_printer ())
= pp_show_color (m_reference_printer);
}
m_reference_printer->set_url_format
(determine_url_format ((diagnostic_url_rule_t) value));
- for (auto sink : m_output_sinks)
- if (sink->follows_reference_printer_p ())
- sink->get_printer ()->set_url_format
+ for (auto sink_ : m_sinks)
+ if (sink_->follows_reference_printer_p ())
+ sink_->get_printer ()->set_url_format
(m_reference_printer->get_url_format ());
}
/* Clean ups. */
- while (!m_output_sinks.is_empty ())
- delete m_output_sinks.pop ();
+ while (!m_sinks.is_empty ())
+ delete m_sinks.pop ();
if (m_diagrams.m_theme)
{
fprintf (out, " reference printer:\n");
m_reference_printer->dump (out, 4);
fprintf (out, " output sinks:\n");
- if (m_output_sinks.length () > 0)
+ if (m_sinks.length () > 0)
{
- for (unsigned i = 0; i < m_output_sinks.length (); ++i)
+ for (unsigned i = 0; i < m_sinks.length (); ++i)
{
fprintf (out, " sink %i:\n", i);
- m_output_sinks[i]->dump (out, 4);
+ m_sinks[i]->dump (out, 4);
}
}
else
void
diagnostic_context::remove_all_output_sinks ()
{
- while (!m_output_sinks.is_empty ())
- delete m_output_sinks.pop ();
+ while (!m_sinks.is_empty ())
+ delete m_sinks.pop ();
}
void
-diagnostic_context::
-set_output_format (std::unique_ptr<diagnostic_output_format> output_format)
+diagnostic_context::set_sink (std::unique_ptr<diagnostics::sink> sink_)
{
remove_all_output_sinks ();
- m_output_sinks.safe_push (output_format.release ());
+ m_sinks.safe_push (sink_.release ());
}
-diagnostic_output_format &
-diagnostic_context::get_output_format (size_t idx) const
+diagnostics::sink &
+diagnostic_context::get_sink (size_t idx) const
{
- gcc_assert (idx < m_output_sinks.length ());
- gcc_assert (m_output_sinks[idx]);
- return *m_output_sinks[idx];
+ gcc_assert (idx < m_sinks.length ());
+ gcc_assert (m_sinks[idx]);
+ return *m_sinks[idx];
}
void
-diagnostic_context::add_sink (std::unique_ptr<diagnostic_output_format> sink)
+diagnostic_context::add_sink (std::unique_ptr<diagnostics::sink> sink_)
{
- m_output_sinks.safe_push (sink.release ());
+ m_sinks.safe_push (sink_.release ());
}
/* Return true if there are no machine-readable formats writing to stderr. */
bool
diagnostic_context::supports_fnotice_on_stderr_p () const
{
- for (auto sink : m_output_sinks)
- if (sink->machine_readable_stderr_p ())
+ for (auto sink_ : m_sinks)
+ if (sink_->machine_readable_stderr_p ())
return false;
return true;
}
void
diagnostic_context::set_main_input_filename (const char *filename)
{
- for (auto sink : m_output_sinks)
- sink->set_main_input_filename (filename);
+ for (auto sink_ : m_sinks)
+ sink_->set_main_input_filename (filename);
}
void
void
diagnostic_context::refresh_output_sinks ()
{
- for (auto sink : m_output_sinks)
- sink->update_printer ();
+ for (auto sink_ : m_sinks)
+ sink_->update_printer ();
}
/* Set FORMAT_DECODER on the reference printer and on the pretty_printer
diagnostic_context::set_format_decoder (printer_fn format_decoder)
{
pp_format_decoder (m_reference_printer) = format_decoder;
- for (auto sink : m_output_sinks)
- pp_format_decoder (sink->get_printer ()) = format_decoder;
+ for (auto sink_ : m_sinks)
+ pp_format_decoder (sink_->get_printer ()) = format_decoder;
}
void
diagnostic_context::set_show_highlight_colors (bool val)
{
pp_show_highlight_colors (m_reference_printer) = val;
- for (auto sink : m_output_sinks)
- if (sink->follows_reference_printer_p ())
- pp_show_highlight_colors (sink->get_printer ()) = val;
+ for (auto sink_ : m_sinks)
+ if (sink_->follows_reference_printer_p ())
+ pp_show_highlight_colors (sink_->get_printer ()) = val;
}
void
diagnostic_context::set_prefixing_rule (diagnostic_prefixing_rule_t rule)
{
pp_prefixing_rule (m_reference_printer) = rule;
- for (auto sink : m_output_sinks)
- if (sink->follows_reference_printer_p ())
- pp_prefixing_rule (sink->get_printer ()) = rule;
+ for (auto sink_ : m_sinks)
+ if (sink_->follows_reference_printer_p ())
+ pp_prefixing_rule (sink_->get_printer ()) = rule;
}
void
col = converted_column (s);
}
- const char *line_col = maybe_line_and_column (line, col);
+ const char *line_col = diagnostics::maybe_line_and_column (line, col);
return label_text::take (build_message_string ("%s%s%s:%s", locus_cs, file,
line_col, locus_ce));
}
}
diagnostic_location_print_policy::
-diagnostic_location_print_policy (const diagnostic_text_output_format &text_output)
+diagnostic_location_print_policy (const diagnostics::text_sink &text_output)
:
m_column_policy (text_output.get_context ()),
m_show_column (text_output.get_context ().m_show_column)
/* Is this the initial diagnostic within the stack of groups? */
if (m_diagnostic_groups.m_emission_count == 0)
- for (auto sink : m_output_sinks)
- sink->on_begin_group ();
+ for (auto sink_ : m_sinks)
+ sink_->on_begin_group ();
m_diagnostic_groups.m_emission_count++;
va_list *orig_args = diagnostic->message.m_args_ptr;
- for (auto sink : m_output_sinks)
+ for (auto sink_ : m_sinks)
{
/* Formatting the message is done per-output-format,
so that each output format gets its own set of pp_token_lists
va_list copied_args;
va_copy (copied_args, *orig_args);
diagnostic->message.m_args_ptr = &copied_args;
- pp_format (sink->get_printer (), &diagnostic->message);
+ pp_format (sink_->get_printer (), &diagnostic->message);
va_end (copied_args);
/* Call vfunc in the output format. This is responsible for
phase 3 of formatting, and for printing the result. */
- sink->on_report_diagnostic (*diagnostic, orig_diag_kind);
+ sink_->on_report_diagnostic (*diagnostic, orig_diag_kind);
}
switch (m_extra_output_kind)
m_lock--;
if (!m_diagnostic_buffer)
- for (auto sink : m_output_sinks)
- sink->after_diagnostic (*diagnostic);
+ for (auto sink_ : m_sinks)
+ sink_->after_diagnostic (*diagnostic);
return true;
}
diagnostic_context::report_verbatim (text_info &text)
{
va_list *orig_args = text.m_args_ptr;
- for (auto sink : m_output_sinks)
+ for (auto sink_ : m_sinks)
{
va_list copied_args;
va_copy (copied_args, *orig_args);
text.m_args_ptr = &copied_args;
- sink->on_report_verbatim (text);
+ sink_->on_report_verbatim (text);
va_end (copied_args);
}
}
diagnostic_context::
report_global_digraph (const diagnostics::digraphs::lazy_digraph &ldg)
{
- for (auto sink : m_output_sinks)
- sink->report_global_digraph (ldg);
+ for (auto sink_ : m_sinks)
+ sink_->report_global_digraph (ldg);
}
/* Get the number of digits in the decimal representation of VALUE. */
if (m_diagrams.m_theme == nullptr)
return;
- for (auto sink : m_output_sinks)
- sink->on_diagram (diag);
+ for (auto sink_ : m_sinks)
+ sink_->on_diagram (diag);
}
/* Inform the user that an error occurred while trying to report some
If any diagnostics were emitted, give the context a chance
to do something. */
if (m_diagnostic_groups.m_emission_count > 0)
- for (auto sink : m_output_sinks)
- sink->on_end_group ();
+ for (auto sink_ : m_sinks)
+ sink_->on_end_group ();
m_diagnostic_groups.m_emission_count = 0;
}
/* We're popping one level, so might need to stop inhibiting notes. */
}
void
-diagnostic_output_format::dump (FILE *out, int indent) const
+diagnostics::sink::dump (FILE *out, int indent) const
{
fprintf (out, "%*sprinter:\n", indent, "");
m_printer->dump (out, indent + 2);
}
void
-diagnostic_output_format::on_report_verbatim (text_info &)
+diagnostics::sink::on_report_verbatim (text_info &)
{
/* No-op. */
}
file-based output formats. */
void
-diagnostic_output_format_init (diagnostic_context &context,
- const char *main_input_filename_,
- const char *base_file_name,
- enum diagnostics_output_format format,
- bool json_formatting)
+diagnostics::output_format_init (diagnostic_context &context,
+ const char *main_input_filename_,
+ const char *base_file_name,
+ enum diagnostics_output_format format,
+ bool json_formatting)
{
- diagnostic_output_format *new_sink = nullptr;
+ diagnostics::sink *new_sink = nullptr;
switch (format)
{
default:
break;
case DIAGNOSTICS_OUTPUT_FORMAT_SARIF_STDERR:
- new_sink = &diagnostic_output_format_init_sarif_stderr (context,
- line_table,
- json_formatting);
+ new_sink = &diagnostics::init_sarif_stderr (context,
+ line_table,
+ json_formatting);
break;
case DIAGNOSTICS_OUTPUT_FORMAT_SARIF_FILE:
- new_sink = &diagnostic_output_format_init_sarif_file (context,
- line_table,
- json_formatting,
- base_file_name);
+ new_sink = &diagnostics::init_sarif_file (context,
+ line_table,
+ json_formatting,
+ base_file_name);
break;
}
if (new_sink)
to this function. */
void
-diagnostic_context::set_diagnostic_buffer (diagnostic_buffer *buffer)
+diagnostic_context::set_diagnostic_buffer (diagnostics::buffer *buffer_)
{
/* We don't allow changing buffering within a diagnostic group
(to simplify handling of buffered diagnostics within the
at nesting level 0. */
gcc_assert (m_diagnostic_groups.m_diagnostic_nesting_level == 0);
- m_diagnostic_buffer = buffer;
+ m_diagnostic_buffer = buffer_;
- if (buffer)
+ if (buffer_)
{
- buffer->ensure_per_format_buffers ();
- gcc_assert (buffer->m_per_format_buffers);
- gcc_assert (buffer->m_per_format_buffers->length ()
- == m_output_sinks.length ());
- for (unsigned idx = 0; idx < m_output_sinks.length (); ++idx)
+ buffer_->ensure_per_sink_buffers ();
+ gcc_assert (buffer_->m_per_sink_buffers);
+ gcc_assert (buffer_->m_per_sink_buffers->length ()
+ == m_sinks.length ());
+ for (unsigned idx = 0; idx < m_sinks.length (); ++idx)
{
- auto sink = m_output_sinks[idx];
- auto per_format_buffer = (*buffer->m_per_format_buffers)[idx];
- sink->set_buffer (per_format_buffer);
+ auto sink_ = m_sinks[idx];
+ auto per_sink_buffer = (*buffer_->m_per_sink_buffers)[idx];
+ sink_->set_buffer (per_sink_buffer);
}
}
else
- for (auto sink : m_output_sinks)
- sink->set_buffer (nullptr);
+ for (auto sink_ : m_sinks)
+ sink_->set_buffer (nullptr);
}
/* Clear BUFFER without flushing it. */
void
-diagnostic_context::clear_diagnostic_buffer (diagnostic_buffer &buffer)
+diagnostic_context::clear_diagnostic_buffer (diagnostics::buffer &buffer_)
{
- if (buffer.m_per_format_buffers)
- for (auto per_format_buffer : *buffer.m_per_format_buffers)
- per_format_buffer->clear ();
+ if (buffer_.m_per_sink_buffers)
+ for (auto per_sink_buffer_ : *buffer_.m_per_sink_buffers)
+ per_sink_buffer_->clear ();
- buffer.m_diagnostic_counters.clear ();
+ buffer_.m_diagnostic_counters.clear ();
/* We need to reset last_location, otherwise we may skip caret lines
when we actually give a diagnostic. */
/* Flush the diagnostics in BUFFER to this context, clearing BUFFER. */
void
-diagnostic_context::flush_diagnostic_buffer (diagnostic_buffer &buffer)
+diagnostic_context::flush_diagnostic_buffer (diagnostics::buffer &buffer_)
{
bool had_errors
- = (buffer.m_diagnostic_counters.m_count_for_kind[DK_ERROR] > 0
- || buffer.m_diagnostic_counters.m_count_for_kind[DK_WERROR] > 0);
- if (buffer.m_per_format_buffers)
- for (auto per_format_buffer : *buffer.m_per_format_buffers)
- per_format_buffer->flush ();
- buffer.m_diagnostic_counters.move_to (m_diagnostic_counters);
+ = (buffer_.m_diagnostic_counters.m_count_for_kind[DK_ERROR] > 0
+ || buffer_.m_diagnostic_counters.m_count_for_kind[DK_WERROR] > 0);
+ if (buffer_.m_per_sink_buffers)
+ for (auto per_sink_buffer_ : *buffer_.m_per_sink_buffers)
+ per_sink_buffer_->flush ();
+ buffer_.m_diagnostic_counters.move_to (m_diagnostic_counters);
action_after_output (had_errors ? DK_ERROR : DK_WARNING);
check_max_errors (true);
memset (&m_count_for_kind, 0, sizeof m_count_for_kind);
}
-/* class diagnostic_buffer. */
+/* class diagnostics::buffer. */
-diagnostic_buffer::diagnostic_buffer (diagnostic_context &ctxt)
+diagnostics::buffer::buffer (diagnostic_context &ctxt)
: m_ctxt (ctxt),
- m_per_format_buffers (nullptr)
+ m_per_sink_buffers (nullptr)
{
}
-diagnostic_buffer::~diagnostic_buffer ()
+diagnostics::buffer::~buffer ()
{
- if (m_per_format_buffers)
+ if (m_per_sink_buffers)
{
- for (auto iter : *m_per_format_buffers)
+ for (auto iter : *m_per_sink_buffers)
delete iter;
- delete m_per_format_buffers;
+ delete m_per_sink_buffers;
}
}
void
-diagnostic_buffer::dump (FILE *out, int indent) const
+diagnostics::buffer::dump (FILE *out, int indent) const
{
m_diagnostic_counters.dump (out, indent + 2);
- fprintf (out, "%*sm_per_format_buffers:\n", indent, "");
- if (m_per_format_buffers)
- for (auto per_format_buffer : *m_per_format_buffers)
- per_format_buffer->dump (out, indent + 2);
+ fprintf (out, "%*sm_per_sink_buffers:\n", indent, "");
+ if (m_per_sink_buffers)
+ for (auto per_sink_buffer_ : *m_per_sink_buffers)
+ per_sink_buffer_->dump (out, indent + 2);
else
fprintf (out, "%*s(none)\n", indent + 2, "");
}
bool
-diagnostic_buffer::empty_p () const
+diagnostics::buffer::empty_p () const
{
- if (m_per_format_buffers)
- for (auto per_format_buffer : *m_per_format_buffers)
+ if (m_per_sink_buffers)
+ for (auto per_sink_buffer_ : *m_per_sink_buffers)
/* Query initial buffer. */
- return per_format_buffer->empty_p ();
+ return per_sink_buffer_->empty_p ();
return true;
}
void
-diagnostic_buffer::move_to (diagnostic_buffer &dest)
+diagnostics::buffer::move_to (diagnostics::buffer &dest)
{
/* Bail if there's nothing to move. */
- if (!m_per_format_buffers)
+ if (!m_per_sink_buffers)
return;
m_diagnostic_counters.move_to (dest.m_diagnostic_counters);
- if (!dest.m_per_format_buffers)
+ if (!dest.m_per_sink_buffers)
{
/* Optimization for the "move to empty" case:
simply move the vec to the dest. */
- dest.m_per_format_buffers = m_per_format_buffers;
- m_per_format_buffers = nullptr;
+ dest.m_per_sink_buffers = m_per_sink_buffers;
+ m_per_sink_buffers = nullptr;
return;
}
- dest.ensure_per_format_buffers ();
- gcc_assert (m_per_format_buffers);
- gcc_assert (m_per_format_buffers->length ()
- == m_ctxt.m_output_sinks.length ());
- gcc_assert (dest.m_per_format_buffers);
- gcc_assert (dest.m_per_format_buffers->length ()
- == m_ctxt.m_output_sinks.length ());
- for (unsigned idx = 0; idx < m_ctxt.m_output_sinks.length (); ++idx)
+ dest.ensure_per_sink_buffers ();
+ gcc_assert (m_per_sink_buffers);
+ gcc_assert (m_per_sink_buffers->length ()
+ == m_ctxt.m_sinks.length ());
+ gcc_assert (dest.m_per_sink_buffers);
+ gcc_assert (dest.m_per_sink_buffers->length ()
+ == m_ctxt.m_sinks.length ());
+ for (unsigned idx = 0; idx < m_ctxt.m_sinks.length (); ++idx)
{
- auto per_format_buffer_src = (*m_per_format_buffers)[idx];
- auto per_format_buffer_dest = (*dest.m_per_format_buffers)[idx];
- per_format_buffer_src->move_to (*per_format_buffer_dest);
+ auto per_sink_buffer_src = (*m_per_sink_buffers)[idx];
+ auto per_sink_buffer_dest = (*dest.m_per_sink_buffers)[idx];
+ per_sink_buffer_src->move_to (*per_sink_buffer_dest);
}
}
way to update all diagnostic_buffer instances for that context. */
void
-diagnostic_buffer::ensure_per_format_buffers ()
+diagnostics::buffer::ensure_per_sink_buffers ()
{
- if (!m_per_format_buffers)
+ if (!m_per_sink_buffers)
{
- m_per_format_buffers = new auto_vec<diagnostic_per_format_buffer *> ();
- for (unsigned idx = 0; idx < m_ctxt.m_output_sinks.length (); ++idx)
+ m_per_sink_buffers = new auto_vec<per_sink_buffer *> ();
+ for (unsigned idx = 0; idx < m_ctxt.m_sinks.length (); ++idx)
{
- auto sink = m_ctxt.m_output_sinks[idx];
- auto per_format_buffer = sink->make_per_format_buffer ();
- m_per_format_buffers->safe_push (per_format_buffer.release ());
+ auto sink_ = m_ctxt.m_sinks[idx];
+ auto per_sink_buffer = sink_->make_per_sink_buffer ();
+ m_per_sink_buffers->safe_push (per_sink_buffer.release ());
}
}
- gcc_assert (m_per_format_buffers);
- gcc_assert (m_per_format_buffers->length ()
- == m_ctxt.m_output_sinks.length ());
+ gcc_assert (m_per_sink_buffers);
+ gcc_assert (m_per_sink_buffers->length ()
+ == m_ctxt.m_sinks.length ());
}
/* Really call the system 'abort'. This has to go right at the end of
assert_location_text ("foo.c:42:", "foo.c", 42, 10, false);
assert_location_text ("foo.c:", "foo.c", 0, 10, false);
- maybe_line_and_column (INT_MAX, INT_MAX);
- maybe_line_and_column (INT_MIN, INT_MIN);
+ diagnostics::maybe_line_and_column (INT_MAX, INT_MAX);
+ diagnostics::maybe_line_and_column (INT_MIN, INT_MIN);
{
/* In order to test display columns vs byte columns, we need to create a
class manager;
} // namespace diagnostics::logical_locations
+ class buffer;
class client_data_hooks;
class diagram;
class edit_context;
+ class sink;
+ class text_sink;
} // namespace diagnostics
class diagnostic_location_print_policy;
class diagnostic_source_print_policy;
-typedef void (*diagnostic_text_starter_fn) (diagnostic_text_output_format &,
+typedef void (*diagnostic_text_starter_fn) (diagnostics::text_sink &,
const diagnostic_info *);
struct to_text;
Sink &sink,
expanded_location);
-typedef void (*diagnostic_text_finalizer_fn) (diagnostic_text_output_format &,
+typedef void (*diagnostic_text_finalizer_fn) (diagnostics::text_sink &,
const diagnostic_info *,
diagnostic_t);
};
class diagnostic_source_effect_info;
-class diagnostic_output_format;
- class diagnostic_text_output_format;
-class diagnostic_buffer;
/* A stack of sets of classifications: each entry in the stack is
a mapping from option index to diagnostic severity that can be changed
{
public:
diagnostic_location_print_policy (const diagnostic_context &dc);
- diagnostic_location_print_policy (const diagnostic_text_output_format &);
+ diagnostic_location_print_policy (const diagnostics::text_sink &);
bool show_column_p () const { return m_show_column; }
/* A collection of counters of diagnostics, per-kind
(e.g. "3 errors and 1 warning"), for use by both diagnostic_context
- and by diagnostic_buffer. */
+ and by diagnostics::buffer. */
struct diagnostic_counters
{
(e.g. text vs SARIF)
- providing a "dump" member function for a debug dump of the state of
the diagnostics subsytem
- - direct vs buffered diagnostics (see class diagnostic_buffer)
+ - direct vs buffered diagnostics (see class diagnostics::buffer)
- tracking the original argv of the program (for SARIF output)
- crash-handling
It delegates responsibility to various other classes:
- - the various output sinks (instances of diagnostic_output_format
+ - the various output sinks (instances of diagnostics::sink
subclasses)
- formatting of messages (class pretty_printer)
- an optional urlifier to inject URLs into formatted messages
diagnostic_text_finalizer (diagnostic_context *context);
friend class diagnostic_source_print_policy;
- friend class diagnostic_text_output_format;
- friend class diagnostic_buffer;
+ friend class diagnostics::text_sink;
+ friend class diagnostics::buffer;
typedef void (*set_locations_callback_t) (diagnostic_context *,
diagnostic_info *);
void emit_diagram (const diagnostics::diagram &diag);
/* Various setters for use by option-handling logic. */
- void set_output_format (std::unique_ptr<diagnostic_output_format> output_format);
+ void set_sink (std::unique_ptr<diagnostics::sink> sink_);
void set_text_art_charset (enum diagnostic_text_art_charset charset);
void set_client_data_hooks (std::unique_ptr<diagnostics::client_data_hooks> hooks);
return m_warning_as_error_requested;
}
bool show_path_depths_p () const { return m_show_path_depths; }
- diagnostic_output_format &get_output_format (size_t idx) const;
+ diagnostics::sink &get_sink (size_t idx) const;
enum diagnostic_path_format get_path_format () const { return m_path_format; }
enum diagnostics_escape_format get_escape_format () const
{
}
- void set_diagnostic_buffer (diagnostic_buffer *);
- diagnostic_buffer *get_diagnostic_buffer () const
+ void set_diagnostic_buffer (diagnostics::buffer *);
+ diagnostics::buffer *get_diagnostic_buffer () const
{
return m_diagnostic_buffer;
}
- void clear_diagnostic_buffer (diagnostic_buffer &);
- void flush_diagnostic_buffer (diagnostic_buffer &);
+ void clear_diagnostic_buffer (diagnostics::buffer &);
+ void flush_diagnostic_buffer (diagnostics::buffer &);
std::unique_ptr<pretty_printer> clone_printer () const
{
}
void
- add_sink (std::unique_ptr<diagnostic_output_format>);
+ add_sink (std::unique_ptr<diagnostics::sink>);
void remove_all_output_sinks ();
The sinks are owned by the context; this would be a
std::vector<std::unique_ptr> if diagnostic_context had a
proper ctor. */
- auto_vec<diagnostic_output_format *> m_output_sinks;
+ auto_vec<diagnostics::sink *> m_sinks;
/* Callback to set the locations of call sites along the inlining
stack corresponding to a diagnostic location. Needed to traverse
/* Owned by the context. */
char **m_original_argv;
- /* Borrowed pointer to the active diagnostic_buffer, if any.
+ /* Borrowed pointer to the active diagnostics::buffer, if any.
If null (the default), then diagnostics that are reported to the
context are immediately issued to the output format.
If non-null, then diagnostics that are reported to the context
are buffered in the buffer, and may be issued to the output format
later (if the buffer is flushed), moved to other buffers, or
discarded (if the buffer is cleared). */
- diagnostic_buffer *m_diagnostic_buffer;
+ diagnostics::buffer *m_diagnostic_buffer;
};
/* Client supplied function to announce a diagnostic
diagnostic_t)
ATTRIBUTE_GCC_DIAG(2,0);
#endif
-void default_diagnostic_text_starter (diagnostic_text_output_format &,
- const diagnostic_info *);
+
+namespace diagnostics {
+
+void default_text_starter (diagnostics::text_sink &,
+ const diagnostic_info *);
template <typename Sink>
-void default_diagnostic_start_span_fn (const diagnostic_location_print_policy &,
- Sink &sink,
- expanded_location);
-void default_diagnostic_text_finalizer (diagnostic_text_output_format &,
- const diagnostic_info *,
- diagnostic_t);
+void default_start_span_fn (const diagnostic_location_print_policy &,
+ Sink &sink,
+ expanded_location);
+void default_text_finalizer (diagnostics::text_sink &,
+ const diagnostic_info *,
+ diagnostic_t);
+} // namespace diagnostics
+
void diagnostic_set_caret_max_width (diagnostic_context *context, int value);
int get_terminal_width (void);
extern const char *get_diagnostic_kind_text (diagnostic_t kind);
+namespace diagnostics {
+
const char *maybe_line_and_column (int line, int col);
+} // namespace diagnostics
+
#endif /* ! GCC_DIAGNOSTIC_H */
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
-#ifndef GCC_DIAGNOSTIC_BUFFER_H
-#define GCC_DIAGNOSTIC_BUFFER_H
+#ifndef GCC_DIAGNOSTICS_BUFFERING_H
+#define GCC_DIAGNOSTICS_BUFFERING_H
#include "diagnostic.h"
-class diagnostic_per_format_buffer;
-class diagnostic_output_format;
- class diagnostic_text_output_format;
+namespace diagnostics {
+
+class per_sink_buffer;
+class sink;
+ class text_sink;
/* Class representing a buffer of zero or more diagnostics that
have been reported to a diagnostic_context, but which haven't
yet been flushed.
- A diagnostic_buffer can be:
+ A diagnostics::buffer can be:
* flushed to the diagnostic_context, which issues
the diagnostics within the buffer to the output format
and checks for limits such as -fmax-errors=, or
- * moved to another diagnostic_buffer, which moves the diagnostics
+ * moved to another diagnostics::buffer, which moves the diagnostics
within the first buffer to the other buffer, appending them after any
existing diagnostics within the destination buffer, emptying the
source buffer, or
to change buffering on a diagnostic_context whilst within a
diagnostic group. */
-class diagnostic_buffer
+class buffer
{
public:
- friend class diagnostic_context;
+ friend class ::diagnostic_context;
- diagnostic_buffer (diagnostic_context &ctxt);
- ~diagnostic_buffer ();
+ buffer (diagnostic_context &ctxt);
+ ~buffer ();
void dump (FILE *out, int indent) const;
void DEBUG_FUNCTION dump () const { dump (stderr, 0); }
bool empty_p () const;
- void move_to (diagnostic_buffer &dest);
+ void move_to (buffer &dest);
private:
- void ensure_per_format_buffers ();
+ void ensure_per_sink_buffers ();
diagnostic_context &m_ctxt;
- auto_vec<diagnostic_per_format_buffer *> *m_per_format_buffers;
+ auto_vec<per_sink_buffer *> *m_per_sink_buffers;
/* The number of buffered diagnostics of each kind. */
diagnostic_counters m_diagnostic_counters;
};
-/* Implementation detail of diagnostic_buffer.
+/* Implementation detail of diagnostics::buffer.
Abstract base class describing how to represent zero of more
- buffered diagnostics for a particular diagnostic_output_format
+ buffered diagnostics for a particular diagnostics::sink
(e.g. text vs SARIF).
- Each diagnostic_output_format subclass should implement its own
- subclass for handling diagnostic_buffer. */
+ Each diagnostics::sink subclass should implement its own
+ subclass for handling diagnostics::buffer. */
-class diagnostic_per_format_buffer
+class per_sink_buffer
{
public:
- virtual ~diagnostic_per_format_buffer () {}
+ virtual ~per_sink_buffer () {}
virtual void dump (FILE *out, int indent) const = 0;
void DEBUG_FUNCTION dump () const { dump (stderr, 0); }
virtual bool empty_p () const = 0;
- virtual void move_to (diagnostic_per_format_buffer &dest) = 0;
+ virtual void move_to (per_sink_buffer &dest) = 0;
virtual void clear () = 0;
virtual void flush () = 0;
};
-#endif /* ! GCC_DIAGNOSTIC_BUFFER_H */
+} // namespace diagnostics
+
+#endif /* ! GCC_DIAGNOSTICS_BUFFERING_H */
#include "diagnostics/logical-locations.h"
-class sarif_object;
-
namespace diagnostics {
+class sarif_object;
class client_version_info;
/* A bundle of additional metadata, owned by the diagnostic_context,
#include "graphviz.h"
#include "diagnostics/digraphs.h"
-#include "diagnostic-format-sarif.h"
+#include "diagnostics/sarif-sink.h"
#include "selftest.h"
#include "coretypes.h"
#include "diagnostic.h"
#include "diagnostics/metadata.h"
-#include "diagnostic-format.h"
-#include "diagnostic-format-html.h"
-#include "diagnostic-format-text.h"
-#include "diagnostic-format-sarif.h"
+#include "diagnostics/sink.h"
+#include "diagnostics/html-sink.h"
+#include "diagnostics/text-sink.h"
+#include "diagnostics/sarif-sink.h"
#include "diagnostics/output-file.h"
-#include "diagnostic-buffer.h"
+#include "diagnostics/buffering.h"
#include "diagnostics/paths.h"
#include "diagnostics/client-data-hooks.h"
#include "selftest.h"
#include "json.h"
#include "selftest-xml.h"
-using namespace diagnostics;
+namespace diagnostics {
// struct html_generation_options
/* Concrete buffering implementation subclass for HTML output. */
-class diagnostic_html_format_buffer : public diagnostic_per_format_buffer
+class html_sink_buffer : public per_sink_buffer
{
public:
friend class html_builder;
- friend class html_output_format;
+ friend class html_sink;
- diagnostic_html_format_buffer (html_builder &builder)
+ html_sink_buffer (html_builder &builder)
: m_builder (builder)
{}
void dump (FILE *out, int indent) const final override;
bool empty_p () const final override;
- void move_to (diagnostic_per_format_buffer &dest) final override;
+ void move_to (per_sink_buffer &dest) final override;
void clear () final override;
void flush () final override;
class html_builder
{
public:
- friend class diagnostic_html_format_buffer;
+ friend class html_sink_buffer;
html_builder (diagnostic_context &context,
pretty_printer &pp,
void on_report_diagnostic (const diagnostic_info &diagnostic,
diagnostic_t orig_diag_kind,
- diagnostic_html_format_buffer *buffer);
+ html_sink_buffer *buffer);
void emit_diagram (const diagram &d);
void emit_global_graph (const digraphs::lazy_digraph &);
return span;
}
-/* class diagnostic_html_format_buffer : public diagnostic_per_format_buffer. */
+/* class html_sink_buffer : public per_sink_buffer. */
void
-diagnostic_html_format_buffer::dump (FILE *out, int indent) const
+html_sink_buffer::dump (FILE *out, int indent) const
{
- fprintf (out, "%*sdiagnostic_html_format_buffer:\n", indent, "");
+ fprintf (out, "%*shtml_sink_buffer:\n", indent, "");
int idx = 0;
for (auto &result : m_results)
{
}
bool
-diagnostic_html_format_buffer::empty_p () const
+html_sink_buffer::empty_p () const
{
return m_results.empty ();
}
void
-diagnostic_html_format_buffer::move_to (diagnostic_per_format_buffer &base)
+html_sink_buffer::move_to (per_sink_buffer &base)
{
- diagnostic_html_format_buffer &dest
- = static_cast<diagnostic_html_format_buffer &> (base);
+ html_sink_buffer &dest
+ = static_cast<html_sink_buffer &> (base);
for (auto &&result : m_results)
dest.m_results.push_back (std::move (result));
m_results.clear ();
}
void
-diagnostic_html_format_buffer::clear ()
+html_sink_buffer::clear ()
{
m_results.clear ();
}
void
-diagnostic_html_format_buffer::flush ()
+html_sink_buffer::flush ()
{
for (auto &&result : m_results)
m_builder.m_diagnostics_element->add_child (std::move (result));
void
html_builder::on_report_diagnostic (const diagnostic_info &diagnostic,
diagnostic_t orig_diag_kind,
- diagnostic_html_format_buffer *buffer)
+ html_sink_buffer *buffer)
{
if (diagnostic.kind == DK_ICE || diagnostic.kind == DK_ICE_NOBT)
{
fprintf (outf, "\n");
}
-class html_output_format : public diagnostic_output_format
+class html_sink : public sink
{
public:
- ~html_output_format ()
+ ~html_sink ()
{
/* Any diagnostics should have been handled by now.
If not, then something's gone wrong with diagnostic
void dump (FILE *out, int indent) const override
{
- fprintf (out, "%*shtml_output_format\n", indent, "");
- diagnostic_output_format::dump (out, indent);
+ fprintf (out, "%*shtml_sink\n", indent, "");
+ sink::dump (out, indent);
}
void
m_builder.set_main_input_filename (name);
}
- std::unique_ptr<diagnostic_per_format_buffer>
- make_per_format_buffer () final override
+ std::unique_ptr<per_sink_buffer>
+ make_per_sink_buffer () final override
{
- return std::make_unique<diagnostic_html_format_buffer> (m_builder);
+ return std::make_unique<html_sink_buffer> (m_builder);
}
- void set_buffer (diagnostic_per_format_buffer *base_buffer) final override
+ void set_buffer (per_sink_buffer *base_buffer) final override
{
- diagnostic_html_format_buffer *buffer
- = static_cast<diagnostic_html_format_buffer *> (base_buffer);
+ html_sink_buffer *buffer
+ = static_cast<html_sink_buffer *> (base_buffer);
m_buffer = buffer;
}
html_builder &get_builder () { return m_builder; }
protected:
- html_output_format (diagnostic_context &context,
- const line_maps *line_maps,
- const html_generation_options &html_gen_opts)
- : diagnostic_output_format (context),
+ html_sink (diagnostic_context &context,
+ const line_maps *line_maps,
+ const html_generation_options &html_gen_opts)
+ : sink (context),
m_builder (context, *get_printer (), line_maps, html_gen_opts),
m_buffer (nullptr)
{}
html_builder m_builder;
- diagnostic_html_format_buffer *m_buffer;
+ html_sink_buffer *m_buffer;
};
-class html_file_output_format : public html_output_format
+class html_file_sink : public html_sink
{
public:
- html_file_output_format (diagnostic_context &context,
- const line_maps *line_maps,
- const html_generation_options &html_gen_opts,
- output_file output_file_)
- : html_output_format (context, line_maps, html_gen_opts),
+ html_file_sink (diagnostic_context &context,
+ const line_maps *line_maps,
+ const html_generation_options &html_gen_opts,
+ output_file output_file_)
+ : html_sink (context, line_maps, html_gen_opts),
m_output_file (std::move (output_file_))
{
gcc_assert (m_output_file.get_open_file ());
gcc_assert (m_output_file.get_filename ());
}
- ~html_file_output_format ()
+ ~html_file_sink ()
{
m_builder.flush_to_file (m_output_file.get_open_file ());
}
void dump (FILE *out, int indent) const override
{
- fprintf (out, "%*shtml_file_output_format: %s\n",
+ fprintf (out, "%*shtml_file_sink: %s\n",
indent, "",
m_output_file.get_filename ());
- diagnostic_output_format::dump (out, indent);
+ sink::dump (out, indent);
}
bool machine_readable_stderr_p () const final override
{
using LINE_MAPS. */
output_file
-diagnostic_output_format_open_html_file (diagnostic_context &context,
- line_maps *line_maps,
- const char *base_file_name)
+open_html_output_file (diagnostic_context &context,
+ line_maps *line_maps,
+ const char *base_file_name)
{
if (!base_file_name)
{
return output_file (outf, true, std::move (filename));
}
-std::unique_ptr<diagnostic_output_format>
+std::unique_ptr<sink>
make_html_sink (diagnostic_context &context,
const line_maps &line_maps,
const html_generation_options &html_gen_opts,
output_file output_file_)
{
auto sink
- = std::make_unique<html_file_output_format> (context,
- &line_maps,
- html_gen_opts,
- std::move (output_file_));
+ = std::make_unique<html_file_sink> (context,
+ &line_maps,
+ html_gen_opts,
+ std::move (output_file_));
sink->update_printer ();
return sink;
}
+} // namespace diagnostics
+
#if CHECKING_P
namespace selftest {
+using namespace diagnostics;
+
/* Helper for writing tests of html_token_printer.
Printing to m_pp will appear as HTML within m_top_element, a <div>. */
}
}
-/* A subclass of html_output_format for writing selftests.
+/* A subclass of html_sink for writing selftests.
The XML output is cached internally, rather than written
out to a file. */
html_generation_options html_gen_opts;
html_gen_opts.m_css = false;
html_gen_opts.m_javascript = false;
- auto sink = std::make_unique<html_buffered_output_format> (*this,
- line_table,
- html_gen_opts);
+ auto sink = std::make_unique<html_buffered_sink> (*this,
+ line_table,
+ html_gen_opts);
sink->update_printer ();
sink->set_main_input_filename ("(main input filename)");
m_format = sink.get (); // borrowed
- set_output_format (std::move (sink));
+ set_sink (std::move (sink));
}
const xml::document &get_document () const
}
private:
- class html_buffered_output_format : public html_output_format
+ class html_buffered_sink : public html_sink
{
public:
- html_buffered_output_format (diagnostic_context &context,
- const line_maps *line_maps,
- const html_generation_options &html_gen_opts)
- : html_output_format (context, line_maps, html_gen_opts)
+ html_buffered_sink (diagnostic_context &context,
+ const line_maps *line_maps,
+ const html_generation_options &html_gen_opts)
+ : html_sink (context, line_maps, html_gen_opts)
{
}
bool machine_readable_stderr_p () const final override
}
};
- html_output_format *m_format; // borrowed
+ html_sink *m_format; // borrowed
};
/* Test of reporting a diagnostic at UNKNOWN_LOCATION to a
/* Run all of the selftests within this file. */
void
-diagnostic_format_html_cc_tests ()
+diagnostics_html_sink_cc_tests ()
{
auto_fix_quotes fix_quotes;
test_token_printer ();
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
-#ifndef GCC_DIAGNOSTIC_FORMAT_HTML_H
-#define GCC_DIAGNOSTIC_FORMAT_HTML_H
+#ifndef GCC_DIAGNOSTICS_HTML_SINK_H
+#define GCC_DIAGNOSTICS_HTML_SINK_H
-#include "diagnostic-format.h"
+#include "diagnostics/sink.h"
#include "diagnostics/output-file.h"
+namespace diagnostics {
+
struct html_generation_options
{
html_generation_options ();
};
extern diagnostics::output_file
-diagnostic_output_format_open_html_file (diagnostic_context &context,
- line_maps *line_maps,
- const char *base_file_name);
+open_html_output_file (diagnostic_context &context,
+ line_maps *line_maps,
+ const char *base_file_name);
-extern std::unique_ptr<diagnostic_output_format>
+extern std::unique_ptr<sink>
make_html_sink (diagnostic_context &context,
const line_maps &line_maps,
const html_generation_options &html_gen_opts,
html_label_writer *event_label_writer,
const diagnostic_source_print_policy &dspp);
-#endif /* ! GCC_DIAGNOSTIC_FORMAT_HTML_H */
+} // namespace diagnostics
+
+#endif /* ! GCC_DIAGNOSTICS_HTML_SINK_H */
#include "selftest-diagnostic.h"
#include "simple-diagnostic-path.h"
#include "gcc-rich-location.h"
-#include "diagnostic-format-text.h"
+#include "diagnostics/text-sink.h"
using namespace diagnostics::paths;
/* Verify that the path works as expected. */
dc.set_path_format (DPF_INLINE_EVENTS);
- diagnostic_text_output_format sink (dc);
- pp_buffer (sink.get_printer ())->m_flush_p = false;
- sink.print_path (rich_loc.m_path);
- ASSERT_STREQ (pp_formatted_text (sink.get_printer ()),
+ diagnostics::text_sink sink_ (dc);
+ pp_buffer (sink_.get_printer ())->m_flush_p = false;
+ sink_.print_path (rich_loc.m_path);
+ ASSERT_STREQ (pp_formatted_text (sink_.get_printer ()),
" `foo': event 1\n"
" (1): first `free'\n"
" `foo': event 2\n"
#ifndef GCC_DIAGNOSTICS_METADATA_H
#define GCC_DIAGNOSTICS_METADATA_H
-class sarif_object;
-
namespace diagnostics {
+ class sarif_object;
+
namespace digraphs {
class lazy_digraphs;
} // namespace digraphs
#include "intl.h"
#include "diagnostic.h"
#include "diagnostic-color.h"
-#include "diagnostic-format.h"
-#include "diagnostic-format-html.h"
-#include "diagnostic-format-text.h"
-#include "diagnostic-format-sarif.h"
+#include "diagnostics/sink.h"
+#include "diagnostics/html-sink.h"
+#include "diagnostics/text-sink.h"
+#include "diagnostics/sarif-sink.h"
#include "selftest.h"
#include "selftest-diagnostic.h"
#include "pretty-print-markup.h"
};
/* Class for parsing the arguments of -fdiagnostics-add-output= and
- -fdiagnostics-set-output=, and making diagnostic_output_format
+ -fdiagnostics-set-output=, and making sink
instances (or issuing errors). */
class output_factory
const std::string &get_scheme_name () const { return m_scheme_name; }
- virtual std::unique_ptr<diagnostic_output_format>
+ virtual std::unique_ptr<sink>
make_sink (const context &ctxt,
diagnostic_context &dc,
const char *unparsed_arg,
output_factory ();
- std::unique_ptr<diagnostic_output_format>
+ std::unique_ptr<sink>
make_sink (const context &ctxt,
diagnostic_context &dc,
const char *unparsed_arg,
public:
text_scheme_handler () : scheme_handler ("text") {}
- std::unique_ptr<diagnostic_output_format>
+ std::unique_ptr<sink>
make_sink (const context &ctxt,
diagnostic_context &dc,
const char *unparsed_arg,
public:
sarif_scheme_handler () : scheme_handler ("sarif") {}
- std::unique_ptr<diagnostic_output_format>
+ std::unique_ptr<sink>
make_sink (const context &ctxt,
diagnostic_context &dc,
const char *unparsed_arg,
public:
html_scheme_handler () : scheme_handler ("experimental-html") {}
- std::unique_ptr<diagnostic_output_format>
+ std::unique_ptr<sink>
make_sink (const context &ctxt,
diagnostic_context &dc,
const char *unparsed_arg,
return std::make_unique<scheme_name_and_params> (std::move (result));
}
-std::unique_ptr<diagnostic_output_format>
+std::unique_ptr<sink>
context::parse_and_make_sink (const char *unparsed_arg,
diagnostic_context &dc)
{
return nullptr;
}
-std::unique_ptr<diagnostic_output_format>
+std::unique_ptr<sink>
output_factory::make_sink (const context &ctxt,
diagnostic_context &dc,
const char *unparsed_arg,
/* class text_scheme_handler : public output_factory::scheme_handler. */
-std::unique_ptr<diagnostic_output_format>
+std::unique_ptr<sink>
text_scheme_handler::make_sink (const context &ctxt,
diagnostic_context &dc,
const char *unparsed_arg,
return nullptr;
}
- auto sink = std::make_unique<diagnostic_text_output_format> (dc);
+ auto sink = std::make_unique<diagnostics::text_sink> (dc);
sink->set_show_nesting (show_nesting);
sink->set_show_locations_in_nesting (show_locations_in_nesting);
sink->set_show_nesting_levels (show_levels);
/* class sarif_scheme_handler : public output_factory::scheme_handler. */
-std::unique_ptr<diagnostic_output_format>
+std::unique_ptr<sink>
sarif_scheme_handler::make_sink (const context &ctxt,
diagnostic_context &dc,
const char *unparsed_arg,
return nullptr;
}
output_file_
- = diagnostic_output_format_open_sarif_file
- (dc,
- ctxt.get_affected_location_mgr (),
- basename,
- serialization_kind);
+ = open_sarif_output_file (dc,
+ ctxt.get_affected_location_mgr (),
+ basename,
+ serialization_kind);
}
if (!output_file_)
return nullptr;
/* class html_scheme_handler : public output_factory::scheme_handler. */
-std::unique_ptr<diagnostic_output_format>
+std::unique_ptr<sink>
html_scheme_handler::make_sink (const context &ctxt,
diagnostic_context &dc,
const char *unparsed_arg,
return nullptr;
}
output_file_
- = diagnostic_output_format_open_html_file
+ = open_html_output_file
(dc,
ctxt.get_affected_location_mgr (),
basename);
parser_test ()
: m_dc (),
m_ctxt (m_dc, line_table, UNKNOWN_LOCATION, "-fOPTION="),
- m_fmt (m_dc.get_output_format (0))
+ m_fmt (m_dc.get_sink (0))
{
pp_buffer (m_fmt.get_printer ())->m_flush_p = false;
}
private:
test_diagnostic_context m_dc;
test_spec_context m_ctxt;
- diagnostic_output_format &m_fmt;
+ diagnostics::sink &m_fmt;
};
/* Selftests. */
#ifndef GCC_DIAGNOSTICS_OUTPUT_SPEC_H
#define GCC_DIAGNOSTICS_OUTPUT_SPEC_H
-#include "diagnostic-format.h"
+#include "diagnostics/sink.h"
#include "diagnostics/output-file.h"
namespace diagnostics {
class context
{
public:
- std::unique_ptr<diagnostic_output_format>
+ std::unique_ptr<sink>
parse_and_make_sink (const char *,
diagnostic_context &dc);
#include "selftest-diagnostic.h"
#include "diagnostics/selftest-paths.h"
#include "text-art/theme.h"
-#include "diagnostic-format-text.h"
-#include "diagnostic-format-html.h"
+#include "diagnostics/text-sink.h"
+#include "diagnostics/html-sink.h"
#include "xml.h"
#include "xml-printer.h"
class path_print_policy
{
public:
- path_print_policy (const diagnostic_text_output_format &text_output)
+ path_print_policy (const diagnostics::text_sink &text_output)
: m_source_policy (text_output.get_context ())
{
}
call to diagnostic_show_locus. */
void print_as_text (pretty_printer &pp,
- diagnostic_text_output_format &text_output,
+ diagnostics::text_sink &text_output,
diagnostic_source_effect_info *effect_info)
{
location_t initial_loc = m_initial_event.get_location ();
}
void
- print_swimlane_for_event_range_as_text (diagnostic_text_output_format &text_output,
+ print_swimlane_for_event_range_as_text (diagnostics::text_sink &text_output,
pretty_printer *pp,
const logical_locations::manager &logical_loc_mgr,
event_range *range,
static void
print_path_summary_as_text (const path_summary &ps,
- diagnostic_text_output_format &text_output,
+ diagnostics::text_sink &text_output,
bool show_depths)
{
pretty_printer *const pp = text_output.get_printer ();
/* Print PATH according to the context's path_format. */
void
-diagnostic_text_output_format::print_path (const path &path_)
+diagnostics::text_sink::print_path (const path &path_)
{
const unsigned num_events = path_.num_events ();
If non-null, use EVENT_LABEL_WRITER when writing events. */
void
-print_path_as_html (xml::printer &xp,
- const path &path_,
- diagnostic_context &dc,
- html_label_writer *event_label_writer,
- const diagnostic_source_print_policy &dspp)
+diagnostics::print_path_as_html (xml::printer &xp,
+ const path &path_,
+ diagnostic_context &dc,
+ html_label_writer *event_label_writer,
+ const diagnostic_source_print_policy &dspp)
{
path_print_policy policy (dc);
const bool check_rich_locations = true;
ASSERT_FALSE (path.interprocedural_p ());
test_diagnostic_context dc;
- diagnostic_text_output_format text_output (dc);
+ diagnostics::text_sink text_output (dc);
path_print_policy policy (text_output);
path_summary summary (policy, *event_pp, path, false);
ASSERT_EQ (summary.get_num_ranges (), 0);
ASSERT_FALSE (path.interprocedural_p ());
test_diagnostic_context dc;
- diagnostic_text_output_format text_output (dc);
+ diagnostics::text_sink text_output (dc);
path_print_policy policy (text_output);
path_summary summary (policy, *event_pp, path, false, false, false);
ASSERT_EQ (summary.get_num_ranges (), 1);
{
test_diagnostic_context dc;
- diagnostic_text_output_format text_output (dc, nullptr, false);
+ diagnostics::text_sink text_output (dc, nullptr, false);
path_print_policy policy (text_output);
path_summary summary (policy, *event_pp, path, false);
ASSERT_EQ (summary.get_num_ranges (), 9);
{
test_diagnostic_context dc;
dc.set_text_art_charset (DIAGNOSTICS_TEXT_ART_CHARSET_UNICODE);
- diagnostic_text_output_format text_output (dc);
+ diagnostics::text_sink text_output (dc);
path_print_policy policy (text_output);
path_summary summary (policy, *event_pp, path, false);
print_path_summary_as_text (summary, text_output, true);
{
test_diagnostic_context dc;
- diagnostic_text_output_format text_output (dc);
+ diagnostics::text_sink text_output (dc);
path_print_policy policy (text_output);
path_summary summary (policy, *event_pp, path, false);
ASSERT_EQ (summary.get_num_ranges (), 5);
{
test_diagnostic_context dc;
dc.set_text_art_charset (DIAGNOSTICS_TEXT_ART_CHARSET_UNICODE);
- diagnostic_text_output_format text_output (dc);
+ diagnostics::text_sink text_output (dc);
path_print_policy policy (text_output);
path_summary summary (policy, *event_pp, path, false);
print_path_summary_as_text (summary, text_output, true);
test_diagnostic_context dc;
dc.set_text_art_charset (DIAGNOSTICS_TEXT_ART_CHARSET_ASCII);
- diagnostic_text_output_format text_output (dc);
+ diagnostics::text_sink text_output (dc);
path_print_policy policy (text_output);
path_summary summary (policy, *event_pp, path, false);
ASSERT_EQ (summary.get_num_ranges (), 4);
test_diagnostic_context dc;
dc.set_text_art_charset (DIAGNOSTICS_TEXT_ART_CHARSET_UNICODE);
- diagnostic_text_output_format text_output (dc);
+ diagnostics::text_sink text_output (dc);
path_print_policy policy (text_output);
path_summary summary (policy, *event_pp, path, false);
print_path_summary_as_text (summary, text_output, true);
test_diagnostic_context dc;
dc.set_text_art_charset (DIAGNOSTICS_TEXT_ART_CHARSET_ASCII);
dc.m_source_printing.show_event_links_p = true;
- diagnostic_text_output_format text_output (dc);
+ diagnostics::text_sink text_output (dc);
path_print_policy policy (text_output);
path_summary summary (policy, *event_pp, path, true);
print_path_summary_as_text (summary, text_output, false);
test_diagnostic_context dc;
dc.set_text_art_charset (DIAGNOSTICS_TEXT_ART_CHARSET_ASCII);
dc.m_source_printing.show_event_links_p = false;
- diagnostic_text_output_format text_output (dc);
+ diagnostics::text_sink text_output (dc);
path_print_policy policy (text_output);
path_summary summary (policy, *event_pp, path, true);
print_path_summary_as_text (summary, text_output, false);
dc.set_text_art_charset (DIAGNOSTICS_TEXT_ART_CHARSET_ASCII);
dc.m_source_printing.show_line_numbers_p = true;
dc.m_source_printing.show_event_links_p = true;
- diagnostic_text_output_format text_output (dc);
+ diagnostics::text_sink text_output (dc);
path_print_policy policy (text_output);
path_summary summary (policy, *event_pp, path, true);
print_path_summary_as_text (summary, text_output, false);
dc.set_text_art_charset (DIAGNOSTICS_TEXT_ART_CHARSET_ASCII);
dc.m_source_printing.show_line_numbers_p = true;
dc.m_source_printing.show_event_links_p = false;
- diagnostic_text_output_format text_output (dc);
+ diagnostics::text_sink text_output (dc);
path_print_policy policy (text_output);
path_summary summary (policy, *event_pp, path, true);
print_path_summary_as_text (summary, text_output, false);
test_diagnostic_context dc;
dc.set_text_art_charset (DIAGNOSTICS_TEXT_ART_CHARSET_UNICODE);
dc.m_source_printing.show_event_links_p = true;
- diagnostic_text_output_format text_output (dc);
+ diagnostics::text_sink text_output (dc);
path_print_policy policy (text_output);
path_summary summary (policy, *event_pp, path, true);
print_path_summary_as_text (summary, text_output, false);
dc.set_text_art_charset (DIAGNOSTICS_TEXT_ART_CHARSET_UNICODE);
dc.m_source_printing.show_event_links_p = true;
dc.m_source_printing.show_line_numbers_p = true;
- diagnostic_text_output_format text_output (dc);
+ diagnostics::text_sink text_output (dc);
path_print_policy policy (text_output);
path_summary summary (policy, *event_pp, path, true);
print_path_summary_as_text (summary, text_output, false);
dc.set_text_art_charset (DIAGNOSTICS_TEXT_ART_CHARSET_ASCII);
dc.m_source_printing.show_event_links_p = true;
dc.m_source_printing.show_line_numbers_p = true;
- diagnostic_text_output_format text_output (dc);
+ diagnostics::text_sink text_output (dc);
path_print_policy policy (text_output);
path_summary summary (policy, *event_pp, path, true);
print_path_summary_as_text (summary, text_output, false);
dc.set_text_art_charset (DIAGNOSTICS_TEXT_ART_CHARSET_ASCII);
dc.m_source_printing.show_event_links_p = true;
dc.m_source_printing.show_line_numbers_p = true;
- diagnostic_text_output_format text_output (dc);
+ diagnostics::text_sink text_output (dc);
path_print_policy policy (text_output);
path_summary summary (policy, *event_pp, path, true);
print_path_summary_as_text (summary, text_output, false);
dc.set_text_art_charset (DIAGNOSTICS_TEXT_ART_CHARSET_ASCII);
dc.m_source_printing.show_event_links_p = true;
dc.m_source_printing.show_line_numbers_p = true;
- diagnostic_text_output_format text_output (dc);
+ diagnostics::text_sink text_output (dc);
path_print_policy policy (text_output);
path_summary summary (policy, *event_pp, path, true);
print_path_summary_as_text (summary, text_output, false);
dc.set_text_art_charset (DIAGNOSTICS_TEXT_ART_CHARSET_ASCII);
dc.m_source_printing.show_event_links_p = true;
dc.m_source_printing.show_line_numbers_p = true;
- diagnostic_text_output_format text_output (dc);
+ diagnostics::text_sink text_output (dc);
path_print_policy policy (text_output);
path_summary summary (policy, *event_pp, path, true);
print_path_summary_as_text (summary, text_output, false);
dc.set_text_art_charset (DIAGNOSTICS_TEXT_ART_CHARSET_ASCII);
dc.m_source_printing.show_event_links_p = true;
dc.m_source_printing.show_line_numbers_p = true;
- diagnostic_text_output_format text_output (dc);
+ diagnostics::text_sink text_output (dc);
path_print_policy policy (text_output);
path_summary summary (policy, *event_pp, path, true);
print_path_summary_as_text (summary, text_output, false);
#include "diagnostics/event-id.h"
#include "diagnostics/logical-locations.h"
-namespace xml { class document; }
-
-class sarif_builder;
-class sarif_object;
-
namespace diagnostics {
namespace digraphs {
class digraph;
namespace logical_locations {
class manager;
} // logical_locations
+ class sarif_builder;
+ class sarif_object;
} //namespace diagnostics
namespace diagnostics {
#include "diagnostics/digraphs.h"
#include "diagnostics/state-graphs.h"
#include "diagnostics/paths.h"
-#include "diagnostic-format.h"
-#include "diagnostic-buffer.h"
+#include "diagnostics/sink.h"
+#include "diagnostics/buffering.h"
#include "json.h"
#include "cpplib.h"
#include "diagnostics/logical-locations.h"
#include "diagnostics/client-data-hooks.h"
#include "diagnostics/diagram.h"
#include "text-art/canvas.h"
-#include "diagnostic-format-sarif.h"
-#include "diagnostic-format-text.h"
+#include "diagnostics/sarif-sink.h"
+#include "diagnostics/text-sink.h"
#include "ordered-hash-map.h"
#include "sbitmap.h"
#include "selftest.h"
#include "backtrace.h"
#include "xml.h"
-using namespace diagnostics;
+namespace diagnostics {
/* A json::array where the values are "unique" as per
SARIF v2.1.0 section 3.7.3 ("Array properties with unique values"). */
render (const sarif_builder &builder) const = 0;
};
-/* Concrete buffering implementation subclass for JSON output. */
+/* Concrete buffering implementation subclass for SARIF output. */
-class diagnostic_sarif_format_buffer : public diagnostic_per_format_buffer
+class sarif_sink_buffer : public per_sink_buffer
{
public:
- friend class sarif_output_format;
+ friend class sarif_sink;
- diagnostic_sarif_format_buffer (sarif_builder &builder)
+ sarif_sink_buffer (sarif_builder &builder)
: m_builder (builder)
{}
void dump (FILE *out, int indent) const final override;
bool empty_p () const final override;
- void move_to (diagnostic_per_format_buffer &dest) final override;
+ void move_to (per_sink_buffer &dest) final override;
void clear () final override;
void flush () final override;
class sarif_builder
{
public:
- friend class diagnostic_sarif_format_buffer;
+ friend class sarif_sink_buffer;
sarif_builder (diagnostic_context &context,
pretty_printer &printer,
void on_report_diagnostic (const diagnostic_info &diagnostic,
diagnostic_t orig_diag_kind,
- diagnostic_sarif_format_buffer *buffer);
+ sarif_sink_buffer *buffer);
void emit_diagram (const diagram &d);
void end_group ();
void
sarif_builder::on_report_diagnostic (const diagnostic_info &diagnostic,
diagnostic_t orig_diag_kind,
- diagnostic_sarif_format_buffer *buffer)
+ sarif_sink_buffer *buffer)
{
pp_output_formatted_text (m_printer, m_context.get_urlifier ());
diagnostic_source_print_policy source_policy (dc);
dc.set_escape_format (m_escape_format);
- diagnostic_text_output_format text_output (dc);
+ text_sink text_output (dc);
source_policy.print (*text_output.get_printer (),
my_rich_loc, DK_ERROR, nullptr);
return content_obj;
}
-/* class diagnostic_sarif_format_buffer : public diagnostic_per_format_buffer. */
+/* class sarif_sink_buffer : public per_sink_buffer. */
void
-diagnostic_sarif_format_buffer::dump (FILE *out, int indent) const
+sarif_sink_buffer::dump (FILE *out, int indent) const
{
- fprintf (out, "%*sdiagnostic_sarif_format_buffer:\n", indent, "");
+ fprintf (out, "%*ssarif_sink_buffer:\n", indent, "");
int idx = 0;
for (auto &result : m_results)
{
}
bool
-diagnostic_sarif_format_buffer::empty_p () const
+sarif_sink_buffer::empty_p () const
{
return m_results.empty ();
}
void
-diagnostic_sarif_format_buffer::move_to (diagnostic_per_format_buffer &base)
+sarif_sink_buffer::move_to (per_sink_buffer &base)
{
- diagnostic_sarif_format_buffer &dest
- = static_cast<diagnostic_sarif_format_buffer &> (base);
+ sarif_sink_buffer &dest
+ = static_cast<sarif_sink_buffer &> (base);
for (auto &&result : m_results)
dest.m_results.push_back (std::move (result));
m_results.clear ();
}
void
-diagnostic_sarif_format_buffer::clear ()
+sarif_sink_buffer::clear ()
{
m_results.clear ();
}
void
-diagnostic_sarif_format_buffer::flush ()
+sarif_sink_buffer::flush ()
{
for (auto &&result : m_results)
{
m_results.clear ();
}
-class sarif_output_format : public diagnostic_output_format
+class sarif_sink : public sink
{
public:
- ~sarif_output_format ()
+ ~sarif_sink ()
{
/* Any sarifResult objects should have been handled by now.
If not, then something's gone wrong with diagnostic
void dump (FILE *out, int indent) const override
{
- fprintf (out, "%*ssarif_output_format\n", indent, "");
- diagnostic_output_format::dump (out, indent);
+ fprintf (out, "%*ssarif_sink\n", indent, "");
+ sink::dump (out, indent);
}
void
m_builder.set_main_input_filename (name);
}
- std::unique_ptr<diagnostic_per_format_buffer>
- make_per_format_buffer () final override
+ std::unique_ptr<per_sink_buffer>
+ make_per_sink_buffer () final override
{
- return std::make_unique<diagnostic_sarif_format_buffer> (m_builder);
+ return std::make_unique<sarif_sink_buffer> (m_builder);
}
- void set_buffer (diagnostic_per_format_buffer *base_buffer) final override
+ void set_buffer (per_sink_buffer *base_buffer) final override
{
- diagnostic_sarif_format_buffer *buffer
- = static_cast<diagnostic_sarif_format_buffer *> (base_buffer);
+ sarif_sink_buffer *buffer
+ = static_cast<sarif_sink_buffer *> (base_buffer);
m_buffer = buffer;
}
sarif_result &get_result (size_t idx) { return m_builder.get_result (idx); }
protected:
- sarif_output_format (diagnostic_context &context,
- const line_maps *line_maps,
- std::unique_ptr<sarif_serialization_format> serialization_format,
- const sarif_generation_options &sarif_gen_opts)
- : diagnostic_output_format (context),
+ sarif_sink (diagnostic_context &context,
+ const line_maps *line_maps,
+ std::unique_ptr<sarif_serialization_format> serialization_format,
+ const sarif_generation_options &sarif_gen_opts)
+ : sink (context),
m_builder (context, *get_printer (), line_maps,
std::move (serialization_format), sarif_gen_opts),
m_buffer (nullptr)
{}
sarif_builder m_builder;
- diagnostic_sarif_format_buffer *m_buffer;
+ sarif_sink_buffer *m_buffer;
};
-class sarif_stream_output_format : public sarif_output_format
+class sarif_stream_sink : public sarif_sink
{
public:
- sarif_stream_output_format (diagnostic_context &context,
- const line_maps *line_maps,
- std::unique_ptr<sarif_serialization_format> serialization_format,
- const sarif_generation_options &sarif_gen_opts,
- FILE *stream)
- : sarif_output_format (context, line_maps,
- std::move (serialization_format), sarif_gen_opts),
+ sarif_stream_sink (diagnostic_context &context,
+ const line_maps *line_maps,
+ std::unique_ptr<sarif_serialization_format> serialization_format,
+ const sarif_generation_options &sarif_gen_opts,
+ FILE *stream)
+ : sarif_sink (context, line_maps,
+ std::move (serialization_format), sarif_gen_opts),
m_stream (stream)
{
}
- ~sarif_stream_output_format ()
+ ~sarif_stream_sink ()
{
m_builder.flush_to_file (m_stream);
}
FILE *m_stream;
};
-class sarif_file_output_format : public sarif_output_format
+class sarif_file_sink : public sarif_sink
{
public:
- sarif_file_output_format (diagnostic_context &context,
- const line_maps *line_maps,
- std::unique_ptr<sarif_serialization_format> serialization_format,
- const sarif_generation_options &sarif_gen_opts,
- output_file output_file_)
- : sarif_output_format (context, line_maps,
- std::move (serialization_format), sarif_gen_opts),
+ sarif_file_sink (diagnostic_context &context,
+ const line_maps *line_maps,
+ std::unique_ptr<sarif_serialization_format> serialization_format,
+ const sarif_generation_options &sarif_gen_opts,
+ output_file output_file_)
+ : sarif_sink (context, line_maps,
+ std::move (serialization_format),
+ sarif_gen_opts),
m_output_file (std::move (output_file_))
{
gcc_assert (m_output_file.get_open_file ());
gcc_assert (m_output_file.get_filename ());
}
- ~sarif_file_output_format ()
+ ~sarif_file_sink ()
{
m_builder.flush_to_file (m_output_file.get_open_file ());
}
void dump (FILE *out, int indent) const override
{
- fprintf (out, "%*ssarif_file_output_format: %s\n",
+ fprintf (out, "%*ssarif_file_sink: %s\n",
indent, "",
m_output_file.get_filename ());
- diagnostic_output_format::dump (out, indent);
+ sink::dump (out, indent);
}
bool machine_readable_stderr_p () const final override
{
to a file).
Return a reference to *FMT. */
-static diagnostic_output_format &
-diagnostic_output_format_init_sarif (diagnostic_context &context,
- std::unique_ptr<sarif_output_format> fmt)
+static sink &
+init_sarif_sink (diagnostic_context &context,
+ std::unique_ptr<sarif_sink> fmt)
{
gcc_assert (fmt);
- diagnostic_output_format &out = *fmt;
+ sink &out = *fmt;
fmt->update_printer ();
- context.set_output_format (std::move (fmt));
+ context.set_sink (std::move (fmt));
return out;
}
/* Populate CONTEXT in preparation for SARIF output to stderr.
Return a reference to the new sink. */
-diagnostic_output_format &
-diagnostic_output_format_init_sarif_stderr (diagnostic_context &context,
- const line_maps *line_maps,
- bool formatted)
+sink &
+init_sarif_stderr (diagnostic_context &context,
+ const line_maps *line_maps,
+ bool formatted)
{
gcc_assert (line_maps);
const sarif_generation_options sarif_gen_opts;
auto serialization
= std::make_unique<sarif_serialization_format_json> (formatted);
- return diagnostic_output_format_init_sarif
+ return init_sarif_sink
(context,
- std::make_unique<sarif_stream_output_format> (context,
- line_maps,
- std::move (serialization),
- sarif_gen_opts,
- stderr));
+ std::make_unique<sarif_stream_sink> (context,
+ line_maps,
+ std::move (serialization),
+ sarif_gen_opts,
+ stderr));
}
/* Attempt to open "BASE_FILE_NAME""EXTENSION" for writing.
using LINE_MAPS. */
output_file
-diagnostic_output_format_open_sarif_file (diagnostic_context &context,
- line_maps *line_maps,
- const char *base_file_name,
- enum sarif_serialization_kind serialization_kind)
+open_sarif_output_file (diagnostic_context &context,
+ line_maps *line_maps,
+ const char *base_file_name,
+ enum sarif_serialization_kind serialization_kind)
{
const char *suffix;
bool is_binary;
BASE_FILE_NAME.sarif.
Return a reference to the new sink. */
-diagnostic_output_format &
-diagnostic_output_format_init_sarif_file (diagnostic_context &context,
- line_maps *line_maps,
- bool formatted,
- const char *base_file_name)
+sink &
+init_sarif_file (diagnostic_context &context,
+ line_maps *line_maps,
+ bool formatted,
+ const char *base_file_name)
{
gcc_assert (line_maps);
output_file output_file_
- = diagnostic_output_format_open_sarif_file (context,
- line_maps,
- base_file_name,
- sarif_serialization_kind::json);
+ = open_sarif_output_file (context,
+ line_maps,
+ base_file_name,
+ sarif_serialization_kind::json);
auto serialization
= std::make_unique<sarif_serialization_format_json> (formatted);
const sarif_generation_options sarif_gen_opts;
- return diagnostic_output_format_init_sarif
+ return init_sarif_sink
(context,
- std::make_unique<sarif_file_output_format> (context,
- line_maps,
- std::move (serialization),
- sarif_gen_opts,
- std::move (output_file_)));
+ std::make_unique<sarif_file_sink> (context,
+ line_maps,
+ std::move (serialization),
+ sarif_gen_opts,
+ std::move (output_file_)));
}
/* Populate CONTEXT in preparation for SARIF output to STREAM.
Return a reference to the new sink. */
-diagnostic_output_format &
-diagnostic_output_format_init_sarif_stream (diagnostic_context &context,
- const line_maps *line_maps,
- bool formatted,
- FILE *stream)
+sink &
+init_sarif_stream (diagnostic_context &context,
+ const line_maps *line_maps,
+ bool formatted,
+ FILE *stream)
{
gcc_assert (line_maps);
const sarif_generation_options sarif_gen_opts;
auto serialization
= std::make_unique<sarif_serialization_format_json> (formatted);
- return diagnostic_output_format_init_sarif
+ return init_sarif_sink
(context,
- std::make_unique<sarif_stream_output_format> (context,
- line_maps,
- std::move (serialization),
- sarif_gen_opts,
- stream));
+ std::make_unique<sarif_stream_sink> (context,
+ line_maps,
+ std::move (serialization),
+ sarif_gen_opts,
+ stream));
}
-std::unique_ptr<diagnostic_output_format>
+std::unique_ptr<sink>
make_sarif_sink (diagnostic_context &context,
const line_maps &line_maps,
std::unique_ptr<sarif_serialization_format> serialization,
output_file output_file_)
{
auto sink
- = std::make_unique<sarif_file_output_format> (context,
- &line_maps,
- std::move (serialization),
- sarif_gen_opts,
- std::move (output_file_));
+ = std::make_unique<sarif_file_sink> (context,
+ &line_maps,
+ std::move (serialization),
+ sarif_gen_opts,
+ std::move (output_file_));
sink->update_printer ();
return sink;
}
{
}
+} // namespace diagnostics
+
#if CHECKING_P
namespace selftest {
+using namespace diagnostics;
+
static void
test_sarif_array_of_unique_1 ()
{
ASSERT_JSON_INT_PROPERTY_EQ (arr[1], "index", 1);
}
-/* A subclass of sarif_output_format for writing selftests.
+/* A subclass of sarif_sink for writing selftests.
The JSON output is cached internally, rather than written
out to a file. */
test_sarif_diagnostic_context (const char *main_input_filename,
const sarif_generation_options &sarif_gen_opts)
{
- auto format = std::make_unique<buffered_output_format> (*this,
- line_table,
- true,
- sarif_gen_opts);
- m_format = format.get (); // borrowed
- diagnostic_output_format_init_sarif (*this, std::move (format));
- m_format->set_main_input_filename (main_input_filename);
+ auto sink_ = std::make_unique<buffered_sink> (*this,
+ line_table,
+ true,
+ sarif_gen_opts);
+ m_sink = sink_.get (); // borrowed
+ init_sarif_sink (*this, std::move (sink_));
+ m_sink->set_main_input_filename (main_input_filename);
}
std::unique_ptr<sarif_log> flush_to_object ()
{
- return m_format->flush_to_object ();
+ return m_sink->flush_to_object ();
}
- size_t num_results () const { return m_format->num_results (); }
- sarif_result &get_result (size_t idx) { return m_format->get_result (idx); }
+ size_t num_results () const { return m_sink->num_results (); }
+ sarif_result &get_result (size_t idx) { return m_sink->get_result (idx); }
private:
- class buffered_output_format : public sarif_output_format
+ class buffered_sink : public sarif_sink
{
public:
- buffered_output_format (diagnostic_context &context,
- const line_maps *line_maps,
- bool formatted,
- const sarif_generation_options &sarif_gen_opts)
- : sarif_output_format (context, line_maps,
- std::make_unique<sarif_serialization_format_json>
- (formatted),
- sarif_gen_opts)
+ buffered_sink (diagnostic_context &context,
+ const line_maps *line_maps,
+ bool formatted,
+ const sarif_generation_options &sarif_gen_opts)
+ : sarif_sink (context, line_maps,
+ std::make_unique<sarif_serialization_format_json> (formatted),
+ sarif_gen_opts)
{
}
bool machine_readable_stderr_p () const final override
}
};
- buffered_output_format *m_format; // borrowed
+ buffered_sink *m_sink; // borrowed
};
/* Test making a sarif_location for a complex rich_location
{
test_sarif_diagnostic_context dc ("test.c", sarif_gen_opts);
- diagnostic_buffer buf_a (dc);
- diagnostic_buffer buf_b (dc);
+ diagnostics::buffer buf_a (dc);
+ diagnostics::buffer buf_b (dc);
rich_location rich_loc (line_table, UNKNOWN_LOCATION);
/* Run all of the selftests within this file. */
void
-diagnostic_format_sarif_cc_tests ()
+diagnostics_sarif_sink_cc_tests ()
{
test_sarif_array_of_unique_1 ();
test_sarif_array_of_unique_2 ();
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
-#ifndef GCC_DIAGNOSTIC_FORMAT_SARIF_H
-#define GCC_DIAGNOSTIC_FORMAT_SARIF_H
+#ifndef GCC_DIAGNOSTICS_SARIF_SINK_H
+#define GCC_DIAGNOSTICS_SARIF_SINK_H
#include "json.h"
-#include "diagnostic-format.h"
+#include "diagnostics/sink.h"
#include "diagnostics/output-file.h"
#include "diagnostics/logical-locations.h"
+namespace diagnostics {
+
+namespace digraphs {
+ class digraph;
+ class node;
+ class edge;
+}
+
/* Enum for choosing what format to serializing the generated SARIF into. */
enum class sarif_serialization_kind
};
extern diagnostics::output_file
-diagnostic_output_format_open_sarif_file (diagnostic_context &context,
- line_maps *line_maps,
- const char *base_file_name,
- enum sarif_serialization_kind serialization_kind);
-
-extern diagnostic_output_format &
-diagnostic_output_format_init_sarif_stderr (diagnostic_context &context,
- const line_maps *line_maps,
- bool formatted);
-extern diagnostic_output_format &
-diagnostic_output_format_init_sarif_file (diagnostic_context &context,
- line_maps *line_maps,
- bool formatted,
- const char *base_file_name);
-extern diagnostic_output_format &
-diagnostic_output_format_init_sarif_stream (diagnostic_context &context,
- const line_maps *line_maps,
- bool formatted,
- FILE *stream);
+open_sarif_output_file (diagnostic_context &context,
+ line_maps *line_maps,
+ const char *base_file_name,
+ enum sarif_serialization_kind serialization_kind);
+
+extern sink &
+init_sarif_stderr (diagnostic_context &context,
+ const line_maps *line_maps,
+ bool formatted);
+extern sink &
+init_sarif_file (diagnostic_context &context,
+ line_maps *line_maps,
+ bool formatted,
+ const char *base_file_name);
+extern sink &
+init_sarif_stream (diagnostic_context &context,
+ const line_maps *line_maps,
+ bool formatted,
+ FILE *stream);
/* Abstract base class for handling JSON output vs other kinds of
serialization of the json tree. */
bool m_state_graph;
};
-extern std::unique_ptr<diagnostic_output_format>
+extern std::unique_ptr<sink>
make_sarif_sink (diagnostic_context &context,
const line_maps &line_maps,
std::unique_ptr<sarif_serialization_format> serialization_format,
class sarif_builder;
class sarif_location_manager;
-namespace diagnostics {
-namespace digraphs {
- class digraph;
- class node;
- class edge;
-}}
-
/* Concrete subclass of json::object for SARIF property bags
(SARIF v2.1.0 section 3.8). */
};
extern std::unique_ptr<sarif_graph>
-make_sarif_graph (const diagnostics::digraphs::digraph &g,
+make_sarif_graph (const digraphs::digraph &g,
sarif_builder *builder,
sarif_location_manager *sarif_location_mgr);
extern std::unique_ptr<sarif_node>
-make_sarif_node (const diagnostics::digraphs::node &n,
+make_sarif_node (const digraphs::node &n,
sarif_builder *builder,
sarif_location_manager *sarif_location_mgr);
extern std::unique_ptr<sarif_edge>
-make_sarif_edge (const diagnostics::digraphs::edge &e,
+make_sarif_edge (const digraphs::edge &e,
sarif_builder *builder);
-#endif /* ! GCC_DIAGNOSTIC_FORMAT_SARIF_H */
+} // namespace diagnostics
+
+#endif /* ! GCC_DIAGNOSTICS_SARIF_SINK_H */
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
-#ifndef GCC_DIAGNOSTIC_FORMAT_H
-#define GCC_DIAGNOSTIC_FORMAT_H
+#ifndef GCC_DIAGNOSTICS_SINK_H
+#define GCC_DIAGNOSTICS_SINK_H
#include "diagnostic.h"
-class diagnostic_per_format_buffer;
+namespace diagnostics {
+
+class per_sink_buffer;
/* Abstract base class for a particular output format for diagnostics;
each value of -fdiagnostics-output-format= will have its own
implementation. */
-class diagnostic_output_format
+class sink
{
public:
- virtual ~diagnostic_output_format () {}
+ virtual ~sink () {}
virtual void dump (FILE *out, int indent) const;
e.g. for titles of HTML, for SARIF's artifact metadata. */
virtual void set_main_input_filename (const char *) {}
- /* Vfunc for making an appropriate diagnostic_per_format_buffer
+ /* Vfunc for making an appropriate per_sink_buffer
subclass for this format. */
- virtual std::unique_ptr<diagnostic_per_format_buffer>
- make_per_format_buffer () = 0;
+ virtual std::unique_ptr<per_sink_buffer>
+ make_per_sink_buffer () = 0;
- /* Vfunc to be called when call a diagnostic_buffer is set on
- a diagnostic_context, to update this format. The per_format_buffer
- will be one created by make_per_format_buffer above and thus be
+ /* Vfunc to be called when call a diagnostics::buffer is set on
+ a diagnostic_context, to update this format. The per_sink_buffer
+ will be one created by make_per_sink_buffer above and thus be
of the correct subclass. */
- virtual void set_buffer (diagnostic_per_format_buffer *) = 0;
+ virtual void set_buffer (per_sink_buffer *) = 0;
virtual void on_begin_group () = 0;
virtual void on_end_group () = 0;
virtual void on_report_verbatim (text_info &);
- virtual void on_diagram (const diagnostics::diagram &diag) = 0;
+ virtual void on_diagram (const diagram &diag) = 0;
virtual void after_diagnostic (const diagnostic_info &) = 0;
virtual bool machine_readable_stderr_p () const = 0;
virtual bool follows_reference_printer_p () const = 0;
virtual void update_printer () = 0;
virtual void
- report_global_digraph (const diagnostics::digraphs::lazy_digraph &) = 0;
+ report_global_digraph (const digraphs::lazy_digraph &) = 0;
diagnostic_context &get_context () const { return m_context; }
pretty_printer *get_printer () const { return m_printer.get (); }
void DEBUG_FUNCTION dump () const { dump (stderr, 0); }
protected:
- diagnostic_output_format (diagnostic_context &context)
+ sink (diagnostic_context &context)
: m_context (context),
m_printer (context.clone_printer ())
{}
};
extern void
-diagnostic_output_format_init (diagnostic_context &,
- const char *main_input_filename_,
- const char *base_file_name,
- enum diagnostics_output_format,
- bool json_formatting);
+output_format_init (diagnostic_context &,
+ const char *main_input_filename_,
+ const char *base_file_name,
+ enum diagnostics_output_format,
+ bool json_formatting);
+
+} // namespace diagnostics
-#endif /* ! GCC_DIAGNOSTIC_FORMAT_H */
+#endif /* ! GCC_DIAGNOSTICS_SINK_H */
default:
gcc_unreachable ();
case style::h1:
- // from diagnostic-format-html.cc: HTML_STYLE .linenum
+ // from diagnostics/html-sink.cc: HTML_STYLE .linenum
bgcolor = "#0088ce";
color = "white";
break;
case style::h2:
- // from diagnostic-format-html.cc: HTML_STYLE .events-hdr
+ // from diagnostics/html-sink.cc: HTML_STYLE .events-hdr
bgcolor = "#393f44"; // pf-black-800
color = "white";
break;
#include "diagnostics/paths.h"
#include "diagnostics/client-data-hooks.h"
#include "diagnostics/diagram.h"
-#include "diagnostic-format-text.h"
-#include "diagnostic-buffer.h"
+#include "diagnostics/text-sink.h"
+#include "diagnostics/buffering.h"
#include "text-art/theme.h"
/* Disable warnings about quoting issues in the pp_xxx calls below
# pragma GCC diagnostic ignored "-Wformat-diag"
#endif
-using namespace diagnostics;
+namespace diagnostics {
-/* Concrete buffering implementation subclass for JSON output. */
+/* Concrete buffering implementation subclass for text output. */
-class diagnostic_text_format_buffer : public diagnostic_per_format_buffer
+class text_sink_buffer : public per_sink_buffer
{
public:
- friend class diagnostic_text_output_format;
+ friend class text_sink;
- diagnostic_text_format_buffer (diagnostic_output_format &format);
+ text_sink_buffer (sink &sink_);
void dump (FILE *out, int indent) const final override;
bool empty_p () const final override;
- void move_to (diagnostic_per_format_buffer &dest) final override;
+ void move_to (per_sink_buffer &dest) final override;
void clear () final override;
void flush () final override;
private:
- diagnostic_output_format &m_format;
+ sink &m_sink;
output_buffer m_output_buffer;
};
-/* class diagnostic_text_format_buffer : public diagnostic_per_format_buffer. */
+/* class text_sink_buffer : public per_sink_buffer. */
-diagnostic_text_format_buffer::
-diagnostic_text_format_buffer (diagnostic_output_format &format)
-: m_format (format)
+text_sink_buffer::text_sink_buffer (sink &sink_)
+: m_sink (sink_)
{
m_output_buffer.m_flush_p = false;
}
void
-diagnostic_text_format_buffer::dump (FILE *out, int indent) const
+text_sink_buffer::dump (FILE *out, int indent) const
{
- fprintf (out, "%*sdiagnostic_text_format_buffer:\n", indent, "");
+ fprintf (out, "%*stext_sink_buffer:\n", indent, "");
m_output_buffer.dump (out, indent + 2);
}
bool
-diagnostic_text_format_buffer::empty_p () const
+text_sink_buffer::empty_p () const
{
return output_buffer_last_position_in_text (&m_output_buffer) == nullptr;
}
void
-diagnostic_text_format_buffer::move_to (diagnostic_per_format_buffer &base_dest)
+text_sink_buffer::move_to (per_sink_buffer &base_dest)
{
- diagnostic_text_format_buffer &dest
- = static_cast<diagnostic_text_format_buffer &> (base_dest);
+ text_sink_buffer &dest
+ = static_cast<text_sink_buffer &> (base_dest);
const char *str = output_buffer_formatted_text (&m_output_buffer);
output_buffer_append_r (&dest.m_output_buffer, str, strlen (str));
}
void
-diagnostic_text_format_buffer::clear ()
+text_sink_buffer::clear ()
{
- pretty_printer *const pp = m_format.get_printer ();
+ pretty_printer *const pp = m_sink.get_printer ();
output_buffer *const old_output_buffer = pp_buffer (pp);
pp_buffer (pp) = &m_output_buffer;
}
void
-diagnostic_text_format_buffer::flush ()
+text_sink_buffer::flush ()
{
- pretty_printer *const pp = m_format.get_printer ();
+ pretty_printer *const pp = m_sink.get_printer ();
output_buffer *const old_output_buffer = pp_buffer (pp);
pp_buffer (pp) = &m_output_buffer;
pp_buffer (pp) = old_output_buffer;
}
-/* class diagnostic_text_output_format : public diagnostic_output_format. */
+/* class diagnostics::text_sink : public diagnostics::sink. */
-diagnostic_text_output_format::~diagnostic_text_output_format ()
+text_sink::~text_sink ()
{
/* Some of the errors may actually have been warnings. */
if (m_context.diagnostic_count (DK_WERROR))
}
void
-diagnostic_text_output_format::dump (FILE *out, int indent) const
+text_sink::dump (FILE *out, int indent) const
{
- fprintf (out, "%*sdiagnostic_text_output_format\n", indent, "");
+ fprintf (out, "%*stext_sink\n", indent, "");
fprintf (out, "%*sm_follows_reference_printer: %s\n",
indent, "",
m_follows_reference_printer ? "true" : "false");
- diagnostic_output_format::dump (out, indent);
+ sink::dump (out, indent);
fprintf (out, "%*ssaved_output_buffer:\n", indent + 2, "");
if (m_saved_output_buffer)
m_saved_output_buffer->dump (out, indent + 4);
}
void
-diagnostic_text_output_format::set_buffer (diagnostic_per_format_buffer *base)
+text_sink::set_buffer (per_sink_buffer *base)
{
- diagnostic_text_format_buffer * const buffer
- = static_cast<diagnostic_text_format_buffer *> (base);
+ text_sink_buffer * const buffer
+ = static_cast<text_sink_buffer *> (base);
pretty_printer *const pp = get_printer ();
}
}
-std::unique_ptr<diagnostic_per_format_buffer>
-diagnostic_text_output_format::make_per_format_buffer ()
+std::unique_ptr<per_sink_buffer>
+text_sink::make_per_sink_buffer ()
{
- return std::make_unique<diagnostic_text_format_buffer> (*this);
+ return std::make_unique<text_sink_buffer> (*this);
}
-/* Implementation of diagnostic_output_format::on_report_diagnostic vfunc
+/* Implementation of diagnostics::sink::on_report_diagnostic vfunc
for GCC's standard textual output. */
void
-diagnostic_text_output_format::
-on_report_diagnostic (const diagnostic_info &diagnostic,
- diagnostic_t orig_diag_kind)
+text_sink::on_report_diagnostic (const diagnostic_info &diagnostic,
+ diagnostic_t orig_diag_kind)
{
pretty_printer *pp = get_printer ();
}
void
-diagnostic_text_output_format::on_report_verbatim (text_info &text)
+text_sink::on_report_verbatim (text_info &text)
{
pp_format_verbatim (get_printer (), &text);
pp_newline_and_flush (get_printer ());
}
void
-diagnostic_text_output_format::on_diagram (const diagnostics::diagram &d)
+text_sink::on_diagram (const diagnostics::diagram &d)
{
pretty_printer *const pp = get_printer ();
}
void
-diagnostic_text_output_format::
+text_sink::
after_diagnostic (const diagnostic_info &diagnostic)
{
if (const paths::path *path = diagnostic.richloc->get_path ())
The caller is responsible for freeing the memory. */
char *
-diagnostic_text_output_format::
-build_prefix (const diagnostic_info &diagnostic) const
+text_sink::build_prefix (const diagnostic_info &diagnostic) const
{
gcc_assert (diagnostic.kind < DK_LAST_DIAGNOSTIC_KIND);
/* Same as build_prefix, but only the source FILE is given. */
char *
-diagnostic_text_output_format::file_name_as_prefix (const char *f) const
+text_sink::file_name_as_prefix (const char *f) const
{
pretty_printer *const pp = get_printer ();
const char *locus_cs
The caller is responsible for freeing the memory. */
char *
-diagnostic_text_output_format::build_indent_prefix (bool with_bullet) const
+text_sink::build_indent_prefix (bool with_bullet) const
{
if (!m_show_nesting)
return xstrdup ("");
/* Add a purely textual note with text GMSGID and with LOCATION. */
void
-diagnostic_text_output_format::append_note (location_t location,
+text_sink::append_note (location_t location,
const char * gmsgid, ...)
{
diagnostic_context *context = &get_context ();
}
bool
-diagnostic_text_output_format::follows_reference_printer_p () const
+text_sink::follows_reference_printer_p () const
{
return m_follows_reference_printer;
}
void
-diagnostic_text_output_format::
-update_printer ()
+text_sink::update_printer ()
{
pretty_printer *copy_from_pp
= (m_follows_reference_printer
description of the security issue. */
void
-diagnostic_text_output_format::print_any_cwe (const diagnostic_info &diagnostic)
+text_sink::print_any_cwe (const diagnostic_info &diagnostic)
{
if (!diagnostic.metadata)
return;
with any URL provided by the rule. */
void
-diagnostic_text_output_format::
-print_any_rules (const diagnostic_info &diagnostic)
+text_sink::print_any_rules (const diagnostic_info &diagnostic)
{
if (!diagnostic.metadata)
return;
Subroutine of diagnostic_context::report_diagnostic. */
void
-diagnostic_text_output_format::
-print_option_information (const diagnostic_info &diagnostic,
- diagnostic_t orig_diag_kind)
+text_sink::print_option_information (const diagnostic_info &diagnostic,
+ diagnostic_t orig_diag_kind)
{
if (char *option_text
= m_context.make_option_name (diagnostic.option_id,
/* Only dump the "In file included from..." stack once for each file. */
bool
-diagnostic_text_output_format::includes_seen_p (const line_map_ordinary *map)
+text_sink::includes_seen_p (const line_map_ordinary *map)
{
/* No include path for main. */
if (MAIN_FILE_P (map))
}
label_text
-diagnostic_text_output_format::
-get_location_text (const expanded_location &s) const
+text_sink::get_location_text (const expanded_location &s) const
{
diagnostic_column_policy column_policy (get_context ());
return column_policy.get_location_text (s,
}
void
-diagnostic_text_output_format::report_current_module (location_t where)
+text_sink::report_current_module (location_t where)
{
pretty_printer *pp = get_printer ();
const line_map_ordinary *map = nullptr;
}
void
-default_diagnostic_text_starter (diagnostic_text_output_format &text_output,
- const diagnostic_info *diagnostic)
+default_text_starter (text_sink &text_output,
+ const diagnostic_info *diagnostic)
{
text_output.report_current_module (diagnostic_location (diagnostic));
pretty_printer *const pp = text_output.get_printer ();
}
void
-default_diagnostic_text_finalizer (diagnostic_text_output_format &text_output,
- const diagnostic_info *diagnostic,
- diagnostic_t)
+default_text_finalizer (text_sink &text_output,
+ const diagnostic_info *diagnostic,
+ diagnostic_t)
{
pretty_printer *const pp = text_output.get_printer ();
char *saved_prefix = pp_take_prefix (pp);
#if __GNUC__ >= 10
# pragma GCC diagnostic pop
#endif
+
+} // namespace diagnostics
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
-#ifndef GCC_DIAGNOSTIC_FORMAT_TEXT_H
-#define GCC_DIAGNOSTIC_FORMAT_TEXT_H
+#ifndef GCC_DIAGNOSTICS_TEXT_SINK_H
+#define GCC_DIAGNOSTICS_TEXT_SINK_H
-#include "diagnostic-format.h"
+#include "diagnostics/sink.h"
-/* Subclass of diagnostic_output_format for classic text-based output
+namespace diagnostics {
+
+/* Subclass of diagnostics::sink for classic text-based output
to stderr.
Uses diagnostic_context.m_text_callbacks to provide client-specific
textual output (e.g. include paths, macro expansions, etc). */
-class diagnostic_text_output_format : public diagnostic_output_format
+class text_sink : public sink
{
public:
- diagnostic_text_output_format (diagnostic_context &context,
- diagnostic_source_printing_options *source_printing = nullptr,
- bool follows_reference_printer = false)
- : diagnostic_output_format (context),
+ text_sink (diagnostic_context &context,
+ diagnostic_source_printing_options *source_printing = nullptr,
+ bool follows_reference_printer = false)
+ : sink (context),
m_saved_output_buffer (nullptr),
m_column_policy (context),
m_last_module (nullptr),
m_show_nesting (false),
m_show_nesting_levels (false)
{}
- ~diagnostic_text_output_format ();
+ ~text_sink ();
void dump (FILE *out, int indent) const override;
- std::unique_ptr<diagnostic_per_format_buffer>
- make_per_format_buffer () final override;
- void set_buffer (diagnostic_per_format_buffer *) final override;
+ std::unique_ptr<per_sink_buffer>
+ make_per_sink_buffer () final override;
+ void set_buffer (per_sink_buffer *) final override;
void on_begin_group () override {}
void on_end_group () override {}
void on_report_diagnostic (const diagnostic_info &,
diagnostic_t orig_diag_kind) override;
void on_report_verbatim (text_info &) final override;
- void on_diagram (const diagnostics::diagram &d) override;
+ void on_diagram (const diagram &d) override;
void after_diagnostic (const diagnostic_info &) override;
bool machine_readable_stderr_p () const final override
{
void update_printer () override;
void
- report_global_digraph (const diagnostics::digraphs::lazy_digraph &) final override
+ report_global_digraph (const digraphs::lazy_digraph &) final override
{
// no-op for text
}
char *build_indent_prefix (bool with_bullet) const;
- void print_path (const diagnostics::paths::path &path);
+ void print_path (const paths::path &path);
bool show_column_p () const { return get_context ().m_show_column; }
bool m_show_nesting_levels;
};
-#endif /* ! GCC_DIAGNOSTIC_FORMAT_TEXT_H */
+} // namespace diagnostics
+
+#endif /* ! GCC_DIAGNOSTICS_TEXT_SINK_H */
#include "diagnostic.h"
#include "diagnostic-color.h"
#include "tree-diagnostic.h" /* tree_diagnostics_defaults */
-#include "diagnostic-format-text.h"
+#include "diagnostics/text-sink.h"
static int suppress_errors = 0;
static bool buffered_p;
static gfc_error_buffer *error_buffer;
-static diagnostic_buffer *pp_error_buffer, *pp_warning_buffer;
+static diagnostics::buffer *pp_error_buffer, *pp_warning_buffer;
gfc_error_buffer::gfc_error_buffer ()
: flag (false), buffer (*global_dc)
it to global_dc. */
static void
-gfc_clear_diagnostic_buffer (diagnostic_buffer *this_buffer)
+gfc_clear_diagnostic_buffer (diagnostics::buffer *this_buffer)
{
gcc_assert (this_buffer);
global_dc->clear_diagnostic_buffer (*this_buffer);
diagnostic_info diagnostic;
rich_location rich_loc (line_table, UNKNOWN_LOCATION);
- diagnostic_buffer *old_buffer = global_dc->get_diagnostic_buffer ();
+ diagnostics::buffer *old_buffer = global_dc->get_diagnostic_buffer ();
gcc_assert (!old_buffer);
gfc_clear_diagnostic_buffer (pp_warning_buffer);
[locus of primary range]: Error: Some error at (1) and (2)
*/
static void
-gfc_diagnostic_text_starter (diagnostic_text_output_format &text_output,
+gfc_diagnostic_text_starter (diagnostics::text_sink &text_output,
const diagnostic_info *diagnostic)
{
diagnostic_context *const context = &text_output.get_context ();
static void
-gfc_diagnostic_text_finalizer (diagnostic_text_output_format &text_output,
+gfc_diagnostic_text_finalizer (diagnostics::text_sink &text_output,
const diagnostic_info *diagnostic ATTRIBUTE_UNUSED,
diagnostic_t orig_diag_kind ATTRIBUTE_UNUSED)
{
diagnostic_info diagnostic;
rich_location richloc (line_table, UNKNOWN_LOCATION);
- diagnostic_buffer *old_buffer = global_dc->get_diagnostic_buffer ();
+ diagnostics::buffer *old_buffer = global_dc->get_diagnostic_buffer ();
gcc_assert (!old_buffer);
gfc_clear_diagnostic_buffer (pp_error_buffer);
gfc_move_error_buffer_from_to (gfc_error_buffer * buffer_from,
gfc_error_buffer * buffer_to)
{
- diagnostic_buffer * from = &(buffer_from->buffer);
- diagnostic_buffer * to = &(buffer_to->buffer);
+ diagnostics::buffer * from = &(buffer_from->buffer);
+ diagnostics::buffer * to = &(buffer_to->buffer);
buffer_to->flag = buffer_from->flag;
buffer_from->flag = false;
global_dc->set_format_decoder (gfc_format_decoder);
global_dc->m_source_printing.caret_chars[0] = '1';
global_dc->m_source_printing.caret_chars[1] = '2';
- pp_warning_buffer = new diagnostic_buffer (*global_dc);
+ pp_warning_buffer = new diagnostics::buffer (*global_dc);
error_buffer = new gfc_error_buffer ();
pp_error_buffer = &(error_buffer->buffer);
}
#define gfc_syntax_error(ST) \
gfc_error ("Syntax error in %s statement at %C", gfc_ascii_statement (ST));
-#include "diagnostic-buffer.h" /* For diagnostic_buffer. */
+#include "diagnostics/buffering.h" /* For diagnostics::buffer. */
struct gfc_error_buffer
{
bool flag;
- diagnostic_buffer buffer;
+ diagnostics::buffer buffer;
gfc_error_buffer();
};
#include "opt-suggestions.h"
#include "gcc.h"
#include "diagnostic.h"
-#include "diagnostic-format.h"
+#include "diagnostics/sink.h"
#include "pretty-print-urlifier.h"
#include "flags.h"
#include "opts.h"
const char *basename = (opts->x_dump_base_name ? opts->x_dump_base_name
: opts->x_main_input_basename);
gcc_assert (dc);
- diagnostic_output_format_init (*dc,
- opts->x_main_input_filename, basename,
- (enum diagnostics_output_format)value,
- opts->x_flag_diagnostics_json_formatting);
+ diagnostics::output_format_init (*dc,
+ opts->x_main_input_filename, basename,
+ (enum diagnostics_output_format)value,
+ opts->x_flag_diagnostics_json_formatting);
break;
}
#include "attribs.h"
#include "cgraph.h"
#include "target.h"
-#include "diagnostic-format-text.h"
+#include "diagnostics/text-sink.h"
#include "print-tree.h"
#include <mpfr.h>
LAST_GGC_ROOT_TAB
};
-/* Subclass of diagnostic_output_format for libgccjit: like text
+/* Subclass of diagnostics::text_sink for libgccjit: like text
output, but capture the message and call add_diagnostic with it
on the active playback context. */
-class jit_diagnostic_listener : public diagnostic_text_output_format
+class jit_diagnostic_listener : public diagnostics::text_sink
{
public:
jit_diagnostic_listener (diagnostic_context &dc,
gcc::jit::playback::context &playback_ctxt)
- : diagnostic_text_output_format (dc),
+ : diagnostics::text_sink (dc),
m_playback_ctxt (playback_ctxt)
{
}
JIT_LOG_SCOPE (gcc::jit::active_playback_ctxt->get_logger ());
/* Let the text output format do most of the work. */
- diagnostic_text_output_format::on_report_diagnostic (info, orig_diag_kind);
+ diagnostics::text_sink::on_report_diagnostic (info, orig_diag_kind);
const char *text = pp_formatted_text (get_printer ());
/* Implementation of "begin_diagnostic". */
static void
-jit_begin_diagnostic (diagnostic_text_output_format &,
+jit_begin_diagnostic (diagnostics::text_sink &,
const diagnostic_info */*diagnostic*/)
{
gcc_assert (gcc::jit::active_playback_ctxt);
/* Implementation of "end_diagnostic". */
static void
-jit_end_diagnostic (diagnostic_text_output_format &,
+jit_end_diagnostic (diagnostics::text_sink &,
const diagnostic_info *,
diagnostic_t)
{
= std::make_unique<jit_diagnostic_listener>
(*global_dc,
*gcc::jit::active_playback_ctxt);
- global_dc->set_output_format (std::move (sink));
+ global_dc->set_sink (std::move (sink));
build_common_tree_nodes (flag_signed_char);
extern const char *lhd_decl_printable_name (tree, int);
extern const char *lhd_dwarf_name (tree, int);
extern int lhd_types_compatible_p (tree, tree);
-extern void lhd_print_error_function (diagnostic_text_output_format &,
+extern void lhd_print_error_function (diagnostics::text_sink &,
const char *,
const struct diagnostic_info *);
extern void lhd_set_decl_assembler_name (tree decl);
#include "stor-layout.h"
#include "cgraph.h"
#include "debug.h"
-#include "diagnostic-format-text.h"
+#include "diagnostics/text-sink.h"
/* Do nothing; in many cases the default hook. */
/* The default function to print out name of current function that caused
an error. */
void
-lhd_print_error_function (diagnostic_text_output_format &text_output,
+lhd_print_error_function (diagnostics::text_sink &text_output,
const char *file,
const diagnostic_info *diagnostic)
{
/* Called by diagnostic_report_current_function to print out function name
for textual diagnostic output. */
- void (*print_error_function) (diagnostic_text_output_format &,
+ void (*print_error_function) (diagnostics::text_sink &,
const char *,
const struct diagnostic_info *);
#include "diagnostics/metadata.h"
#include "diagnostics/paths.h"
#include "diagnostics/client-data-hooks.h"
-#include "diagnostic-format-sarif.h"
-#include "diagnostic-format-text.h"
+#include "diagnostics/sarif-sink.h"
+#include "diagnostics/text-sink.h"
#include "diagnostics/output-spec.h"
#include "diagnostics/digraphs.h"
#include "diagnostics/state-graphs.h"
set_colorize (enum diagnostic_colorize colorize);
static void
- text_starter (diagnostic_text_output_format &text_output,
+ text_starter (diagnostics::text_sink &text_output,
const diagnostic_info *diagnostic);
private:
- diagnostic_text_output_format *m_inner_sink; // borrowed from dc
+ diagnostics::text_sink *m_inner_sink; // borrowed from dc
diagnostic_source_printing_options m_source_printing;
};
sarif_sink (diagnostic_manager &mgr,
FILE *dst_stream,
const diagnostic_file *main_input_file,
- const sarif_generation_options &sarif_gen_opts);
+ const diagnostics::sarif_generation_options &sarif_gen_opts);
};
struct diagnostic_message_buffer
const char * maybe_get_sarif_source_language (const char *filename)
const final override;
- void add_sarif_invocation_properties (sarif_object &invocation_obj)
+ void
+ add_sarif_invocation_properties (diagnostics::sarif_object &invocation_obj)
const final override;
private:
void
impl_diagnostic_client_data_hooks::
-add_sarif_invocation_properties (sarif_object &) const
+add_sarif_invocation_properties (diagnostics::sarif_object &) const
{
// No-op.
}
m_source_printing (mgr.get_dc ().m_source_printing)
{
auto inner_sink
- = std::make_unique<diagnostic_text_output_format> (mgr.get_dc (),
+ = std::make_unique<diagnostics::text_sink> (mgr.get_dc (),
&m_source_printing);
inner_sink->get_printer ()->set_output_stream (dst_stream);
m_inner_sink = inner_sink.get ();
}
void
-diagnostic_text_sink::text_starter (diagnostic_text_output_format &text_output,
+diagnostic_text_sink::text_starter (diagnostics::text_sink &text_output,
const diagnostic_info *info)
{
gcc_assert (info->x_data);
/* class sarif_sink : public sink. */
-sarif_sink::sarif_sink (diagnostic_manager &mgr,
- FILE *dst_stream,
- const diagnostic_file *main_input_file,
- const sarif_generation_options &sarif_gen_opts)
+sarif_sink::
+sarif_sink (diagnostic_manager &mgr,
+ FILE *dst_stream,
+ const diagnostic_file *main_input_file,
+ const diagnostics::sarif_generation_options &sarif_gen_opts)
: sink (mgr)
{
diagnostics::output_file output_file (dst_stream, false,
label_text::borrow ("sarif_sink"));
- auto serialization = std::make_unique<sarif_serialization_format_json> (true);
+ auto serialization
+ = std::make_unique<diagnostics::sarif_serialization_format_json> (true);
auto inner_sink = make_sarif_sink (mgr.get_dc (),
*mgr.get_line_table (),
std::move (serialization),
FAIL_IF_NULL (dst_stream);
FAIL_IF_NULL (main_input_file);
- sarif_generation_options sarif_gen_opts;
+ diagnostics::sarif_generation_options sarif_gen_opts;
switch (version)
{
default:
__func__, (int)version);
abort ();
case DIAGNOSTIC_SARIF_VERSION_2_1_0:
- sarif_gen_opts.m_version = sarif_version::v2_1_0;
+ sarif_gen_opts.m_version = diagnostics::sarif_version::v2_1_0;
break;
case DIAGNOSTIC_SARIF_VERSION_2_2_PRERELEASE:
- sarif_gen_opts.m_version = sarif_version::v2_2_prerelease_2024_08_08;
+ sarif_gen_opts.m_version
+ = diagnostics::sarif_version::v2_2_prerelease_2024_08_08;
break;
}
diagnostic_initialize (&dc, 0);
dc.m_show_column = true;
- diagnostic_text_output_format text_format (dc);
- label_text loc_text = text_format.get_location_text (exp_loc);
+ diagnostics::text_sink text_output (dc);
+ label_text loc_text = text_output.get_location_text (exp_loc);
fprintf (out, "%s", loc_text.get ());
diagnostic_finish (&dc);
return;
sink->set_main_input_filename (opts.x_main_input_filename);
- dc.set_output_format (std::move (sink));
+ dc.set_sink (std::move (sink));
}
#include "spellcheck.h"
#include "opt-suggestions.h"
#include "diagnostic-color.h"
-#include "diagnostic-format.h"
+#include "diagnostics/sink.h"
#include "version.h"
#include "selftest.h"
#include "file-prefix-map.h"
const char *basename = (opts->x_dump_base_name ? opts->x_dump_base_name
: opts->x_main_input_basename);
gcc_assert (dc);
- diagnostic_output_format_init (*dc,
- opts->x_main_input_filename, basename,
- (enum diagnostics_output_format)value,
- opts->x_flag_diagnostics_json_formatting);
+ diagnostics::output_format_init (*dc,
+ opts->x_main_input_filename, basename,
+ (enum diagnostics_output_format)value,
+ opts->x_flag_diagnostics_json_formatting);
break;
}
namespace Resolver {
void ATTRIBUTE_NORETURN
-funny_ice_text_finalizer (diagnostic_text_output_format &text_output,
+funny_ice_text_finalizer (diagnostics::text_sink &text_output,
const diagnostic_info *diagnostic,
diagnostic_t diag_kind)
{
gcc_assert (diag_kind == DK_ICE_NOBT);
- default_diagnostic_text_finalizer (text_output, diagnostic, diag_kind);
+ diagnostics::default_text_finalizer (text_output, diagnostic, diag_kind);
fnotice (stderr, "You have broken GCC Rust. This is a feature.\n");
exit (ICE_EXIT_CODE);
}
the default bug reporting instructions, as there is no bug to report. */
void ATTRIBUTE_NORETURN
-funny_ice_text_finalizer (diagnostic_text_output_format &text_output,
+funny_ice_text_finalizer (diagnostics::text_sink &text_output,
const diagnostic_info *diagnostic,
diagnostic_t diag_kind);
#include "system.h"
#include "coretypes.h"
#include "diagnostic.h"
-#include "diagnostic-format.h"
+#include "diagnostics/sink.h"
#include "selftest.h"
#include "selftest-diagnostic.h"
diagnostic_start_span (this) = start_span_cb;
m_source_printing.min_margin_width = 6;
m_source_printing.max_width = 80;
- pp_buffer (get_output_format (0).get_printer ())->m_flush_p = false;
+ pp_buffer (get_sink (0).get_printer ())->m_flush_p = false;
}
test_diagnostic_context::~test_diagnostic_context ()
expanded_location exploc)
{
exploc.file = "FILENAME";
- default_diagnostic_start_span_fn<to_text> (loc_policy, sink, exploc);
+ diagnostics::default_start_span_fn<to_text> (loc_policy, sink, exploc);
}
bool
rely on. */
diagnostic_color_cc_tests ();
diagnostic_show_locus_cc_tests ();
- diagnostic_format_html_cc_tests ();
- diagnostic_format_sarif_cc_tests ();
+ diagnostics_html_sink_cc_tests ();
+ diagnostics_sarif_sink_cc_tests ();
diagnostics_digraphs_cc_tests ();
diagnostics_output_spec_cc_tests ();
diagnostics_state_graphs_cc_tests ();
extern void convert_cc_tests ();
extern void dbgcnt_cc_tests ();
extern void diagnostic_color_cc_tests ();
-extern void diagnostic_format_html_cc_tests ();
-extern void diagnostic_format_sarif_cc_tests ();
extern void diagnostic_show_locus_cc_tests ();
extern void diagnostics_digraphs_cc_tests ();
+extern void diagnostics_html_sink_cc_tests ();
extern void diagnostics_lazy_paths_cc_tests ();
extern void diagnostics_output_spec_cc_tests ();
extern void diagnostics_paths_output_cc_tests ();
+extern void diagnostics_sarif_sink_cc_tests ();
extern void diagnostics_selftest_logical_locations_cc_tests ();
extern void diagnostics_state_graphs_cc_tests ();
extern void digraph_cc_tests ();
#include "plugin-version.h"
#include "c-family/c-common.h"
#include "diagnostic.h"
-#include "diagnostic-format-text.h"
+#include "diagnostics/text-sink.h"
#include "context.h"
int plugin_is_GPL_compatible;
expected output. */
void
-test_diagnostic_text_starter (diagnostic_text_output_format &text_output,
+test_diagnostic_text_starter (diagnostics::text_sink &text_output,
const diagnostic_info *diagnostic)
{
pp_set_prefix (text_output.get_printer (), xstrdup ("PREFIX: "));
pp_newline (pp);
}
-/* Custom output format subclass. */
+/* Custom text_sink subclass. */
-class test_output_format : public diagnostic_text_output_format
+class custom_test_sink : public diagnostics::text_sink
{
public:
- test_output_format (diagnostic_context &context)
- : diagnostic_text_output_format (context)
+ custom_test_sink (diagnostic_context &context)
+ : diagnostics::text_sink (context)
{}
void on_begin_group () final override
diagnostic_text_starter (global_dc) = test_diagnostic_text_starter;
diagnostic_start_span (global_dc) = test_diagnostic_start_span_fn;
- global_dc->set_output_format
- (::std::make_unique<test_output_format> (*global_dc));
+ global_dc->set_sink (::std::make_unique<custom_test_sink> (*global_dc));
pass_info.pass = new pass_test_groups (g);
pass_info.reference_pass_name = "*warn_function_noreturn";
#include "print-tree.h"
#include "gcc-rich-location.h"
#include "text-range-label.h"
-#include "diagnostic-format-text.h"
+#include "diagnostics/text-sink.h"
int plugin_is_GPL_compatible;
/* We want to verify the colorized output of diagnostic_show_locus,
but turning on colorization for everything confuses "dg-warning" etc.
Hence we special-case it within this plugin by using this modified
- version of default_diagnostic_text_finalizer, which, if "color" is
+ version of diagnostics::default_text_finalizer, which, if "color" is
passed in as a plugin argument turns on colorization, but just
for diagnostic_show_locus. */
static void
-custom_diagnostic_text_finalizer (diagnostic_text_output_format &text_output,
+custom_diagnostic_text_finalizer (diagnostics::text_sink &text_output,
const diagnostic_info *diagnostic,
diagnostic_t)
{
#include "coretypes.h"
#include "spellcheck.h"
#include "diagnostic.h"
-#include "diagnostic-format-text.h"
+#include "diagnostics/text-sink.h"
int plugin_is_GPL_compatible;
static diagnostic_text_finalizer_fn original_text_finalizer = NULL;
static void
-verify_unpacked_ranges (diagnostic_text_output_format &text_output,
+verify_unpacked_ranges (diagnostics::text_sink &text_output,
const diagnostic_info *diagnostic,
diagnostic_t orig_diag_kind)
{
}
static void
-verify_no_columns (diagnostic_text_output_format &text_output,
+verify_no_columns (diagnostics::text_sink &text_output,
const diagnostic_info *diagnostic,
diagnostic_t orig_diag_kind)
{
#include "diagnostic.h"
#include "tree-logical-location.h"
#include "diagnostics/client-data-hooks.h"
-#include "diagnostic-format-sarif.h"
+#include "diagnostics/sarif-sink.h"
#include "langhooks.h"
#include "plugin.h"
#include "timevar.h"
}
void
- add_sarif_invocation_properties (sarif_object &invocation_obj)
+ add_sarif_invocation_properties (diagnostics::sarif_object &invocation_obj)
const final override
{
if (g_timer)
if (auto timereport_val = g_timer->make_json ())
{
- sarif_property_bag &bag_obj
+ auto &bag_obj
= invocation_obj.get_or_create_properties ();
bag_obj.set ("gcc/timeReport", std::move (timereport_val));
#include "diagnostics/client-data-hooks.h"
#include "langhooks.h"
#include "intl.h"
-#include "diagnostic-format-text.h"
+#include "diagnostics/text-sink.h"
/* Prints out, if necessary, the name of the current function
that caused an error. */
void
-diagnostic_report_current_function (diagnostic_text_output_format &text_output,
+diagnostic_report_current_function (diagnostics::text_sink &text_output,
const diagnostic_info *diagnostic)
{
location_t loc = diagnostic_location (diagnostic);
}
static void
-default_tree_diagnostic_text_starter (diagnostic_text_output_format &text_output,
+default_tree_diagnostic_text_starter (diagnostics::text_sink &text_output,
const diagnostic_info *diagnostic)
{
pretty_printer *const pp = text_output.get_printer ();
tree_diagnostics_defaults (diagnostic_context *context)
{
diagnostic_text_starter (context) = default_tree_diagnostic_text_starter;
- diagnostic_text_finalizer (context) = default_diagnostic_text_finalizer;
+ diagnostic_text_finalizer (context) = diagnostics::default_text_finalizer;
context->set_format_decoder (default_tree_printer);
context->set_set_locations_callback (set_inlining_locations);
context->set_client_data_hooks (make_compiler_data_hooks ());
#include "diagnostic.h"
#include "langhooks.h"
#include "langhooks-def.h"
-#include "diagnostic-format-text.h"
+#include "diagnostics/text-sink.h"
#include "gcc-interface.h"
// This is put into the lang hooks when the plugin starts.
static void
-plugin_print_error_function (diagnostic_text_output_format &text_output,
+plugin_print_error_function (diagnostics::text_sink &text_output,
const char *file,
const diagnostic_info *diagnostic)
{
projects / thirdparty / gcc.git / commitdiff
