inline alternative<
typename extension::as_parser<Left>::value_type
, typename extension::as_parser<Right>::value_type>
operator|(Left const& left, Right const& right)
{
return {as_parser(left), as_parser(right)};
}
inline sequence<
typename extension::as_parser<Left>::value_type
, typename extension::as_parser<Right>::value_type>
operator>>(Left const& left, Right const& right)
{
return { as_parser(left), as_parser(right) };
}
inline alternative<
typename extension::as_parser<Left>::value_type
, typename extension::as_parser<Right>::value_type>
operator|(Left const& left, Right const& right)
{
typedef alternative<
typename extension::as_parser<Left>::value_type
, typename extension::as_parser<Right>::value_type>
result_type;
return result_type(as_parser(left), as_parser(right));
}
inline sequence<
typename extension::as_parser<Left>::value_type
, expect_directive<typename extension::as_parser<Right>::value_type>>
operator>(Left const& left, Right const& right)
{
typedef sequence<
typename extension::as_parser<Left>::value_type
, expect_directive<typename extension::as_parser<Right>::value_type>>
result_type;
return result_type(as_parser(left), as_parser(right));
}
inline difference<
typename extension::as_parser<Left>::value_type
, typename extension::as_parser<Right>::value_type>
operator-(Left const& left, Right const& right)
{
typedef difference<
typename extension::as_parser<Left>::value_type
, typename extension::as_parser<Right>::value_type>
result_type;
return result_type(as_parser(left), as_parser(right));
}
expect_directive<typename extension::as_parser<Subject>::value_type>
operator[](Subject const& subject) const
{
typedef
expect_directive<typename extension::as_parser<Subject>::value_type>
result_type;
return result_type(as_parser(subject));
}
inline plus<typename extension::as_parser<Subject>::value_type>
operator+(Subject const& subject)
{
typedef
plus<typename extension::as_parser<Subject>::value_type>
result_type;
return result_type(as_parser(subject));
}
inline bool
phrase_parse(
Iterator& first
, Iterator last
, Parser const& p
, Skipper const& s
, Attribute& attr
, skip_flag post_skip = skip_flag::post_skip)
{
// Make sure the iterator is at least a forward_iterator. If you got a
// compilation error here, then you are using an input_iterator while
// calling this function. You need to supply at least a forward_iterator
// instead.
BOOST_CONCEPT_ASSERT((ForwardIterator<Iterator>));
// If you get an error no matching function for call to 'as_parser'
// here, for either p or s, then p or s is not a parser or there is
// no suitable conversion from p to a parser.
context<skipper_tag, Skipper const> skipper(as_parser(s));
bool r = as_parser(p).parse(first, last, skipper, attr);
if (post_skip == skip_flag::post_skip)
x3::skip_over(first, last, skipper);
return r;
}
inline bool
parse(
Iterator& first
, Iterator last
, Parser const& p
, Attribute& attr)
{
// Make sure the iterator is at least a forward_iterator. If you got a
// compilation error here, then you are using an input_iterator while
// calling this function. You need to supply at least a forward_iterator
// instead.
BOOST_CONCEPT_ASSERT((ForwardIterator<Iterator>));
// If you get an error no matching function for call to 'as_parser'
// here, then p is not a parser or there is no suitable conversion
// from p to a parser.
return as_parser(p).parse(first, last, unused, attr);
}
omit_directive<typename extension::as_parser<Subject>::value_type>
operator[](Subject const& subject) const
{
return {as_parser(subject)};
}
inline kleene<typename extension::as_parser<Subject>::value_type>
operator*(Subject const& subject)
{
return {as_parser(subject)};
}
};
template< typename type >
struct is_parser< type, std::void_t< typename type::parser_type > >
: std::true_type
{
};
template< typename iterator_type, typename skipper_type = unused_type >
struct dispatcher;
void as_parser(...) { ; }
template< typename grammar_type, typename attribute_type = decltype(as_parser(std::declval< grammar_type && >())) >
struct get_attribute
: identity< type >
{
};
template< typename type >
using get_attribute_t = typename get_attribute< type >::type;
template< typename iterator_type, typename skipper_type >
struct dispatcher
{
iterator_type & beg;
iterator_type end;
with_directive<typename extension::as_parser<Subject>::value_type, ID, T>
operator[](Subject const& subject) const
{
return { as_parser(subject), val };
}
confix_gen<typename extension::as_parser<Prefix>::value_type,
typename extension::as_parser<Postfix>::value_type>
confix(Prefix const& prefix, Postfix const& postfix)
{
return { as_parser(prefix), as_parser(postfix) };
}
confix_directive<
Prefix, typename extension::as_parser<Subject>::value_type, Postfix>
operator[](Subject const& subject) const
{
return { prefix, as_parser(subject), postfix };
}
rule_definition<
ID, typename extension::as_parser<RHS>::value_type, Attribute, force_attribute_>
operator=(RHS const& rhs) const
{
return { as_parser(rhs), name };
}
inline not_predicate<typename extension::as_parser<Subject>::value_type>
operator!(Subject const& subject)
{
return { as_parser(subject) };
}
inline action<typename extension::as_parser<P>::value_type, Action>
operator/(P const& p, Action f)
{
return {as_parser(p), f};
}
