namespace boost {
namespace parser {
struct callback_error_handler;
struct rethrow_error_handler;
struct vs_output_error_handler;
template<typename Iter, typename Sentinel>
std::ostream &
write_formatted_message(std::ostream &, std::string_view, Iter, Iter,
Sentinel, std::string_view, int64_t = 80,
int64_t = 40);
template<typename Iter, typename Sentinel>
std::ostream &
write_formatted_expectation_failure_error_message(std::ostream &,
std::string_view,
Iter, Sentinel,
parse_error< Iter > const &,
int64_t = 80,
int64_t = 40);
template<typename Iter>
line_position< Iter > find_line_position(Iter, Iter);
template<typename Iter, typename Sentinel>
Iter find_line_end(Iter, Sentinel);
}
}
namespace boost {
namespace parser {
struct default_error_handler;
template<typename Iter> struct line_position;
template<typename Iter> struct parse_error;
struct stream_error_handler;
enum error_handler_result;
enum diagnostic_kind;
template<typename Iter, typename Sentinel>
std::ostream &
write_formatted_message(std::ostream &, std::wstring_view, Iter, Iter,
Sentinel, std::string_view, int64_t = 80,
int64_t = 40);
template<typename Iter, typename Sentinel>
std::ostream &
write_formatted_expectation_failure_error_message(std::ostream &,
std::wstring_view,
Iter, Sentinel,
parse_error< Iter > const &,
int64_t = 80,
int64_t = 40);
}
}
BOOST_PARSER_DEFINE_RULES(...)
namespace boost {
namespace parser {
template<typename DelimiterParser> struct delimiter_directive;
template<template< class > class Parser> struct directive;
template<typename Predicate> struct if_directive;
struct merge_directive;
struct none;
template<typename MinType, typename MaxType> struct repeat_directive;
struct separate_directive;
template<typename SkipParser = unspecified> struct skip_directive;
template<typename T> struct symbols;
template<typename F> struct transform_directive;
enum trace;
unspecified _p;
int64_t const Inf;
directive< omit_parser > omit;
directive< raw_parser > raw;
directive< string_view_parser > string_view;
directive< lexeme_parser > lexeme;
directive< no_case_parser > no_case;
skip_directive skip;
merge_directive merge;
separate_directive separate;
unspecified eps;
parser_interface< eoi_parser > eoi;
unspecified char_;
unspecified cp;
unspecified cu;
parser_interface< quoted_string_parser<> > quoted_string;
parser_interface< ws_parser< true, false > > eol;
parser_interface< ws_parser< false, false > > ws;
parser_interface< ws_parser< false, true > > blank;
parser_interface< digit_parser > digit;
unspecified hex_digit;
unspecified control;
unspecified punct;
unspecified symb;
unspecified lower;
unspecified upper;
parser_interface< bool_parser > bool_;
parser_interface< uint_parser< unsigned int, 2 > > bin;
parser_interface< uint_parser< unsigned int, 8 > > oct;
parser_interface< uint_parser< unsigned int, 16 > > hex;
parser_interface< uint_parser< unsigned short > > ushort_;
parser_interface< uint_parser< unsigned int > > uint_;
parser_interface< uint_parser< unsigned long > > ulong_;
parser_interface< uint_parser< unsigned long long > > ulong_long;
parser_interface< int_parser< short > > short_;
parser_interface< int_parser< int > > int_;
parser_interface< int_parser< long > > long_;
parser_interface< int_parser< long long > > long_long;
parser_interface< float_parser< float > > float_;
parser_interface< float_parser< double > > double_;
template<typename Parser, typename GlobalState, typename ErrorHandler>
auto with_globals(unspecified, GlobalState &);
template<typename Parser, typename GlobalState, typename ErrorHandler>
auto with_error_handler(parser_interface< Parser, GlobalState, default_error_handler > const &,
ErrorHandler &);
template<typename T> repeat_directive< T, T > repeat(T);
template<typename MinType, typename MaxType>
repeat_directive< MinType, MaxType > repeat(MinType, MaxType);
template<typename DelimiterParser>
delimiter_directive< DelimiterParser >
delimiter(parser_interface< DelimiterParser >);
template<typename F> auto transform(F);
template<typename Attribute> auto attr(Attribute);
auto lit(char);
auto lit(char8_t);
auto lit(char32_t);
template<parsable_range_like R> auto string(R &&);
template<parsable_range_like R> auto lit(R &&);
template<typename Predicate> auto if_(Predicate);
template<typename T> auto switch_(T);
template<typename Parser>
auto operator>>(char, parser_interface< Parser >);
template<typename Parser>
auto operator>>(char32_t, parser_interface< Parser >);
template<parsable_range_like R, typename Parser>
auto operator>>(R &&, parser_interface< Parser >);
template<typename Parser> auto operator>(char, parser_interface< Parser >);
template<typename Parser>
auto operator>(char32_t, parser_interface< Parser >);
template<parsable_range_like R, typename Parser>
auto operator>(R &&, parser_interface< Parser >);
template<typename Parser> auto operator|(char, parser_interface< Parser >);
template<typename Parser>
auto operator|(char32_t, parser_interface< Parser >);
template<parsable_range_like R, typename Parser>
auto operator|(R &&, parser_interface< Parser >);
template<typename Parser> auto operator-(char, parser_interface< Parser >);
template<typename Parser>
auto operator-(char32_t, parser_interface< Parser >);
template<parsable_range_like R, typename Parser>
auto operator-(R &&, parser_interface< Parser >);
template<typename Parser> auto operator%(char, parser_interface< Parser >);
template<typename Parser>
auto operator%(char32_t, parser_interface< Parser >);
template<parsable_range_like R, typename Parser>
auto operator%(R &&, parser_interface< Parser >);
template<parsable_iter I, std::sentinel_for< I > S, typename Parser,
typename GlobalState,
error_handler< I, S, GlobalState > ErrorHandler, typename Attr>
bool prefix_parse(I &, S,
parser_interface< Parser, GlobalState, ErrorHandler > const &,
Attr &, trace = trace::off);
template<parsable_range R, typename Parser, typename GlobalState,
typename ErrorHandler, typename Attr>
bool parse(R const &,
parser_interface< Parser, GlobalState, ErrorHandler > const &,
Attr &, trace = trace::off);
template<parsable_iter I, std::sentinel_for< I > S, typename Parser,
typename GlobalState,
error_handler< I, S, GlobalState > ErrorHandler>
auto prefix_parse(I &, S,
parser_interface< Parser, GlobalState, ErrorHandler > const &,
trace = trace::off);
template<parsable_range R, typename Parser, typename GlobalState,
typename ErrorHandler>
auto parse(R const &,
parser_interface< Parser, GlobalState, ErrorHandler > const &,
trace = trace::off);
template<parsable_iter I, std::sentinel_for< I > S, typename Parser,
typename GlobalState,
error_handler< I, S, GlobalState > ErrorHandler,
typename SkipParser, typename Attr>
bool prefix_parse(I &, S,
parser_interface< Parser, GlobalState, ErrorHandler > const &,
parser_interface< SkipParser > const &, Attr &,
trace = trace::off);
template<parsable_range R, typename Parser, typename GlobalState,
typename ErrorHandler, typename SkipParser, typename Attr>
bool parse(R const &,
parser_interface< Parser, GlobalState, ErrorHandler > const &,
parser_interface< SkipParser > const &, Attr &,
trace = trace::off);
template<parsable_iter I, std::sentinel_for< I > S, typename Parser,
typename GlobalState,
error_handler< I, S, GlobalState > ErrorHandler,
typename SkipParser>
auto prefix_parse(I &, S,
parser_interface< Parser, GlobalState, ErrorHandler > const &,
parser_interface< SkipParser > const &,
trace = trace::off);
template<parsable_range R, typename Parser, typename GlobalState,
typename ErrorHandler, typename SkipParser>
auto parse(R const &,
parser_interface< Parser, GlobalState, ErrorHandler > const &,
parser_interface< SkipParser > const &, trace = trace::off);
template<parsable_iter I, std::sentinel_for< I > S, typename Parser,
typename GlobalState,
error_handler< I, S, GlobalState > ErrorHandler,
typename Callbacks>
bool callback_prefix_parse(I &, S,
parser_interface< Parser, GlobalState, ErrorHandler > const &,
Callbacks const &, trace = trace::off);
template<parsable_range R, typename Parser, typename GlobalState,
typename ErrorHandler, typename Callbacks>
bool callback_parse(R const &,
parser_interface< Parser, GlobalState, ErrorHandler > const &,
Callbacks const &, trace = trace::off);
template<parsable_iter I, std::sentinel_for< I > S, typename Parser,
typename GlobalState,
error_handler< I, S, GlobalState > ErrorHandler,
typename SkipParser, typename Callbacks>
bool callback_prefix_parse(I &, S,
parser_interface< Parser, GlobalState, ErrorHandler > const &,
parser_interface< SkipParser > const &,
Callbacks const &, trace = trace::off);
template<parsable_range R, typename Parser, typename GlobalState,
typename ErrorHandler, typename SkipParser, typename Callbacks>
bool callback_parse(R const &,
parser_interface< Parser, GlobalState, ErrorHandler > const &,
parser_interface< SkipParser > const &,
Callbacks const &, trace = trace::off);
namespace literals {
auto operator""_l(char);
auto operator""_l(char8_t);
auto operator""_l(char32_t);
auto operator""_l(char const *, std::size_t);
auto operator""_l(char8_t const *, std::size_t);
auto operator""_l(char32_t const *, std::size_t);
auto operator""_p(char);
auto operator""_p(char8_t);
auto operator""_p(char32_t);
auto operator""_p(char const *, std::size_t);
auto operator""_p(char8_t const *, std::size_t);
auto operator""_p(char32_t const *, std::size_t);
}
}
}
namespace boost {
namespace parser {
template<typename Parser, typename Action> struct action_parser;
template<typename Attribute> struct attr_parser;
template<typename R, typename Parser> struct attribute;
template<typename TagType, typename Attribute = no_attribute,
typename LocalState = no_local_state,
typename ParamsTuple = no_params>
struct callback_rule;
template<typename Expected, typename AttributeType = void>
struct char_parser;
template<typename Tag> struct char_set_parser;
template<typename Tag> struct char_subrange_parser;
template<typename Parser, typename DelimiterParser>
struct delimited_seq_parser;
template<typename Predicate> struct eps_parser;
template<typename Parser, bool FailOnMatch> struct expect_parser;
template<typename T> struct float_parser;
template<typename T, int Radix = 10, int MinDigits = 1,
int MaxDigits = -1, typename Expected = unspecified>
struct int_parser;
template<typename Parser> struct lexeme_parser;
template<typename Parser> struct no_case_parser;
template<typename Parser> struct omit_parser;
template<typename Parser> struct one_plus_parser;
template<typename Parser> struct opt_parser;
template<typename ParserTuple> struct or_parser;
template<typename Parser, typename GlobalState, typename ErrorHandler>
struct parser_interface;
template<typename ParserTuple, typename DelimiterParser> struct perm_parser;
template<typename Quotes, typename Escapes, typename CharParser>
struct quoted_string_parser;
template<typename Parser> struct raw_parser;
template<typename Parser, typename DelimiterParser = unspecified,
typename MinType = int64_t, typename MaxType = int64_t>
struct repeat_parser;
template<typename TagType, typename Attribute = no_attribute,
typename LocalState = no_local_state,
typename ParamsTuple = no_params>
struct rule;
template<bool CanUseCallbacks, typename TagType, typename Attribute,
typename LocalState, typename ParamsTuple>
struct rule_parser;
template<typename ParserTuple, typename BacktrackingTuple,
typename CombiningGroups>
struct seq_parser;
template<typename Parser, typename SkipParser = unspecified>
struct skip_parser;
struct sorted_t;
template<typename StrIter, typename StrSentinel> struct string_parser;
template<typename Parser> struct string_view_parser;
template<typename SwitchValue, typename OrParser = unspecified>
struct switch_parser;
template<typename T> struct symbol_parser;
template<typename Parser, typename F> struct transform_parser;
template<typename T, int Radix = 10, int MinDigits = 1,
int MaxDigits = -1, typename Expected = unspecified>
struct uint_parser;
template<bool NewlinesOnly, bool NoNewlines> struct ws_parser;
template<typename Parser> struct zero_plus_parser;
typedef unspecified null_sentinel_t;
typedef typename attribute< R, Parser >::type attribute_t;
typedef unspecified no_attribute;
typedef unspecified no_local_state;
typedef unspecified no_params;
bool enable_optional;
bool enable_variant;
sorted_t sorted;
template<typename CharT> auto null_term(CharT *);
decltype(auto) _val(Context const &);
template<typename Context> decltype(auto) _attr(Context const &);
template<typename Context> decltype(auto) _where(Context const &);
template<typename Context> decltype(auto) _begin(Context const &);
template<typename Context> decltype(auto) _end(Context const &);
template<typename Context> decltype(auto) _pass(Context const &);
template<typename Context> decltype(auto) _locals(Context const &);
template<typename Context> decltype(auto) _params(Context const &);
template<typename Context> decltype(auto) _globals(Context const &);
template<typename Context> decltype(auto) _error_handler(Context const &);
template<std::forward_iterator I, typename Context>
void _report_error(Context const &, std::string_view, I);
template<typename Context>
void _report_error(Context const &, std::string_view);
template<std::forward_iterator I, typename Context>
void _report_warning(Context const &, std::string_view, I);
template<typename Context>
void _report_warning(Context const &, std::string_view);
}
}
namespace boost {
namespace parser {
template<std::ranges::viewable_range V,
std::ranges::viewable_range ReplacementV, typename Parser,
typename GlobalState, typename ErrorHandler, typename SkipParser>
struct replace_view;
unspecified replace;
template<typename V, typename ReplacementV, typename Parser,
typename GlobalState, typename ErrorHandler, typename SkipParser>
replace_view(V &&,
parser_interface< Parser, GlobalState, ErrorHandler >,
parser_interface< SkipParser >, ReplacementV &&, trace);
template<typename V, typename ReplacementV, typename Parser,
typename GlobalState, typename ErrorHandler, typename SkipParser>
replace_view(V &&,
parser_interface< Parser, GlobalState, ErrorHandler >,
parser_interface< SkipParser >, ReplacementV &&);
template<typename V, typename ReplacementV, typename Parser,
typename GlobalState, typename ErrorHandler>
replace_view(V &&,
parser_interface< Parser, GlobalState, ErrorHandler >,
ReplacementV &&, trace);
template<typename V, typename ReplacementV, typename Parser,
typename GlobalState, typename ErrorHandler>
replace_view(V &&,
parser_interface< Parser, GlobalState, ErrorHandler >,
ReplacementV &&);
}
}
namespace boost {
namespace parser {
template<std::ranges::viewable_range V, typename Parser,
typename GlobalState, typename ErrorHandler, typename SkipParser>
struct search_all_view;
unspecified search_all;
template<parsable_range R, typename Parser, typename GlobalState,
typename ErrorHandler, typename SkipParser>
auto search(R &&,
parser_interface< Parser, GlobalState, ErrorHandler > const &,
parser_interface< SkipParser > const &, trace = trace::off);
template<parsable_iter I, std::sentinel_for< I > S, typename Parser,
typename SkipParser, typename GlobalState,
error_handler< I, S, GlobalState > ErrorHandler>
auto search(I, S,
parser_interface< Parser, GlobalState, ErrorHandler > const &,
parser_interface< SkipParser > const &, trace = trace::off);
template<parsable_range R, typename Parser, typename GlobalState,
typename ErrorHandler>
auto search(R &&,
parser_interface< Parser, GlobalState, ErrorHandler > const &,
trace = trace::off);
template<parsable_iter I, std::sentinel_for< I > S, typename Parser,
typename GlobalState,
error_handler< I, S, GlobalState > ErrorHandler>
auto search(I, S,
parser_interface< Parser, GlobalState, ErrorHandler > const &,
trace = trace::off);
template<typename V, typename Parser, typename GlobalState,
typename ErrorHandler, typename SkipParser>
search_all_view(V &&,
parser_interface< Parser, GlobalState, ErrorHandler >,
parser_interface< SkipParser >, trace);
template<typename V, typename Parser, typename GlobalState,
typename ErrorHandler, typename SkipParser>
search_all_view(V &&,
parser_interface< Parser, GlobalState, ErrorHandler >,
parser_interface< SkipParser >);
template<typename V, typename Parser, typename GlobalState,
typename ErrorHandler>
search_all_view(V &&,
parser_interface< Parser, GlobalState, ErrorHandler >,
trace);
template<typename V, typename Parser, typename GlobalState,
typename ErrorHandler>
search_all_view(V &&,
parser_interface< Parser, GlobalState, ErrorHandler >);
}
}
namespace boost {
namespace parser {
template<std::ranges::viewable_range V, typename Parser,
typename GlobalState, typename ErrorHandler, typename SkipParser>
struct split_view;
unspecified split;
template<typename V, typename Parser, typename GlobalState,
typename ErrorHandler, typename SkipParser>
split_view(V &&, parser_interface< Parser, GlobalState, ErrorHandler >,
parser_interface< SkipParser >, trace);
template<typename V, typename Parser, typename GlobalState,
typename ErrorHandler, typename SkipParser>
split_view(V &&, parser_interface< Parser, GlobalState, ErrorHandler >,
parser_interface< SkipParser >);
template<typename V, typename Parser, typename GlobalState,
typename ErrorHandler>
split_view(V &&, parser_interface< Parser, GlobalState, ErrorHandler >,
trace);
template<typename V, typename Parser, typename GlobalState,
typename ErrorHandler>
split_view(V &&, parser_interface< Parser, GlobalState, ErrorHandler >);
}
}
namespace boost {
namespace parser {
template<std::forward_iterator I, std::sentinel_for< I > S = I>
struct subrange;
template<std::forward_iterator I, std::sentinel_for< I > S = I>
subrange< I, S > make_subrange(I, S);
}
}namespace std {
namespace ranges {
}
}
namespace boost {
namespace parser {
template<std::ranges::viewable_range V, std::move_constructible F,
typename Parser, typename GlobalState, typename ErrorHandler,
typename SkipParser>
struct transform_replace_view;
unspecified transform_replace;
template<typename V, typename F, typename Parser, typename GlobalState,
typename ErrorHandler, typename SkipParser>
transform_replace_view(V &&,
parser_interface< Parser, GlobalState, ErrorHandler >,
parser_interface< SkipParser >, F &&, trace);
template<typename V, typename F, typename Parser, typename GlobalState,
typename ErrorHandler, typename SkipParser>
transform_replace_view(V &&,
parser_interface< Parser, GlobalState, ErrorHandler >,
parser_interface< SkipParser >, F &&);
template<typename V, typename F, typename Parser, typename GlobalState,
typename ErrorHandler>
transform_replace_view(V &&,
parser_interface< Parser, GlobalState, ErrorHandler >,
F &&, trace);
template<typename V, typename F, typename Parser, typename GlobalState,
typename ErrorHandler>
transform_replace_view(V &&,
parser_interface< Parser, GlobalState, ErrorHandler >,
F &&);
}
}
namespace boost {
namespace parser {
typedef hana::tuple< Args... > tuple;
typedef hana::integral_constant< T, I > integral_constant;
typedef integral_constant< long long, I > llong;
template<typename T, typename U, U I>
decltype(auto) get(T &&, integral_constant< U, I >);
namespace literals {
template<char... chars> auto operator""_c();
}
}
}
