| #ifndef BOOST_PP_IS_ITERATING |
| /////////////////////////////////////////////////////////////////////////////// |
| /// \file matches.hpp |
| /// Contains definition of matches\<\> metafunction for determining if |
| /// a given expression matches a given pattern. |
| // |
| // 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_PROTO_MATCHES_HPP_EAN_11_03_2006 |
| #define BOOST_PROTO_MATCHES_HPP_EAN_11_03_2006 |
| |
| #include <boost/config.hpp> |
| #include <boost/detail/workaround.hpp> |
| #include <boost/preprocessor/cat.hpp> |
| #include <boost/preprocessor/arithmetic/dec.hpp> |
| #include <boost/preprocessor/arithmetic/sub.hpp> |
| #include <boost/preprocessor/iteration/iterate.hpp> |
| #include <boost/preprocessor/facilities/intercept.hpp> |
| #include <boost/preprocessor/punctuation/comma_if.hpp> |
| #include <boost/preprocessor/repetition/enum.hpp> |
| #include <boost/preprocessor/repetition/enum_params.hpp> |
| #include <boost/preprocessor/repetition/enum_shifted.hpp> |
| #include <boost/preprocessor/repetition/enum_binary_params.hpp> |
| #include <boost/preprocessor/repetition/enum_shifted_params.hpp> |
| #include <boost/preprocessor/repetition/enum_trailing_params.hpp> |
| #include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> |
| #include <boost/preprocessor/repetition/repeat.hpp> |
| #include <boost/config.hpp> |
| #include <boost/mpl/logical.hpp> |
| #include <boost/mpl/eval_if.hpp> |
| #include <boost/mpl/aux_/template_arity.hpp> |
| #include <boost/mpl/aux_/lambda_arity_param.hpp> |
| #include <boost/utility/enable_if.hpp> |
| #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) |
| #include <boost/type_traits/is_array.hpp> |
| #endif |
| #include <boost/type_traits/is_const.hpp> |
| #include <boost/type_traits/is_convertible.hpp> |
| #include <boost/type_traits/is_reference.hpp> |
| #include <boost/type_traits/is_pointer.hpp> |
| #include <boost/proto/proto_fwd.hpp> |
| #include <boost/proto/traits.hpp> |
| #include <boost/proto/transform/when.hpp> |
| #include <boost/proto/transform/impl.hpp> |
| |
| // Some compilers (like GCC) need extra help figuring out a template's arity. |
| // I use MPL's BOOST_MPL_AUX_LAMBDA_ARITY_PARAM() macro to disambiguate, which |
| // which is controlled by the BOOST_MPL_LIMIT_METAFUNCTION_ARITY macro. If |
| // You define BOOST_PROTO_MAX_ARITY to be greater than |
| // BOOST_MPL_LIMIT_METAFUNCTION_ARITY on these compilers, things don't work. |
| // You must define BOOST_MPL_LIMIT_METAFUNCTION_ARITY to be greater. |
| #ifdef BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING |
| # if BOOST_PROTO_MAX_ARITY > BOOST_MPL_LIMIT_METAFUNCTION_ARITY |
| # error BOOST_MPL_LIMIT_METAFUNCTION_ARITY must be at least as large as BOOST_PROTO_MAX_ARITY |
| # endif |
| #endif |
| |
| #if defined(_MSC_VER) && (_MSC_VER >= 1020) |
| # pragma warning(push) |
| # pragma warning(disable:4305) // 'specialization' : truncation from 'const int' to 'bool' |
| #endif |
| |
| namespace boost { namespace proto |
| { |
| |
| namespace detail |
| { |
| template<typename Expr, typename Grammar> |
| struct matches_; |
| |
| template<bool B, typename Pred> |
| struct and_2; |
| |
| template<typename And, typename Expr, typename State, typename Data> |
| struct _and_impl; |
| |
| template<typename T, typename U> |
| struct array_matches |
| : mpl::false_ |
| {}; |
| |
| template<typename T, std::size_t M> |
| struct array_matches<T[M], T *> |
| : mpl::true_ |
| {}; |
| |
| template<typename T, std::size_t M> |
| struct array_matches<T[M], T const *> |
| : mpl::true_ |
| {}; |
| |
| template<typename T, std::size_t M> |
| struct array_matches<T[M], T[proto::N]> |
| : mpl::true_ |
| {}; |
| |
| template<typename T, typename U |
| BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(long Arity = mpl::aux::template_arity<U>::value) |
| > |
| struct lambda_matches |
| : mpl::false_ |
| {}; |
| |
| template<typename T> |
| struct lambda_matches<T, proto::_ BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(-1)> |
| : mpl::true_ |
| {}; |
| |
| template<typename T> |
| struct lambda_matches<T, T BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(-1)> |
| : mpl::true_ |
| {}; |
| |
| template<typename T, std::size_t M, typename U> |
| struct lambda_matches<T[M], U BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(-1)> |
| : array_matches<T[M], U> |
| {}; |
| |
| template<typename T, std::size_t M> |
| struct lambda_matches<T[M], _ BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(-1)> |
| : mpl::true_ |
| {}; |
| |
| template<typename T, std::size_t M> |
| struct lambda_matches<T[M], T[M] BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(-1)> |
| : mpl::true_ |
| {}; |
| |
| template<template<typename> class T, typename Expr0, typename Grammar0> |
| struct lambda_matches<T<Expr0>, T<Grammar0> BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(1) > |
| : lambda_matches<Expr0, Grammar0> |
| {}; |
| |
| // vararg_matches_impl |
| template<typename Args1, typename Back, long From, long To> |
| struct vararg_matches_impl; |
| |
| // vararg_matches |
| template<typename Args1, typename Args2, typename Back, bool Can, bool Zero, typename Void = void> |
| struct vararg_matches |
| : mpl::false_ |
| {}; |
| |
| template<typename Args1, typename Args2, typename Back> |
| struct vararg_matches<Args1, Args2, Back, true, true, typename Back::proto_is_vararg_> |
| : matches_< |
| proto::basic_expr<ignore, Args1, Args1::arity> |
| , proto::basic_expr<ignore, Args2, Args1::arity> |
| > |
| {}; |
| |
| template<typename Args1, typename Args2, typename Back> |
| struct vararg_matches<Args1, Args2, Back, true, false, typename Back::proto_is_vararg_> |
| : and_2< |
| matches_< |
| proto::basic_expr<ignore, Args1, Args2::arity> |
| , proto::basic_expr<ignore, Args2, Args2::arity> |
| >::value |
| , vararg_matches_impl<Args1, typename Back::proto_grammar, Args2::arity + 1, Args1::arity> |
| > |
| {}; |
| |
| // How terminal_matches<> handles references and cv-qualifiers. |
| // The cv and ref matter *only* if the grammar has a top-level ref. |
| // |
| // Expr | Grammar | Matches? |
| // ------------------------------------- |
| // T T yes |
| // T & T yes |
| // T const & T yes |
| // T T & no |
| // T & T & yes |
| // T const & T & no |
| // T T const & no |
| // T & T const & no |
| // T const & T const & yes |
| |
| template<typename T, typename U> |
| struct is_cv_ref_compatible |
| : mpl::true_ |
| {}; |
| |
| template<typename T, typename U> |
| struct is_cv_ref_compatible<T, U &> |
| : mpl::false_ |
| {}; |
| |
| template<typename T, typename U> |
| struct is_cv_ref_compatible<T &, U &> |
| : mpl::bool_<is_const<T>::value == is_const<U>::value> |
| {}; |
| |
| #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) |
| // MSVC-7.1 has lots of problems with array types that have been |
| // deduced. Partially specializing terminal_matches<> on array types |
| // doesn't seem to work. |
| template< |
| typename T |
| , typename U |
| , bool B = is_array<BOOST_PROTO_UNCVREF(T)>::value |
| > |
| struct terminal_array_matches |
| : mpl::false_ |
| {}; |
| |
| template<typename T, typename U, std::size_t M> |
| struct terminal_array_matches<T, U(&)[M], true> |
| : is_convertible<T, U(&)[M]> |
| {}; |
| |
| template<typename T, typename U> |
| struct terminal_array_matches<T, U(&)[proto::N], true> |
| : is_convertible<T, U *> |
| {}; |
| |
| template<typename T, typename U> |
| struct terminal_array_matches<T, U *, true> |
| : is_convertible<T, U *> |
| {}; |
| |
| // terminal_matches |
| template<typename T, typename U> |
| struct terminal_matches |
| : mpl::or_< |
| mpl::and_< |
| is_cv_ref_compatible<T, U> |
| , lambda_matches< |
| BOOST_PROTO_UNCVREF(T) |
| , BOOST_PROTO_UNCVREF(U) |
| > |
| > |
| , terminal_array_matches<T, U> |
| > |
| {}; |
| #else |
| // terminal_matches |
| template<typename T, typename U> |
| struct terminal_matches |
| : mpl::and_< |
| is_cv_ref_compatible<T, U> |
| , lambda_matches< |
| BOOST_PROTO_UNCVREF(T) |
| , BOOST_PROTO_UNCVREF(U) |
| > |
| > |
| {}; |
| |
| template<typename T, std::size_t M> |
| struct terminal_matches<T(&)[M], T(&)[proto::N]> |
| : mpl::true_ |
| {}; |
| |
| template<typename T, std::size_t M> |
| struct terminal_matches<T(&)[M], T *> |
| : mpl::true_ |
| {}; |
| |
| // Avoid ambiguity errors on MSVC |
| #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)) |
| template<typename T, std::size_t M> |
| struct terminal_matches<T const (&)[M], T const[M]> |
| : mpl::true_ |
| {}; |
| #endif |
| #endif |
| |
| template<typename T> |
| struct terminal_matches<T, T> |
| : mpl::true_ |
| {}; |
| |
| template<typename T> |
| struct terminal_matches<T &, T> |
| : mpl::true_ |
| {}; |
| |
| template<typename T> |
| struct terminal_matches<T const &, T> |
| : mpl::true_ |
| {}; |
| |
| template<typename T> |
| struct terminal_matches<T, proto::_> |
| : mpl::true_ |
| {}; |
| |
| template<typename T> |
| struct terminal_matches<T, exact<T> > |
| : mpl::true_ |
| {}; |
| |
| template<typename T, typename U> |
| struct terminal_matches<T, proto::convertible_to<U> > |
| : is_convertible<T, U> |
| {}; |
| |
| // matches_ |
| template<typename Expr, typename Grammar> |
| struct matches_ |
| : mpl::false_ |
| {}; |
| |
| template<typename Expr> |
| struct matches_< Expr, proto::_ > |
| : mpl::true_ |
| {}; |
| |
| template<typename Tag, typename Args1, long N1, typename Args2, long N2> |
| struct matches_< proto::basic_expr<Tag, Args1, N1>, proto::basic_expr<Tag, Args2, N2> > |
| : vararg_matches< Args1, Args2, typename Args2::back_, (N1+2 > N2), (N2 > N1) > |
| {}; |
| |
| template<typename Tag, typename Args1, long N1, typename Args2, long N2> |
| struct matches_< proto::basic_expr<Tag, Args1, N1>, proto::basic_expr<proto::_, Args2, N2> > |
| : vararg_matches< Args1, Args2, typename Args2::back_, (N1+2 > N2), (N2 > N1) > |
| {}; |
| |
| template<typename Tag, typename Args1, typename Args2> |
| struct matches_< proto::basic_expr<Tag, Args1, 0>, proto::basic_expr<Tag, Args2, 0> > |
| : terminal_matches<typename Args1::child0, typename Args2::child0> |
| {}; |
| |
| template<typename Tag, typename Args1, typename Args2, long N2> |
| struct matches_< proto::basic_expr<Tag, Args1, 0>, proto::basic_expr<proto::_, Args2, N2> > |
| : mpl::false_ |
| {}; |
| |
| template<typename Tag, typename Args1, typename Args2> |
| struct matches_< proto::basic_expr<Tag, Args1, 0>, proto::basic_expr<proto::_, Args2, 0> > |
| : terminal_matches<typename Args1::child0, typename Args2::child0> |
| {}; |
| |
| template<typename Tag, typename Args1, typename Args2> |
| struct matches_< proto::basic_expr<Tag, Args1, 1>, proto::basic_expr<Tag, Args2, 1> > |
| : matches_< |
| typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar |
| , typename Args2::child0::proto_grammar |
| > |
| {}; |
| |
| template<typename Tag, typename Args1, typename Args2> |
| struct matches_< proto::basic_expr<Tag, Args1, 1>, proto::basic_expr<proto::_, Args2, 1> > |
| : matches_< |
| typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar |
| , typename Args2::child0::proto_grammar |
| > |
| {}; |
| |
| #define BOOST_PROTO_MATCHES_N_FUN(Z, N, DATA) \ |
| matches_< \ |
| typename detail::expr_traits<typename Args1::BOOST_PP_CAT(child, N)>::value_type::proto_grammar\ |
| , typename Args2::BOOST_PP_CAT(child, N)::proto_grammar \ |
| > |
| |
| #define BOOST_PROTO_DEFINE_MATCHES(Z, N, DATA) \ |
| matches_< \ |
| Expr \ |
| , typename BOOST_PP_CAT(G, N)::proto_grammar \ |
| > |
| |
| #define BOOST_PROTO_DEFINE_LAMBDA_MATCHES(Z, N, DATA) \ |
| lambda_matches< \ |
| BOOST_PP_CAT(Expr, N) \ |
| , BOOST_PP_CAT(Grammar, N) \ |
| > |
| |
| #if BOOST_PROTO_MAX_LOGICAL_ARITY > BOOST_PROTO_MAX_ARITY |
| #define BOOST_PP_ITERATION_PARAMS_1 (4, (2, BOOST_PROTO_MAX_LOGICAL_ARITY, <boost/proto/matches.hpp>, 1)) |
| #else |
| #define BOOST_PP_ITERATION_PARAMS_1 (4, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/matches.hpp>, 1)) |
| #endif |
| #include BOOST_PP_ITERATE() |
| |
| #define BOOST_PP_ITERATION_PARAMS_1 (4, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/matches.hpp>, 2)) |
| #include BOOST_PP_ITERATE() |
| |
| #undef BOOST_PROTO_MATCHES_N_FUN |
| #undef BOOST_PROTO_DEFINE_MATCHES |
| #undef BOOST_PROTO_DEFINE_LAMBDA_MATCHES |
| |
| // handle proto::if_ |
| template<typename Tag, typename Args, long Arity, typename If, typename Then, typename Else> |
| struct matches_<proto::basic_expr<Tag, Args, Arity>, proto::if_<If, Then, Else> > |
| : mpl::eval_if_c< |
| remove_reference< |
| typename when<_, If>:: |
| template impl<proto::expr<Tag, Args, Arity>, int, int>::result_type |
| >::type::value |
| , matches_<proto::basic_expr<Tag, Args, Arity>, typename Then::proto_grammar> |
| , matches_<proto::basic_expr<Tag, Args, Arity>, typename Else::proto_grammar> |
| >::type |
| {}; |
| |
| template<typename Tag, typename Args, long Arity, typename If> |
| struct matches_<proto::basic_expr<Tag, Args, Arity>, proto::if_<If> > |
| : detail::uncvref< |
| typename when<_, If>:: |
| template impl<proto::expr<Tag, Args, Arity>, int, int>::result_type |
| >::type |
| {}; |
| |
| // handle degenerate cases of proto::or_ |
| template<typename Expr> |
| struct matches_<Expr, or_<> > |
| : mpl::false_ |
| { |
| typedef not_<_> which; |
| }; |
| |
| template<typename Expr, typename G0> |
| struct matches_<Expr, or_<G0> > |
| : matches_<Expr, typename G0::proto_grammar> |
| { |
| typedef G0 which; |
| }; |
| |
| // handle degenerate cases of proto::and_ |
| template<typename Expr> |
| struct matches_<Expr, and_<> > |
| : mpl::true_ |
| {}; |
| |
| template<typename Expr, typename G0> |
| struct matches_<Expr, and_<G0> > |
| : matches_<Expr, typename G0::proto_grammar> |
| {}; |
| |
| // handle proto::not_ |
| template<typename Expr, typename Grammar> |
| struct matches_<Expr, not_<Grammar> > |
| : mpl::not_<matches_<Expr, typename Grammar::proto_grammar> > |
| {}; |
| |
| // handle proto::switch_ |
| template<typename Tag, typename Args, long Arity, typename Cases> |
| struct matches_<proto::basic_expr<Tag, Args, Arity>, switch_<Cases> > |
| : matches_< |
| proto::basic_expr<Tag, Args, Arity> |
| , typename Cases::template case_<Tag>::proto_grammar |
| > |
| {}; |
| } |
| |
| /// \brief A Boolean metafunction that evaluates whether a given |
| /// expression type matches a grammar. |
| /// |
| /// <tt>matches\<Expr,Grammar\></tt> inherits (indirectly) from |
| /// \c mpl::true_ if <tt>Expr::proto_grammar</tt> matches |
| /// <tt>Grammar::proto_grammar</tt>, and from \c mpl::false_ |
| /// otherwise. |
| /// |
| /// Non-terminal expressions are matched against a grammar |
| /// according to the following rules: |
| /// |
| /// \li The wildcard pattern, \c _, matches any expression. |
| /// \li An expression <tt>expr\<AT, listN\<A0,A1,...An\> \></tt> |
| /// matches a grammar <tt>expr\<BT, listN\<B0,B1,...Bn\> \></tt> |
| /// if \c BT is \c _ or \c AT, and if \c Ax matches \c Bx for |
| /// each \c x in <tt>[0,n)</tt>. |
| /// \li An expression <tt>expr\<AT, listN\<A0,...An,U0,...Um\> \></tt> |
| /// matches a grammar <tt>expr\<BT, listM\<B0,...Bn,vararg\<V\> \> \></tt> |
| /// if \c BT is \c _ or \c AT, and if \c Ax matches \c Bx |
| /// for each \c x in <tt>[0,n)</tt> and if \c Ux matches \c V |
| /// for each \c x in <tt>[0,m)</tt>. |
| /// \li An expression \c E matches <tt>or_\<B0,B1,...Bn\></tt> if \c E |
| /// matches some \c Bx for \c x in <tt>[0,n)</tt>. |
| /// \li An expression \c E matches <tt>and_\<B0,B1,...Bn\></tt> if \c E |
| /// matches all \c Bx for \c x in <tt>[0,n)</tt>. |
| /// \li An expression \c E matches <tt>if_\<T,U,V\></tt> if |
| /// <tt>boost::result_of\<when\<_,T\>(E,int,int)\>::type::value</tt> |
| /// is \c true and \c E matches \c U; or, if |
| /// <tt>boost::result_of\<when\<_,T\>(E,int,int)\>::type::value</tt> |
| /// is \c false and \c E matches \c V. (Note: \c U defaults to \c _ |
| /// and \c V defaults to \c not_\<_\>.) |
| /// \li An expression \c E matches <tt>not_\<T\></tt> if \c E does |
| /// not match \c T. |
| /// \li An expression \c E matches <tt>switch_\<C\></tt> if |
| /// \c E matches <tt>C::case_\<E::proto_tag\></tt>. |
| /// |
| /// A terminal expression <tt>expr\<AT,term\<A\> \></tt> matches |
| /// a grammar <tt>expr\<BT,term\<B\> \></tt> if \c BT is \c AT or |
| /// \c proto::_ and if one of the following is true: |
| /// |
| /// \li \c B is the wildcard pattern, \c _ |
| /// \li \c A is \c B |
| /// \li \c A is <tt>B &</tt> |
| /// \li \c A is <tt>B const &</tt> |
| /// \li \c B is <tt>exact\<A\></tt> |
| /// \li \c B is <tt>convertible_to\<X\></tt> and |
| /// <tt>is_convertible\<A,X\>::value</tt> is \c true. |
| /// \li \c A is <tt>X[M]</tt> or <tt>X(&)[M]</tt> and |
| /// \c B is <tt>X[proto::N]</tt>. |
| /// \li \c A is <tt>X(&)[M]</tt> and \c B is <tt>X(&)[proto::N]</tt>. |
| /// \li \c A is <tt>X[M]</tt> or <tt>X(&)[M]</tt> and |
| /// \c B is <tt>X*</tt>. |
| /// \li \c B lambda-matches \c A (see below). |
| /// |
| /// A type \c B lambda-matches \c A if one of the following is true: |
| /// |
| /// \li \c B is \c A |
| /// \li \c B is the wildcard pattern, \c _ |
| /// \li \c B is <tt>T\<B0,B1,...Bn\></tt> and \c A is |
| /// <tt>T\<A0,A1,...An\></tt> and for each \c x in |
| /// <tt>[0,n)</tt>, \c Ax and \c Bx are types |
| /// such that \c Ax lambda-matches \c Bx |
| template<typename Expr, typename Grammar> |
| struct matches |
| : detail::matches_< |
| typename Expr::proto_grammar |
| , typename Grammar::proto_grammar |
| > |
| {}; |
| |
| /// INTERNAL ONLY |
| /// |
| template<typename Expr, typename Grammar> |
| struct matches<Expr &, Grammar> |
| : detail::matches_< |
| typename Expr::proto_grammar |
| , typename Grammar::proto_grammar |
| > |
| {}; |
| |
| /// \brief A wildcard grammar element that matches any expression, |
| /// and a transform that returns the current expression unchanged. |
| /// |
| /// The wildcard type, \c _, is a grammar element such that |
| /// <tt>matches\<E,_\>::value</tt> is \c true for any expression |
| /// type \c E. |
| /// |
| /// The wildcard can also be used as a stand-in for a template |
| /// argument when matching terminals. For instance, the following |
| /// is a grammar that will match any <tt>std::complex\<\></tt> |
| /// terminal: |
| /// |
| /// \code |
| /// BOOST_MPL_ASSERT(( |
| /// matches< |
| /// terminal<std::complex<double> >::type |
| /// , terminal<std::complex< _ > > |
| /// > |
| /// )); |
| /// \endcode |
| /// |
| /// When used as a transform, \c _ returns the current expression |
| /// unchanged. For instance, in the following, \c _ is used with |
| /// the \c fold\<\> transform to fold the children of a node: |
| /// |
| /// \code |
| /// struct CountChildren |
| /// : or_< |
| /// // Terminals have no children |
| /// when<terminal<_>, mpl::int_<0>()> |
| /// // Use fold<> to count the children of non-terminals |
| /// , otherwise< |
| /// fold< |
| /// _ // <-- fold the current expression |
| /// , mpl::int_<0>() |
| /// , mpl::plus<_state, mpl::int_<1> >() |
| /// > |
| /// > |
| /// > |
| /// {}; |
| /// \endcode |
| struct _ : transform<_> |
| { |
| typedef _ proto_grammar; |
| |
| template<typename Expr, typename State, typename Data> |
| struct impl : transform_impl<Expr, State, Data> |
| { |
| typedef Expr result_type; |
| |
| /// \param expr An expression |
| /// \return \c e |
| #ifdef BOOST_PROTO_STRICT_RESULT_OF |
| result_type |
| #else |
| typename impl::expr_param |
| #endif |
| operator()( |
| typename impl::expr_param e |
| , typename impl::state_param |
| , typename impl::data_param |
| ) const |
| { |
| return e; |
| } |
| }; |
| }; |
| |
| namespace detail |
| { |
| template<typename Expr, typename State, typename Data> |
| struct _and_impl<proto::and_<>, Expr, State, Data> |
| : proto::_::impl<Expr, State, Data> |
| {}; |
| |
| template<typename G0, typename Expr, typename State, typename Data> |
| struct _and_impl<proto::and_<G0>, Expr, State, Data> |
| : proto::when<proto::_, G0>::template impl<Expr, State, Data> |
| {}; |
| } |
| |
| /// \brief Inverts the set of expressions matched by a grammar. When |
| /// used as a transform, \c not_\<\> returns the current expression |
| /// unchanged. |
| /// |
| /// If an expression type \c E does not match a grammar \c G, then |
| /// \c E \e does match <tt>not_\<G\></tt>. For example, |
| /// <tt>not_\<terminal\<_\> \></tt> will match any non-terminal. |
| template<typename Grammar> |
| struct not_ : transform<not_<Grammar> > |
| { |
| typedef not_ proto_grammar; |
| |
| template<typename Expr, typename State, typename Data> |
| struct impl : transform_impl<Expr, State, Data> |
| { |
| typedef Expr result_type; |
| |
| /// \param e An expression |
| /// \pre <tt>matches\<Expr,not_\>::value</tt> is \c true. |
| /// \return \c e |
| #ifdef BOOST_PROTO_STRICT_RESULT_OF |
| result_type |
| #else |
| typename impl::expr_param |
| #endif |
| operator()( |
| typename impl::expr_param e |
| , typename impl::state_param |
| , typename impl::data_param |
| ) const |
| { |
| return e; |
| } |
| }; |
| }; |
| |
| /// \brief Used to select one grammar or another based on the result |
| /// of a compile-time Boolean. When used as a transform, \c if_\<\> |
| /// selects between two transforms based on a compile-time Boolean. |
| /// |
| /// When <tt>if_\<If,Then,Else\></tt> is used as a grammar, \c If |
| /// must be a Proto transform and \c Then and \c Else must be grammars. |
| /// An expression type \c E matches <tt>if_\<If,Then,Else\></tt> if |
| /// <tt>boost::result_of\<when\<_,If\>(E,int,int)\>::type::value</tt> |
| /// is \c true and \c E matches \c U; or, if |
| /// <tt>boost::result_of\<when\<_,If\>(E,int,int)\>::type::value</tt> |
| /// is \c false and \c E matches \c V. |
| /// |
| /// The template parameter \c Then defaults to \c _ |
| /// and \c Else defaults to \c not\<_\>, so an expression type \c E |
| /// will match <tt>if_\<If\></tt> if and only if |
| /// <tt>boost::result_of\<when\<_,If\>(E,int,int)\>::type::value</tt> |
| /// is \c true. |
| /// |
| /// \code |
| /// // A grammar that only matches integral terminals, |
| /// // using is_integral<> from Boost.Type_traits. |
| /// struct IsIntegral |
| /// : and_< |
| /// terminal<_> |
| /// , if_< is_integral<_value>() > |
| /// > |
| /// {}; |
| /// \endcode |
| /// |
| /// When <tt>if_\<If,Then,Else\></tt> is used as a transform, \c If, |
| /// \c Then and \c Else must be Proto transforms. When applying |
| /// the transform to an expression \c E, state \c S and data \c V, |
| /// if <tt>boost::result_of\<when\<_,If\>(E,S,V)\>::type::value</tt> |
| /// is \c true then the \c Then transform is applied; otherwise |
| /// the \c Else transform is applied. |
| /// |
| /// \code |
| /// // Match a terminal. If the terminal is integral, return |
| /// // mpl::true_; otherwise, return mpl::false_. |
| /// struct IsIntegral2 |
| /// : when< |
| /// terminal<_> |
| /// , if_< |
| /// is_integral<_value>() |
| /// , mpl::true_() |
| /// , mpl::false_() |
| /// > |
| /// > |
| /// {}; |
| /// \endcode |
| template< |
| typename If |
| , typename Then // = _ |
| , typename Else // = not_<_> |
| > |
| struct if_ : transform<if_<If, Then, Else> > |
| { |
| typedef if_ proto_grammar; |
| |
| template<typename Expr, typename State, typename Data> |
| struct impl : transform_impl<Expr, State, Data> |
| { |
| typedef |
| typename when<_, If>::template impl<Expr, State, Data>::result_type |
| condition; |
| |
| typedef |
| typename mpl::if_c< |
| remove_reference<condition>::type::value |
| , when<_, Then> |
| , when<_, Else> |
| >::type |
| which; |
| |
| typedef typename which::template impl<Expr, State, Data>::result_type result_type; |
| |
| /// \param e An expression |
| /// \param s The current state |
| /// \param d A data of arbitrary type |
| /// \return <tt>which::impl<Expr, State, Data>()(e, s, d)</tt> |
| result_type operator ()( |
| typename impl::expr_param e |
| , typename impl::state_param s |
| , typename impl::data_param d |
| ) const |
| { |
| return typename which::template impl<Expr, State, Data>()(e, s, d); |
| } |
| }; |
| }; |
| |
| /// \brief For matching one of a set of alternate grammars. Alternates |
| /// tried in order to avoid ambiguity. When used as a transform, \c or_\<\> |
| /// applies the transform associated with the first grammar that matches |
| /// the expression. |
| /// |
| /// An expression type \c E matches <tt>or_\<B0,B1,...Bn\></tt> if \c E |
| /// matches any \c Bx for \c x in <tt>[0,n)</tt>. |
| /// |
| /// When applying <tt>or_\<B0,B1,...Bn\></tt> as a transform with an |
| /// expression \c e of type \c E, state \c s and data \c d, it is |
| /// equivalent to <tt>Bx()(e, s, d)</tt>, where \c x is the lowest |
| /// number such that <tt>matches\<E,Bx\>::value</tt> is \c true. |
| template<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G)> |
| struct or_ : transform<or_<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, G)> > |
| { |
| typedef or_ proto_grammar; |
| |
| /// \param e An expression |
| /// \param s The current state |
| /// \param d A data of arbitrary type |
| /// \pre <tt>matches\<Expr,or_\>::value</tt> is \c true. |
| /// \return <tt>which()(e, s, d)</tt>, where <tt>which</tt> is the |
| /// sub-grammar that matched <tt>Expr</tt>. |
| |
| template<typename Expr, typename State, typename Data> |
| struct impl |
| : detail::matches_<typename Expr::proto_grammar, or_> |
| ::which::template impl<Expr, State, Data> |
| {}; |
| |
| template<typename Expr, typename State, typename Data> |
| struct impl<Expr &, State, Data> |
| : detail::matches_<typename Expr::proto_grammar, or_> |
| ::which::template impl<Expr &, State, Data> |
| {}; |
| }; |
| |
| /// \brief For matching all of a set of grammars. When used as a |
| /// transform, \c and_\<\> applies the transforms associated with |
| /// the each grammar in the set, and returns the result of the last. |
| /// |
| /// An expression type \c E matches <tt>and_\<B0,B1,...Bn\></tt> if \c E |
| /// matches all \c Bx for \c x in <tt>[0,n)</tt>. |
| /// |
| /// When applying <tt>and_\<B0,B1,...Bn\></tt> as a transform with an |
| /// expression \c e, state \c s and data \c d, it is |
| /// equivalent to <tt>(B0()(e, s, d),B1()(e, s, d),...Bn()(e, s, d))</tt>. |
| template<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G)> |
| struct and_ : transform<and_<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, G)> > |
| { |
| typedef and_ proto_grammar; |
| |
| template<typename Expr, typename State, typename Data> |
| struct impl |
| : detail::_and_impl<and_, Expr, State, Data> |
| {}; |
| }; |
| |
| /// \brief For matching one of a set of alternate grammars, which |
| /// are looked up based on an expression's tag type. When used as a |
| /// transform, \c switch_\<\> applies the transform associated with |
| /// the grammar that matches the expression. |
| /// |
| /// \note \c switch_\<\> is functionally identical to \c or_\<\> but |
| /// is often more efficient. It does a fast, O(1) lookup based on an |
| /// expression's tag type to find a sub-grammar that may potentially |
| /// match the expression. |
| /// |
| /// An expression type \c E matches <tt>switch_\<C\></tt> if \c E |
| /// matches <tt>C::case_\<E::proto_tag\></tt>. |
| /// |
| /// When applying <tt>switch_\<C\></tt> as a transform with an |
| /// expression \c e of type \c E, state \c s and data \c d, it is |
| /// equivalent to <tt>C::case_\<E::proto_tag\>()(e, s, d)</tt>. |
| template<typename Cases> |
| struct switch_ : transform<switch_<Cases> > |
| { |
| typedef switch_ proto_grammar; |
| |
| /// \param e An expression |
| /// \param s The current state |
| /// \param d A data of arbitrary type |
| /// \pre <tt>matches\<Expr,switch_\>::value</tt> is \c true. |
| /// \return <tt>which()(e, s, d)</tt>, where <tt>which</tt> is |
| /// <tt>Cases::case_<typename Expr::proto_tag></tt> |
| |
| template<typename Expr, typename State, typename Data> |
| struct impl |
| : Cases::template case_<typename Expr::proto_tag>::template impl<Expr, State, Data> |
| {}; |
| |
| template<typename Expr, typename State, typename Data> |
| struct impl<Expr &, State, Data> |
| : Cases::template case_<typename Expr::proto_tag>::template impl<Expr &, State, Data> |
| {}; |
| }; |
| |
| /// \brief For forcing exact matches of terminal types. |
| /// |
| /// By default, matching terminals ignores references and |
| /// cv-qualifiers. For instance, a terminal expression of |
| /// type <tt>terminal\<int const &\>::type</tt> will match |
| /// the grammar <tt>terminal\<int\></tt>. If that is not |
| /// desired, you can force an exact match with |
| /// <tt>terminal\<exact\<int\> \></tt>. This will only |
| /// match integer terminals where the terminal is held by |
| /// value. |
| template<typename T> |
| struct exact |
| {}; |
| |
| /// \brief For matching terminals that are convertible to |
| /// a type. |
| /// |
| /// Use \c convertible_to\<\> to match a terminal that is |
| /// convertible to some type. For example, the grammar |
| /// <tt>terminal\<convertible_to\<int\> \></tt> will match |
| /// any terminal whose argument is convertible to an integer. |
| /// |
| /// \note The trait \c is_convertible\<\> from Boost.Type_traits |
| /// is used to determinal convertibility. |
| template<typename T> |
| struct convertible_to |
| {}; |
| |
| /// \brief For matching a Grammar to a variable number of |
| /// sub-expressions. |
| /// |
| /// An expression type <tt>expr\<AT, listN\<A0,...An,U0,...Um\> \></tt> |
| /// matches a grammar <tt>expr\<BT, listM\<B0,...Bn,vararg\<V\> \> \></tt> |
| /// if \c BT is \c _ or \c AT, and if \c Ax matches \c Bx |
| /// for each \c x in <tt>[0,n)</tt> and if \c Ux matches \c V |
| /// for each \c x in <tt>[0,m)</tt>. |
| /// |
| /// For example: |
| /// |
| /// \code |
| /// // Match any function call expression, irregardless |
| /// // of the number of function arguments: |
| /// struct Function |
| /// : function< vararg<_> > |
| /// {}; |
| /// \endcode |
| /// |
| /// When used as a transform, <tt>vararg\<G\></tt> applies |
| /// <tt>G</tt>'s transform. |
| template<typename Grammar> |
| struct vararg |
| : Grammar |
| { |
| /// INTERNAL ONLY |
| typedef void proto_is_vararg_; |
| }; |
| |
| /// INTERNAL ONLY |
| /// |
| template<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G)> |
| struct is_callable<or_<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, G)> > |
| : mpl::true_ |
| {}; |
| |
| /// INTERNAL ONLY |
| /// |
| template<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G)> |
| struct is_callable<and_<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, G)> > |
| : mpl::true_ |
| {}; |
| |
| /// INTERNAL ONLY |
| /// |
| template<typename Grammar> |
| struct is_callable<not_<Grammar> > |
| : mpl::true_ |
| {}; |
| |
| /// INTERNAL ONLY |
| /// |
| template<typename If, typename Then, typename Else> |
| struct is_callable<if_<If, Then, Else> > |
| : mpl::true_ |
| {}; |
| |
| /// INTERNAL ONLY |
| /// |
| template<typename Grammar> |
| struct is_callable<vararg<Grammar> > |
| : mpl::true_ |
| {}; |
| |
| }} |
| |
| #if defined(_MSC_VER) && (_MSC_VER >= 1020) |
| # pragma warning(pop) |
| #endif |
| |
| #endif |
| |
| #elif BOOST_PP_ITERATION_FLAGS() == 1 |
| |
| #define N BOOST_PP_ITERATION() |
| |
| // Assymetry here between the handling of and_N and or_N because |
| // and_N is used by lambda_matches up to BOOST_PROTO_MAX_ARITY, |
| // regardless of how low BOOST_PROTO_MAX_LOGICAL_ARITY is. |
| template<bool B, BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(N), typename P)> |
| struct BOOST_PP_CAT(and_, N) |
| #if 2 == N |
| : mpl::bool_<P0::value> |
| {}; |
| #else |
| : BOOST_PP_CAT(and_, BOOST_PP_DEC(N))< |
| P0::value BOOST_PP_COMMA_IF(BOOST_PP_SUB(N,2)) |
| BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_DEC(N), P) |
| > |
| {}; |
| #endif |
| |
| template<BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(N), typename P)> |
| struct BOOST_PP_CAT(and_, N)<false, BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(N), P)> |
| : mpl::false_ |
| {}; |
| |
| #if N <= BOOST_PROTO_MAX_LOGICAL_ARITY |
| template<BOOST_PP_ENUM_PARAMS(N, typename G), typename Expr, typename State, typename Data> |
| struct _and_impl<proto::and_<BOOST_PP_ENUM_PARAMS(N, G)>, Expr, State, Data> |
| : proto::transform_impl<Expr, State, Data> |
| { |
| #define M0(Z, N, DATA) \ |
| typedef \ |
| typename proto::when<proto::_, BOOST_PP_CAT(G, N)> \ |
| ::template impl<Expr, State, Data> \ |
| BOOST_PP_CAT(Gimpl, N); \ |
| /**/ |
| BOOST_PP_REPEAT(N, M0, ~) |
| |
| typedef typename BOOST_PP_CAT(Gimpl, BOOST_PP_DEC(N))::result_type result_type; |
| |
| result_type operator()( |
| typename _and_impl::expr_param e |
| , typename _and_impl::state_param s |
| , typename _and_impl::data_param d |
| ) const |
| { |
| // expands to (G0()(e,s,d),G1()(e,s,d),...); |
| return (BOOST_PP_ENUM_BINARY_PARAMS(N, Gimpl, ()(e,s,d) BOOST_PP_INTERCEPT)); |
| } |
| |
| #undef M0 |
| }; |
| |
| template<bool B, typename Expr, BOOST_PP_ENUM_PARAMS(N, typename G)> |
| struct BOOST_PP_CAT(or_, N) |
| #if 2 == N |
| : mpl::bool_<matches_<Expr, typename G1::proto_grammar>::value> |
| { |
| typedef G1 which; |
| }; |
| #else |
| : BOOST_PP_CAT(or_, BOOST_PP_DEC(N))< |
| matches_<Expr, typename G1::proto_grammar>::value |
| , Expr, BOOST_PP_ENUM_SHIFTED_PARAMS(N, G) |
| > |
| {}; |
| #endif |
| |
| template<typename Expr BOOST_PP_ENUM_TRAILING_PARAMS(N, typename G)> |
| struct BOOST_PP_CAT(or_, N)<true, Expr, BOOST_PP_ENUM_PARAMS(N, G)> |
| : mpl::true_ |
| { |
| typedef G0 which; |
| }; |
| |
| // handle proto::or_ |
| template<typename Expr, BOOST_PP_ENUM_PARAMS(N, typename G)> |
| struct matches_<Expr, proto::or_<BOOST_PP_ENUM_PARAMS(N, G)> > |
| : BOOST_PP_CAT(or_, N)< |
| matches_<Expr, typename G0::proto_grammar>::value, |
| Expr, BOOST_PP_ENUM_PARAMS(N, G) |
| > |
| {}; |
| |
| // handle proto::and_ |
| template<typename Expr, BOOST_PP_ENUM_PARAMS(N, typename G)> |
| struct matches_<Expr, proto::and_<BOOST_PP_ENUM_PARAMS(N, G)> > |
| : detail::BOOST_PP_CAT(and_, N)< |
| BOOST_PROTO_DEFINE_MATCHES(~, 0, ~)::value, |
| BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFINE_MATCHES, ~) |
| > |
| {}; |
| #endif |
| |
| #undef N |
| |
| #elif BOOST_PP_ITERATION_FLAGS() == 2 |
| |
| #define N BOOST_PP_ITERATION() |
| |
| template<typename Args, typename Back, long To> |
| struct vararg_matches_impl<Args, Back, N, To> |
| : and_2< |
| matches_< |
| typename detail::expr_traits<typename Args::BOOST_PP_CAT(child, BOOST_PP_DEC(N))>::value_type::proto_grammar |
| , Back |
| >::value |
| , vararg_matches_impl<Args, Back, N + 1, To> |
| > |
| {}; |
| |
| template<typename Args, typename Back> |
| struct vararg_matches_impl<Args, Back, N, N> |
| : matches_< |
| typename detail::expr_traits<typename Args::BOOST_PP_CAT(child, BOOST_PP_DEC(N))>::value_type::proto_grammar |
| , Back |
| > |
| {}; |
| |
| template< |
| template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class T |
| BOOST_PP_ENUM_TRAILING_PARAMS(N, typename Expr) |
| BOOST_PP_ENUM_TRAILING_PARAMS(N, typename Grammar) |
| > |
| struct lambda_matches< |
| T<BOOST_PP_ENUM_PARAMS(N, Expr)> |
| , T<BOOST_PP_ENUM_PARAMS(N, Grammar)> |
| BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(N) |
| > |
| : BOOST_PP_CAT(and_, N)< |
| BOOST_PROTO_DEFINE_LAMBDA_MATCHES(~, 0, ~)::value, |
| BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFINE_LAMBDA_MATCHES, ~) |
| > |
| {}; |
| |
| template<typename Tag, typename Args1, typename Args2> |
| struct matches_< proto::basic_expr<Tag, Args1, N>, proto::basic_expr<Tag, Args2, N> > |
| : BOOST_PP_CAT(and_, N)< |
| BOOST_PROTO_MATCHES_N_FUN(~, 0, ~)::value, |
| BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_MATCHES_N_FUN, ~) |
| > |
| {}; |
| |
| template<typename Tag, typename Args1, typename Args2> |
| struct matches_< proto::basic_expr<Tag, Args1, N>, proto::basic_expr<proto::_, Args2, N> > |
| : BOOST_PP_CAT(and_, N)< |
| BOOST_PROTO_MATCHES_N_FUN(~, 0, ~)::value, |
| BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_MATCHES_N_FUN, ~) |
| > |
| {}; |
| |
| #undef N |
| |
| #endif |
| |