You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
365 lines
12 KiB
365 lines
12 KiB
/////////////////////////////////////////////////////////////////////////////// |
|
// grammar.hpp |
|
// |
|
// Copyright 2008 Eric Niebler. Distributed under the Boost |
|
// Software License, Version 1.0. (See accompanying file |
|
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
|
|
|
#ifndef BOOST_XPRESSIVE_DETAIL_STATIC_GRAMMAR_HPP_EAN_11_12_2006 |
|
#define BOOST_XPRESSIVE_DETAIL_STATIC_GRAMMAR_HPP_EAN_11_12_2006 |
|
|
|
// MS compatible compilers support #pragma once |
|
#if defined(_MSC_VER) && (_MSC_VER >= 1020) |
|
# pragma once |
|
#endif |
|
|
|
#include <boost/mpl/if.hpp> |
|
#include <boost/mpl/bool.hpp> |
|
#include <boost/mpl/assert.hpp> |
|
#include <boost/proto/core.hpp> |
|
#include <boost/xpressive/detail/static/is_pure.hpp> |
|
#include <boost/xpressive/detail/static/transforms/as_matcher.hpp> |
|
#include <boost/xpressive/detail/static/transforms/as_alternate.hpp> |
|
#include <boost/xpressive/detail/static/transforms/as_sequence.hpp> |
|
#include <boost/xpressive/detail/static/transforms/as_quantifier.hpp> |
|
#include <boost/xpressive/detail/static/transforms/as_marker.hpp> |
|
#include <boost/xpressive/detail/static/transforms/as_set.hpp> |
|
#include <boost/xpressive/detail/static/transforms/as_independent.hpp> |
|
#include <boost/xpressive/detail/static/transforms/as_modifier.hpp> |
|
#include <boost/xpressive/detail/static/transforms/as_inverse.hpp> |
|
#include <boost/xpressive/detail/static/transforms/as_action.hpp> |
|
#include <boost/xpressive/detail/detail_fwd.hpp> |
|
|
|
#define BOOST_XPRESSIVE_CHECK_REGEX(Expr, Char)\ |
|
BOOST_MPL_ASSERT\ |
|
((\ |
|
typename boost::mpl::if_c<\ |
|
boost::xpressive::is_valid_regex<Expr, Char>::value\ |
|
, boost::mpl::true_\ |
|
, boost::xpressive::INVALID_REGULAR_EXPRESSION\ |
|
>::type\ |
|
)); |
|
|
|
////////////////////////////////////////////////////////////////////////// |
|
//**********************************************************************// |
|
//* << NOTE! >> *// |
|
//* *// |
|
//* Whenever you change this grammar, you MUST also make corresponding *// |
|
//* changes to width_of.hpp and is_pure.hpp. *// |
|
//* *// |
|
//**********************************************************************// |
|
////////////////////////////////////////////////////////////////////////// |
|
|
|
namespace boost { namespace xpressive |
|
{ |
|
template<typename Char> |
|
struct Grammar; |
|
|
|
template<typename Char> |
|
struct ActionableGrammar; |
|
|
|
namespace grammar_detail |
|
{ |
|
/////////////////////////////////////////////////////////////////////////// |
|
// CharLiteral |
|
template<typename Char> |
|
struct CharLiteral; |
|
|
|
/////////////////////////////////////////////////////////////////////////// |
|
// ListSet |
|
template<typename Char> |
|
struct ListSet; |
|
|
|
/////////////////////////////////////////////////////////////////////////// |
|
// as_repeat |
|
template<typename Char, typename Gram, typename Greedy> |
|
struct as_repeat |
|
: if_< |
|
make<detail::use_simple_repeat<_child, Char> > |
|
, as_simple_quantifier<Gram, Greedy> |
|
, as_default_quantifier<Greedy> |
|
> |
|
{}; |
|
|
|
/////////////////////////////////////////////////////////////////////////// |
|
// NonGreedyRepeatCases |
|
template<typename Gram> |
|
struct NonGreedyRepeatCases |
|
{ |
|
template<typename Tag, typename Dummy = void> |
|
struct case_ |
|
: not_<_> |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<tag::dereference, Dummy> |
|
: dereference<Gram> |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<tag::unary_plus, Dummy> |
|
: unary_plus<Gram> |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<tag::logical_not, Dummy> |
|
: logical_not<Gram> |
|
{}; |
|
|
|
template<uint_t Min, uint_t Max, typename Dummy> |
|
struct case_<detail::generic_quant_tag<Min, Max>, Dummy> |
|
: unary_expr<detail::generic_quant_tag<Min, Max>, Gram> |
|
{}; |
|
}; |
|
|
|
/////////////////////////////////////////////////////////////////////////// |
|
// InvertibleCases |
|
template<typename Char, typename Gram> |
|
struct InvertibleCases |
|
{ |
|
template<typename Tag, typename Dummy = void> |
|
struct case_ |
|
: not_<_> |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<tag::comma, Dummy> |
|
: when<ListSet<Char>, as_list_set_matcher<Char> > |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<tag::assign, Dummy> |
|
: when<ListSet<Char>, as_list_set_matcher<Char> > |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<tag::subscript, Dummy> |
|
: when<subscript<detail::set_initializer_type, Gram>, call<as_set_matcher<Gram>(_right)> > |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<detail::lookahead_tag, Dummy> |
|
: when< |
|
unary_expr<detail::lookahead_tag, Gram> |
|
, as_lookahead<Gram> |
|
> |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<detail::lookbehind_tag, Dummy> |
|
: when< |
|
unary_expr<detail::lookbehind_tag, Gram> |
|
, as_lookbehind<Gram> |
|
> |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<tag::terminal, Dummy> |
|
: when< |
|
or_< |
|
CharLiteral<Char> |
|
, terminal<detail::posix_charset_placeholder> |
|
, terminal<detail::range_placeholder<_> > |
|
, terminal<detail::logical_newline_placeholder> |
|
, terminal<detail::assert_word_placeholder<detail::word_boundary<mpl::true_> > > |
|
> |
|
, as_matcher |
|
> |
|
{}; |
|
}; |
|
|
|
/////////////////////////////////////////////////////////////////////////// |
|
// Cases |
|
template<typename Char, typename Gram> |
|
struct Cases |
|
{ |
|
template<typename Tag, typename Dummy = void> |
|
struct case_ |
|
: not_<_> |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<tag::terminal, Dummy> |
|
: when< |
|
_ |
|
, in_sequence<as_matcher> |
|
> |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<tag::shift_right, Dummy> |
|
: when< |
|
shift_right<Gram, Gram> |
|
, reverse_fold<_, _state, Gram> |
|
> |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<tag::bitwise_or, Dummy> |
|
: when< |
|
bitwise_or<Gram, Gram> |
|
, in_sequence< |
|
as_alternate_matcher< |
|
reverse_fold_tree<_, make<fusion::nil>, in_alternate_list<Gram> > |
|
> |
|
> |
|
> |
|
{}; |
|
|
|
template<typename Dummy, typename Greedy> |
|
struct case_<optional_tag<Greedy> , Dummy> |
|
: when< |
|
unary_expr<optional_tag<Greedy>, Gram> |
|
, in_sequence<call<as_optional<Gram, Greedy>(_child)> > |
|
> |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<tag::dereference, Dummy> |
|
: when< |
|
dereference<Gram> |
|
, call<Gram(as_repeat<Char, Gram, mpl::true_>)> |
|
> |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<tag::unary_plus, Dummy> |
|
: when< |
|
unary_plus<Gram> |
|
, call<Gram(as_repeat<Char, Gram, mpl::true_>)> |
|
> |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<tag::logical_not, Dummy> |
|
: when< |
|
logical_not<Gram> |
|
, call<Gram(as_repeat<Char, Gram, mpl::true_>)> |
|
> |
|
{}; |
|
|
|
template<uint_t Min, uint_t Max, typename Dummy> |
|
struct case_<detail::generic_quant_tag<Min, Max>, Dummy> |
|
: when< |
|
unary_expr<detail::generic_quant_tag<Min, Max>, Gram> |
|
, call<Gram(as_repeat<Char, Gram, mpl::true_>)> |
|
> |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<tag::negate, Dummy> |
|
: when< |
|
negate<switch_<NonGreedyRepeatCases<Gram> > > |
|
, call<Gram(call<as_repeat<Char, Gram, mpl::false_>(_child)>)> |
|
> |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<tag::complement, Dummy> |
|
: when< |
|
complement<switch_<InvertibleCases<Char, Gram> > > |
|
, in_sequence<call<as_inverse(call<switch_<InvertibleCases<Char, Gram> >(_child)>)> > |
|
> |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<detail::modifier_tag, Dummy> |
|
: when<binary_expr<detail::modifier_tag, _, Gram>, as_modifier<Gram> > |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<detail::lookahead_tag, Dummy> |
|
: when< |
|
unary_expr<detail::lookahead_tag, Gram> |
|
, in_sequence<as_lookahead<Gram> > |
|
> |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<detail::lookbehind_tag, Dummy> |
|
: when< |
|
unary_expr<detail::lookbehind_tag, Gram> |
|
, in_sequence<as_lookbehind<Gram> > |
|
> |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<detail::keeper_tag, Dummy> |
|
: when< |
|
unary_expr<detail::keeper_tag, Gram> |
|
, in_sequence<as_keeper<Gram> > |
|
> |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<tag::comma, Dummy> |
|
: when<ListSet<Char>, in_sequence<as_list_set_matcher<Char> > > |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<tag::assign, Dummy> |
|
: or_< |
|
when<assign<detail::basic_mark_tag, Gram>, call<Gram(as_marker)> > |
|
, when<ListSet<Char>, in_sequence<as_list_set_matcher<Char> > > |
|
> |
|
{}; |
|
|
|
template<typename Dummy> |
|
struct case_<tag::subscript, Dummy> |
|
: or_< |
|
when<subscript<detail::set_initializer_type, Gram>, in_sequence<call<as_set_matcher<Gram>(_right)> > > |
|
, when<subscript<ActionableGrammar<Char>, _>, call<ActionableGrammar<Char>(as_action)> > |
|
> |
|
{}; |
|
}; |
|
|
|
/////////////////////////////////////////////////////////////////////////// |
|
// ActionableCases |
|
template<typename Char, typename Gram> |
|
struct ActionableCases |
|
{ |
|
template<typename Tag, typename Dummy = void> |
|
struct case_ |
|
: Cases<Char, Gram>::template case_<Tag> |
|
{}; |
|
|
|
// Only in sub-expressions with actions attached do we allow attribute assignements |
|
template<typename Dummy> |
|
struct case_<proto::tag::assign, Dummy> |
|
: or_< |
|
typename Cases<Char, Gram>::template case_<proto::tag::assign> |
|
, when<proto::assign<terminal<detail::attribute_placeholder<_> >, _>, in_sequence<as_attr_matcher> > |
|
> |
|
{}; |
|
}; |
|
|
|
} // namespace detail |
|
|
|
/////////////////////////////////////////////////////////////////////////// |
|
// Grammar |
|
template<typename Char> |
|
struct Grammar |
|
: proto::switch_<grammar_detail::Cases<Char, Grammar<Char> > > |
|
{}; |
|
|
|
template<typename Char> |
|
struct ActionableGrammar |
|
: proto::switch_<grammar_detail::ActionableCases<Char, ActionableGrammar<Char> > > |
|
{}; |
|
|
|
/////////////////////////////////////////////////////////////////////////// |
|
// INVALID_REGULAR_EXPRESSION |
|
struct INVALID_REGULAR_EXPRESSION |
|
: mpl::false_ |
|
{}; |
|
|
|
/////////////////////////////////////////////////////////////////////////// |
|
// is_valid_regex |
|
template<typename Expr, typename Char> |
|
struct is_valid_regex |
|
: proto::matches<Expr, Grammar<Char> > |
|
{}; |
|
|
|
}} // namespace boost::xpressive |
|
|
|
#endif
|
|
|