Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: /// \file matches.hpp
Chris@16: /// Contains definition of matches\<\> metafunction for determining if
Chris@16: /// a given expression matches a given pattern.
Chris@16: //
Chris@16: //  Copyright 2008 Eric Niebler. Distributed under the Boost
Chris@16: //  Software License, Version 1.0. (See accompanying file
Chris@16: //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Chris@16: 
Chris@16: #ifndef BOOST_PROTO_MATCHES_HPP_EAN_11_03_2006
Chris@16: #define BOOST_PROTO_MATCHES_HPP_EAN_11_03_2006
Chris@16: 
Chris@16: #include <boost/config.hpp>
Chris@16: #include <boost/detail/workaround.hpp>
Chris@16: #include <boost/preprocessor/cat.hpp>
Chris@16: #include <boost/preprocessor/arithmetic/dec.hpp>
Chris@16: #include <boost/preprocessor/arithmetic/sub.hpp>
Chris@16: #include <boost/preprocessor/iteration/iterate.hpp>
Chris@16: #include <boost/preprocessor/facilities/intercept.hpp>
Chris@16: #include <boost/preprocessor/punctuation/comma_if.hpp>
Chris@16: #include <boost/preprocessor/repetition/enum.hpp>
Chris@16: #include <boost/preprocessor/repetition/enum_params.hpp>
Chris@16: #include <boost/preprocessor/repetition/enum_shifted.hpp>
Chris@16: #include <boost/preprocessor/repetition/enum_binary_params.hpp>
Chris@16: #include <boost/preprocessor/repetition/enum_shifted_params.hpp>
Chris@16: #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
Chris@16: #include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
Chris@16: #include <boost/preprocessor/repetition/repeat.hpp>
Chris@16: #include <boost/config.hpp>
Chris@16: #include <boost/mpl/logical.hpp>
Chris@16: #include <boost/mpl/eval_if.hpp>
Chris@16: #include <boost/proto/detail/template_arity.hpp>
Chris@16: #include <boost/utility/enable_if.hpp>
Chris@16: #if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
Chris@16: #include <boost/type_traits/is_array.hpp>
Chris@16: #endif
Chris@16: #include <boost/type_traits/is_const.hpp>
Chris@16: #include <boost/type_traits/is_convertible.hpp>
Chris@16: #include <boost/type_traits/is_reference.hpp>
Chris@16: #include <boost/type_traits/is_pointer.hpp>
Chris@16: #include <boost/proto/proto_fwd.hpp>
Chris@16: #include <boost/proto/traits.hpp>
Chris@16: #include <boost/proto/transform/when.hpp>
Chris@16: #include <boost/proto/transform/impl.hpp>
Chris@16: 
Chris@101: #if defined(_MSC_VER)
Chris@16: # pragma warning(push)
Chris@16: # pragma warning(disable:4305) // 'specialization' : truncation from 'const int' to 'bool'
Chris@16: #endif
Chris@16: 
Chris@16: #define BOOST_PROTO_LOGICAL_typename_G  BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G)
Chris@16: #define BOOST_PROTO_LOGICAL_G           BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, G)
Chris@16: 
Chris@16: namespace boost { namespace proto
Chris@16: {
Chris@16: 
Chris@16:     namespace detail
Chris@16:     {
Chris@16:         template<typename Expr, typename BasicExpr, typename Grammar>
Chris@16:         struct matches_;
Chris@16: 
Chris@16:         template<bool B, typename Pred>
Chris@16:         struct and_2;
Chris@16: 
Chris@16:         template<typename And, typename Expr, typename State, typename Data>
Chris@16:         struct _and_impl;
Chris@16: 
Chris@16:         template<typename T, typename U>
Chris@16:         struct array_matches
Chris@16:           : mpl::false_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T, std::size_t M>
Chris@16:         struct array_matches<T[M], T *>
Chris@16:           : mpl::true_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T, std::size_t M>
Chris@16:         struct array_matches<T[M], T const *>
Chris@16:           : mpl::true_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T, std::size_t M>
Chris@16:         struct array_matches<T[M], T[proto::N]>
Chris@16:           : mpl::true_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T, typename U
Chris@16:             BOOST_PROTO_TEMPLATE_ARITY_PARAM(long Arity = detail::template_arity<U>::value)
Chris@16:         >
Chris@16:         struct lambda_matches
Chris@16:           : mpl::false_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T>
Chris@16:         struct lambda_matches<T, proto::_ BOOST_PROTO_TEMPLATE_ARITY_PARAM(-1)>
Chris@16:           : mpl::true_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T>
Chris@16:         struct lambda_matches<T, T BOOST_PROTO_TEMPLATE_ARITY_PARAM(-1)>
Chris@16:           : mpl::true_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T, std::size_t M, typename U>
Chris@16:         struct lambda_matches<T[M], U BOOST_PROTO_TEMPLATE_ARITY_PARAM(-1)>
Chris@16:           : array_matches<T[M], U>
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T, std::size_t M>
Chris@16:         struct lambda_matches<T[M], _ BOOST_PROTO_TEMPLATE_ARITY_PARAM(-1)>
Chris@16:           : mpl::true_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T, std::size_t M>
Chris@16:         struct lambda_matches<T[M], T[M] BOOST_PROTO_TEMPLATE_ARITY_PARAM(-1)>
Chris@16:           : mpl::true_
Chris@16:         {};
Chris@16: 
Chris@16:         template<template<typename> class T, typename Expr0, typename Grammar0>
Chris@16:         struct lambda_matches<T<Expr0>, T<Grammar0> BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) >
Chris@16:           : lambda_matches<Expr0, Grammar0>
Chris@16:         {};
Chris@16: 
Chris@16:         // vararg_matches_impl
Chris@16:         template<typename Args1, typename Back, long From, long To>
Chris@16:         struct vararg_matches_impl;
Chris@16: 
Chris@16:         // vararg_matches
Chris@16:         template<typename Expr, typename Args1, typename Args2, typename Back, bool Can, bool Zero, typename Void = void>
Chris@16:         struct vararg_matches
Chris@16:           : mpl::false_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename Expr, typename Args1, typename Args2, typename Back>
Chris@16:         struct vararg_matches<Expr, Args1, Args2, Back, true, true, typename Back::proto_is_vararg_>
Chris@16:           : matches_<
Chris@16:                 Expr
Chris@16:               , proto::basic_expr<ignore, Args1, Args1::arity>
Chris@16:               , proto::basic_expr<ignore, Args2, Args1::arity>
Chris@16:             >
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename Expr, typename Args1, typename Args2, typename Back>
Chris@16:         struct vararg_matches<Expr, Args1, Args2, Back, true, false, typename Back::proto_is_vararg_>
Chris@16:           : and_2<
Chris@16:                 matches_<
Chris@16:                     Expr
Chris@16:                   , proto::basic_expr<ignore, Args1, Args2::arity>
Chris@16:                   , proto::basic_expr<ignore, Args2, Args2::arity>
Chris@16:                 >::value
Chris@16:               , vararg_matches_impl<Args1, typename Back::proto_grammar, Args2::arity + 1, Args1::arity>
Chris@16:             >
Chris@16:         {};
Chris@16: 
Chris@16:         // How terminal_matches<> handles references and cv-qualifiers.
Chris@16:         // The cv and ref matter *only* if the grammar has a top-level ref.
Chris@16:         //
Chris@16:         // Expr       |   Grammar    |  Matches?
Chris@16:         // -------------------------------------
Chris@16:         // T              T             yes
Chris@16:         // T &            T             yes
Chris@16:         // T const &      T             yes
Chris@16:         // T              T &           no
Chris@16:         // T &            T &           yes
Chris@16:         // T const &      T &           no
Chris@16:         // T              T const &     no
Chris@16:         // T &            T const &     no
Chris@16:         // T const &      T const &     yes
Chris@16: 
Chris@16:         template<typename T, typename U>
Chris@16:         struct is_cv_ref_compatible
Chris@16:           : mpl::true_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T, typename U>
Chris@16:         struct is_cv_ref_compatible<T, U &>
Chris@16:           : mpl::false_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T, typename U>
Chris@16:         struct is_cv_ref_compatible<T &, U &>
Chris@16:           : mpl::bool_<is_const<T>::value == is_const<U>::value>
Chris@16:         {};
Chris@16: 
Chris@16:     #if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
Chris@16:         // MSVC-7.1 has lots of problems with array types that have been
Chris@16:         // deduced. Partially specializing terminal_matches<> on array types
Chris@16:         // doesn't seem to work.
Chris@16:         template<
Chris@16:             typename T
Chris@16:           , typename U
Chris@16:           , bool B = is_array<BOOST_PROTO_UNCVREF(T)>::value
Chris@16:         >
Chris@16:         struct terminal_array_matches
Chris@16:           : mpl::false_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T, typename U, std::size_t M>
Chris@16:         struct terminal_array_matches<T, U(&)[M], true>
Chris@16:           : is_convertible<T, U(&)[M]>
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T, typename U>
Chris@16:         struct terminal_array_matches<T, U(&)[proto::N], true>
Chris@16:           : is_convertible<T, U *>
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T, typename U>
Chris@16:         struct terminal_array_matches<T, U *, true>
Chris@16:           : is_convertible<T, U *>
Chris@16:         {};
Chris@16: 
Chris@16:         // terminal_matches
Chris@16:         template<typename T, typename U>
Chris@16:         struct terminal_matches
Chris@16:           : mpl::or_<
Chris@16:                 mpl::and_<
Chris@16:                     is_cv_ref_compatible<T, U>
Chris@16:                   , lambda_matches<
Chris@16:                         BOOST_PROTO_UNCVREF(T)
Chris@16:                       , BOOST_PROTO_UNCVREF(U)
Chris@16:                     >
Chris@16:                 >
Chris@16:               , terminal_array_matches<T, U>
Chris@16:             >
Chris@16:         {};
Chris@16:     #else
Chris@16:         // terminal_matches
Chris@16:         template<typename T, typename U>
Chris@16:         struct terminal_matches
Chris@16:           : mpl::and_<
Chris@16:                 is_cv_ref_compatible<T, U>
Chris@16:               , lambda_matches<
Chris@16:                     BOOST_PROTO_UNCVREF(T)
Chris@16:                   , BOOST_PROTO_UNCVREF(U)
Chris@16:                 >
Chris@16:             >
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T, std::size_t M>
Chris@16:         struct terminal_matches<T(&)[M], T(&)[proto::N]>
Chris@16:           : mpl::true_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T, std::size_t M>
Chris@16:         struct terminal_matches<T(&)[M], T *>
Chris@16:           : mpl::true_
Chris@16:         {};
Chris@16: 
Chris@16:         // Avoid ambiguity errors on MSVC
Chris@16:         #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
Chris@16:         template<typename T, std::size_t M>
Chris@16:         struct terminal_matches<T const (&)[M], T const[M]>
Chris@16:           : mpl::true_
Chris@16:         {};
Chris@16:         #endif
Chris@16:     #endif
Chris@16: 
Chris@16:         template<typename T>
Chris@16:         struct terminal_matches<T, T>
Chris@16:           : mpl::true_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T>
Chris@16:         struct terminal_matches<T &, T>
Chris@16:           : mpl::true_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T>
Chris@16:         struct terminal_matches<T const &, T>
Chris@16:           : mpl::true_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T>
Chris@16:         struct terminal_matches<T, proto::_>
Chris@16:           : mpl::true_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T>
Chris@16:         struct terminal_matches<T, exact<T> >
Chris@16:           : mpl::true_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T, typename U>
Chris@16:         struct terminal_matches<T, proto::convertible_to<U> >
Chris@16:           : is_convertible<T, U>
Chris@16:         {};
Chris@16: 
Chris@16:         // matches_
Chris@16:         template<typename Expr, typename BasicExpr, typename Grammar>
Chris@16:         struct matches_
Chris@16:           : mpl::false_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename Expr, typename BasicExpr>
Chris@16:         struct matches_< Expr, BasicExpr, proto::_ >
Chris@16:           : mpl::true_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename Expr, typename Tag, typename Args1, long N1, typename Args2, long N2>
Chris@16:         struct matches_< Expr, proto::basic_expr<Tag, Args1, N1>, proto::basic_expr<Tag, Args2, N2> >
Chris@16:           : vararg_matches< Expr, Args1, Args2, typename Args2::back_, (N1+2 > N2), (N2 > N1) >
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename Expr, typename Tag, typename Args1, long N1, typename Args2, long N2>
Chris@16:         struct matches_< Expr, proto::basic_expr<Tag, Args1, N1>, proto::basic_expr<proto::_, Args2, N2> >
Chris@16:           : vararg_matches< Expr, Args1, Args2, typename Args2::back_, (N1+2 > N2), (N2 > N1) >
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename Expr, typename Tag, typename Args1, typename Args2>
Chris@16:         struct matches_< Expr, proto::basic_expr<Tag, Args1, 0>, proto::basic_expr<Tag, Args2, 0> >
Chris@16:           : terminal_matches<typename Args1::child0, typename Args2::child0>
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename Expr, typename Tag, typename Args1, typename Args2, long N2>
Chris@16:         struct matches_< Expr, proto::basic_expr<Tag, Args1, 0>, proto::basic_expr<proto::_, Args2, N2> >
Chris@16:           : mpl::false_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename Expr, typename Tag, typename Args1, typename Args2>
Chris@16:         struct matches_< Expr, proto::basic_expr<Tag, Args1, 0>, proto::basic_expr<proto::_, Args2, 0> >
Chris@16:           : terminal_matches<typename Args1::child0, typename Args2::child0>
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename Expr, typename Tag, typename Args1, typename Args2>
Chris@16:         struct matches_< Expr, proto::basic_expr<Tag, Args1, 1>, proto::basic_expr<Tag, Args2, 1> >
Chris@16:           : matches_<
Chris@16:                 typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr
Chris@16:               , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar
Chris@16:               , typename Args2::child0::proto_grammar
Chris@16:             >
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename Expr, typename Tag, typename Args1, typename Args2>
Chris@16:         struct matches_< Expr, proto::basic_expr<Tag, Args1, 1>, proto::basic_expr<proto::_, Args2, 1> >
Chris@16:           : matches_<
Chris@16:                 typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr
Chris@16:               , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar
Chris@16:               , typename Args2::child0::proto_grammar
Chris@16:             >
Chris@16:         {};
Chris@16: 
Chris@16:         #include <boost/proto/detail/and_n.hpp>
Chris@16:         #include <boost/proto/detail/or_n.hpp>
Chris@16:         #include <boost/proto/detail/matches_.hpp>
Chris@16:         #include <boost/proto/detail/vararg_matches_impl.hpp>
Chris@16:         #include <boost/proto/detail/lambda_matches.hpp>
Chris@16: 
Chris@16:         // handle proto::if_
Chris@16:         template<typename Expr, typename Tag, typename Args, long Arity, typename If, typename Then, typename Else>
Chris@16:         struct matches_<Expr, proto::basic_expr<Tag, Args, Arity>, proto::if_<If, Then, Else> >
Chris@16:           : mpl::eval_if_c<
Chris@16:                 static_cast<bool>(
Chris@16:                     remove_reference<
Chris@16:                         typename when<_, If>::template impl<Expr, int, int>::result_type
Chris@16:                     >::type::value
Chris@16:                 )
Chris@16:               , matches_<Expr, proto::basic_expr<Tag, Args, Arity>, typename Then::proto_grammar>
Chris@16:               , matches_<Expr, proto::basic_expr<Tag, Args, Arity>, typename Else::proto_grammar>
Chris@16:             >::type
Chris@16:         {
Chris@16:             typedef
Chris@16:                 typename mpl::if_c<
Chris@16:                     static_cast<bool>(
Chris@16:                         remove_reference<
Chris@16:                             typename when<_, If>::template impl<Expr, int, int>::result_type
Chris@16:                         >::type::value
Chris@16:                     )
Chris@16:                   , Then
Chris@16:                   , Else
Chris@16:                 >::type
Chris@16:             which;
Chris@16:         };
Chris@16: 
Chris@16:         // handle degenerate cases of proto::or_
Chris@16:         template<typename Expr, typename BasicExpr>
Chris@16:         struct matches_<Expr, BasicExpr, or_<> >
Chris@16:           : mpl::false_
Chris@16:         {
Chris@16:             typedef not_<_> which;
Chris@16:         };
Chris@16: 
Chris@16:         template<typename Expr, typename BasicExpr, typename G0>
Chris@16:         struct matches_<Expr, BasicExpr, or_<G0> >
Chris@16:           : matches_<Expr, BasicExpr, typename G0::proto_grammar>
Chris@16:         {
Chris@16:             typedef G0 which;
Chris@16:         };
Chris@16: 
Chris@16:         // handle degenerate cases of proto::and_
Chris@16:         template<typename Expr, typename BasicExpr>
Chris@16:         struct matches_<Expr, BasicExpr, and_<> >
Chris@16:           : mpl::true_
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename Expr, typename BasicExpr, typename G0>
Chris@16:         struct matches_<Expr, BasicExpr, and_<G0> >
Chris@16:           : matches_<Expr, BasicExpr, typename G0::proto_grammar>
Chris@16:         {};
Chris@16: 
Chris@16:         // handle proto::not_
Chris@16:         template<typename Expr, typename BasicExpr, typename Grammar>
Chris@16:         struct matches_<Expr, BasicExpr, not_<Grammar> >
Chris@16:           : mpl::not_<matches_<Expr, BasicExpr, typename Grammar::proto_grammar> >
Chris@16:         {};
Chris@16: 
Chris@16:         // handle proto::switch_
Chris@16:         template<typename Expr, typename Tag, typename Args, long Arity, typename Cases, typename Transform>
Chris@16:         struct matches_<Expr, proto::basic_expr<Tag, Args, Arity>, switch_<Cases, Transform> >
Chris@16:           : matches_<
Chris@16:                 Expr
Chris@16:               , proto::basic_expr<Tag, Args, Arity>
Chris@16:               , typename Cases::template case_<
Chris@16:                     typename when<_,Transform>::template impl<Expr,int,int>::result_type
Chris@16:                 >::proto_grammar
Chris@16:             >
Chris@16:         {
Chris@16:             typedef
Chris@16:                 typename Cases::template case_<
Chris@16:                     typename when<_, Transform>::template impl<Expr, int, int>::result_type
Chris@16:                 >
Chris@16:             which;
Chris@16:         };
Chris@16: 
Chris@16:         // handle proto::switch_ with the default Transform for specially for better compile times
Chris@16:         template<typename Expr, typename Tag, typename Args, long Arity, typename Cases>
Chris@16:         struct matches_<Expr, proto::basic_expr<Tag, Args, Arity>, switch_<Cases> >
Chris@16:           : matches_<
Chris@16:                 Expr
Chris@16:               , proto::basic_expr<Tag, Args, Arity>
Chris@16:               , typename Cases::template case_<Tag>::proto_grammar
Chris@16:             >
Chris@16:         {
Chris@16:             typedef typename Cases::template case_<Tag> which;
Chris@16:         };
Chris@16:     }
Chris@16: 
Chris@16:     /// \brief A Boolean metafunction that evaluates whether a given
Chris@16:     /// expression type matches a grammar.
Chris@16:     ///
Chris@16:     /// <tt>matches\<Expr,Grammar\></tt> inherits (indirectly) from
Chris@16:     /// \c mpl::true_ if <tt>Expr::proto_grammar</tt> matches
Chris@16:     /// <tt>Grammar::proto_grammar</tt>, and from \c mpl::false_
Chris@16:     /// otherwise.
Chris@16:     ///
Chris@16:     /// Non-terminal expressions are matched against a grammar
Chris@16:     /// according to the following rules:
Chris@16:     ///
Chris@16:     /// \li The wildcard pattern, \c _, matches any expression.
Chris@16:     /// \li An expression <tt>expr\<AT, listN\<A0,A1,...An\> \></tt>
Chris@16:     ///     matches a grammar <tt>expr\<BT, listN\<B0,B1,...Bn\> \></tt>
Chris@16:     ///     if \c BT is \c _ or \c AT, and if \c Ax matches \c Bx for
Chris@16:     ///     each \c x in <tt>[0,n)</tt>.
Chris@16:     /// \li An expression <tt>expr\<AT, listN\<A0,...An,U0,...Um\> \></tt>
Chris@16:     ///     matches a grammar <tt>expr\<BT, listM\<B0,...Bn,vararg\<V\> \> \></tt>
Chris@16:     ///     if \c BT is \c _ or \c AT, and if \c Ax matches \c Bx
Chris@16:     ///     for each \c x in <tt>[0,n)</tt> and if \c Ux matches \c V
Chris@16:     ///     for each \c x in <tt>[0,m)</tt>.
Chris@16:     /// \li An expression \c E matches <tt>or_\<B0,B1,...Bn\></tt> if \c E
Chris@16:     ///     matches some \c Bx for \c x in <tt>[0,n)</tt>.
Chris@16:     /// \li An expression \c E matches <tt>and_\<B0,B1,...Bn\></tt> if \c E
Chris@16:     ///     matches all \c Bx for \c x in <tt>[0,n)</tt>.
Chris@16:     /// \li An expression \c E matches <tt>if_\<T,U,V\></tt> if
Chris@16:     ///     <tt>boost::result_of\<when\<_,T\>(E,int,int)\>::type::value</tt>
Chris@16:     ///     is \c true and \c E matches \c U; or, if
Chris@16:     ///     <tt>boost::result_of\<when\<_,T\>(E,int,int)\>::type::value</tt>
Chris@16:     ///     is \c false and \c E matches \c V. (Note: \c U defaults to \c _
Chris@16:     ///     and \c V defaults to \c not_\<_\>.)
Chris@16:     /// \li An expression \c E matches <tt>not_\<T\></tt> if \c E does
Chris@16:     ///     not match \c T.
Chris@16:     /// \li An expression \c E matches <tt>switch_\<C,T\></tt> if
Chris@16:     ///     \c E matches <tt>C::case_\<boost::result_of\<T(E)\>::type\></tt>.
Chris@16:     ///     (Note: T defaults to <tt>tag_of\<_\>()</tt>.)
Chris@16:     ///
Chris@16:     /// A terminal expression <tt>expr\<AT,term\<A\> \></tt> matches
Chris@16:     /// a grammar <tt>expr\<BT,term\<B\> \></tt> if \c BT is \c AT or
Chris@16:     /// \c proto::_ and if one of the following is true:
Chris@16:     ///
Chris@16:     /// \li \c B is the wildcard pattern, \c _
Chris@16:     /// \li \c A is \c B
Chris@16:     /// \li \c A is <tt>B &</tt>
Chris@16:     /// \li \c A is <tt>B const &</tt>
Chris@16:     /// \li \c B is <tt>exact\<A\></tt>
Chris@16:     /// \li \c B is <tt>convertible_to\<X\></tt> and
Chris@16:     ///     <tt>is_convertible\<A,X\>::value</tt> is \c true.
Chris@16:     /// \li \c A is <tt>X[M]</tt> or <tt>X(&)[M]</tt> and
Chris@16:     ///     \c B is <tt>X[proto::N]</tt>.
Chris@16:     /// \li \c A is <tt>X(&)[M]</tt> and \c B is <tt>X(&)[proto::N]</tt>.
Chris@16:     /// \li \c A is <tt>X[M]</tt> or <tt>X(&)[M]</tt> and
Chris@16:     ///     \c B is <tt>X*</tt>.
Chris@16:     /// \li \c B lambda-matches \c A (see below).
Chris@16:     ///
Chris@16:     /// A type \c B lambda-matches \c A if one of the following is true:
Chris@16:     ///
Chris@16:     /// \li \c B is \c A
Chris@16:     /// \li \c B is the wildcard pattern, \c _
Chris@16:     /// \li \c B is <tt>T\<B0,B1,...Bn\></tt> and \c A is
Chris@16:     ///     <tt>T\<A0,A1,...An\></tt> and for each \c x in
Chris@16:     ///     <tt>[0,n)</tt>, \c Ax and \c Bx are types
Chris@16:     ///     such that \c Ax lambda-matches \c Bx
Chris@16:     template<typename Expr, typename Grammar>
Chris@16:     struct matches
Chris@16:       : detail::matches_<
Chris@16:             typename Expr::proto_derived_expr
Chris@16:           , typename Expr::proto_grammar
Chris@16:           , typename Grammar::proto_grammar
Chris@16:         >
Chris@16:     {};
Chris@16: 
Chris@16:     /// INTERNAL ONLY
Chris@16:     ///
Chris@16:     template<typename Expr, typename Grammar>
Chris@16:     struct matches<Expr &, Grammar>
Chris@16:       : detail::matches_<
Chris@16:             typename Expr::proto_derived_expr
Chris@16:           , typename Expr::proto_grammar
Chris@16:           , typename Grammar::proto_grammar
Chris@16:         >
Chris@16:     {};
Chris@16: 
Chris@16:     /// \brief A wildcard grammar element that matches any expression,
Chris@16:     /// and a transform that returns the current expression unchanged.
Chris@16:     ///
Chris@16:     /// The wildcard type, \c _, is a grammar element such that
Chris@16:     /// <tt>matches\<E,_\>::value</tt> is \c true for any expression
Chris@16:     /// type \c E.
Chris@16:     ///
Chris@16:     /// The wildcard can also be used as a stand-in for a template
Chris@16:     /// argument when matching terminals. For instance, the following
Chris@16:     /// is a grammar that will match any <tt>std::complex\<\></tt>
Chris@16:     /// terminal:
Chris@16:     ///
Chris@16:     /// \code
Chris@16:     /// BOOST_MPL_ASSERT((
Chris@16:     ///     matches<
Chris@16:     ///         terminal<std::complex<double> >::type
Chris@16:     ///       , terminal<std::complex< _ > >
Chris@16:     ///     >
Chris@16:     /// ));
Chris@16:     /// \endcode
Chris@16:     ///
Chris@16:     /// When used as a transform, \c _ returns the current expression
Chris@16:     /// unchanged. For instance, in the following, \c _ is used with
Chris@16:     /// the \c fold\<\> transform to fold the children of a node:
Chris@16:     ///
Chris@16:     /// \code
Chris@16:     /// struct CountChildren
Chris@16:     ///   : or_<
Chris@16:     ///         // Terminals have no children
Chris@16:     ///         when<terminal<_>, mpl::int_<0>()>
Chris@16:     ///         // Use fold<> to count the children of non-terminals
Chris@16:     ///       , otherwise<
Chris@16:     ///             fold<
Chris@16:     ///                 _ // <-- fold the current expression
Chris@16:     ///               , mpl::int_<0>()
Chris@16:     ///               , mpl::plus<_state, mpl::int_<1> >()
Chris@16:     ///             >
Chris@16:     ///         >
Chris@16:     ///     >
Chris@16:     /// {};
Chris@16:     /// \endcode
Chris@16:     struct _ : transform<_>
Chris@16:     {
Chris@16:         typedef _ proto_grammar;
Chris@16: 
Chris@16:         template<typename Expr, typename State, typename Data>
Chris@16:         struct impl : transform_impl<Expr, State, Data>
Chris@16:         {
Chris@16:             typedef Expr result_type;
Chris@16: 
Chris@16:             /// \param expr An expression
Chris@16:             /// \return \c e
Chris@16:             BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::expr_param)
Chris@16:             operator()(
Chris@16:                 typename impl::expr_param e
Chris@16:               , typename impl::state_param
Chris@16:               , typename impl::data_param
Chris@16:             ) const
Chris@16:             {
Chris@16:                 return e;
Chris@16:             }
Chris@16:         };
Chris@16:     };
Chris@16: 
Chris@16:     namespace detail
Chris@16:     {
Chris@16:         template<typename Expr, typename State, typename Data>
Chris@16:         struct _and_impl<proto::and_<>, Expr, State, Data>
Chris@16:           : proto::_::impl<Expr, State, Data>
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename G0, typename Expr, typename State, typename Data>
Chris@16:         struct _and_impl<proto::and_<G0>, Expr, State, Data>
Chris@16:           : proto::when<proto::_, G0>::template impl<Expr, State, Data>
Chris@16:         {};
Chris@16:     }
Chris@16: 
Chris@16:     /// \brief Inverts the set of expressions matched by a grammar. When
Chris@16:     /// used as a transform, \c not_\<\> returns the current expression
Chris@16:     /// unchanged.
Chris@16:     ///
Chris@16:     /// If an expression type \c E does not match a grammar \c G, then
Chris@16:     /// \c E \e does match <tt>not_\<G\></tt>. For example,
Chris@16:     /// <tt>not_\<terminal\<_\> \></tt> will match any non-terminal.
Chris@16:     template<typename Grammar>
Chris@16:     struct not_ : transform<not_<Grammar> >
Chris@16:     {
Chris@16:         typedef not_ proto_grammar;
Chris@16: 
Chris@16:         template<typename Expr, typename State, typename Data>
Chris@16:         struct impl : transform_impl<Expr, State, Data>
Chris@16:         {
Chris@16:             typedef Expr result_type;
Chris@16: 
Chris@16:             /// \param e An expression
Chris@16:             /// \pre <tt>matches\<Expr,not_\>::value</tt> is \c true.
Chris@16:             /// \return \c e
Chris@16:             BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::expr_param)
Chris@16:             operator()(
Chris@16:                 typename impl::expr_param e
Chris@16:               , typename impl::state_param
Chris@16:               , typename impl::data_param
Chris@16:             ) const
Chris@16:             {
Chris@16:                 return e;
Chris@16:             }
Chris@16:         };
Chris@16:     };
Chris@16: 
Chris@16:     /// \brief Used to select one grammar or another based on the result
Chris@16:     /// of a compile-time Boolean. When used as a transform, \c if_\<\>
Chris@16:     /// selects between two transforms based on a compile-time Boolean.
Chris@16:     ///
Chris@16:     /// When <tt>if_\<If,Then,Else\></tt> is used as a grammar, \c If
Chris@16:     /// must be a Proto transform and \c Then and \c Else must be grammars.
Chris@16:     /// An expression type \c E matches <tt>if_\<If,Then,Else\></tt> if
Chris@16:     /// <tt>boost::result_of\<when\<_,If\>(E,int,int)\>::type::value</tt>
Chris@16:     /// is \c true and \c E matches \c U; or, if
Chris@16:     /// <tt>boost::result_of\<when\<_,If\>(E,int,int)\>::type::value</tt>
Chris@16:     /// is \c false and \c E matches \c V.
Chris@16:     ///
Chris@16:     /// The template parameter \c Then defaults to \c _
Chris@16:     /// and \c Else defaults to \c not\<_\>, so an expression type \c E
Chris@16:     /// will match <tt>if_\<If\></tt> if and only if
Chris@16:     /// <tt>boost::result_of\<when\<_,If\>(E,int,int)\>::type::value</tt>
Chris@16:     /// is \c true.
Chris@16:     ///
Chris@16:     /// \code
Chris@16:     /// // A grammar that only matches integral terminals,
Chris@16:     /// // using is_integral<> from Boost.Type_traits.
Chris@16:     /// struct IsIntegral
Chris@16:     ///   : and_<
Chris@16:     ///         terminal<_>
Chris@16:     ///       , if_< is_integral<_value>() >
Chris@16:     ///     >
Chris@16:     /// {};
Chris@16:     /// \endcode
Chris@16:     ///
Chris@16:     /// When <tt>if_\<If,Then,Else\></tt> is used as a transform, \c If,
Chris@16:     /// \c Then and \c Else must be Proto transforms. When applying
Chris@16:     /// the transform to an expression \c E, state \c S and data \c V,
Chris@16:     /// if <tt>boost::result_of\<when\<_,If\>(E,S,V)\>::type::value</tt>
Chris@16:     /// is \c true then the \c Then transform is applied; otherwise
Chris@16:     /// the \c Else transform is applied.
Chris@16:     ///
Chris@16:     /// \code
Chris@16:     /// // Match a terminal. If the terminal is integral, return
Chris@16:     /// // mpl::true_; otherwise, return mpl::false_.
Chris@16:     /// struct IsIntegral2
Chris@16:     ///   : when<
Chris@16:     ///         terminal<_>
Chris@16:     ///       , if_<
Chris@16:     ///             is_integral<_value>()
Chris@16:     ///           , mpl::true_()
Chris@16:     ///           , mpl::false_()
Chris@16:     ///         >
Chris@16:     ///     >
Chris@16:     /// {};
Chris@16:     /// \endcode
Chris@16:     template<
Chris@16:         typename If
Chris@16:       , typename Then   // = _
Chris@16:       , typename Else   // = not_<_>
Chris@16:     >
Chris@16:     struct if_ : transform<if_<If, Then, Else> >
Chris@16:     {
Chris@16:         typedef if_ proto_grammar;
Chris@16: 
Chris@16:         template<typename Expr, typename State, typename Data>
Chris@16:         struct impl : transform_impl<Expr, State, Data>
Chris@16:         {
Chris@16:             typedef
Chris@16:                 typename when<_, If>::template impl<Expr, State, Data>::result_type
Chris@16:             condition;
Chris@16: 
Chris@16:             typedef
Chris@16:                 typename mpl::if_c<
Chris@16:                     static_cast<bool>(remove_reference<condition>::type::value)
Chris@16:                   , when<_, Then>
Chris@16:                   , when<_, Else>
Chris@16:                 >::type
Chris@16:             which;
Chris@16: 
Chris@16:             typedef typename which::template impl<Expr, State, Data>::result_type result_type;
Chris@16: 
Chris@16:             /// \param e An expression
Chris@16:             /// \param s The current state
Chris@16:             /// \param d A data of arbitrary type
Chris@16:             /// \return <tt>which::impl<Expr, State, Data>()(e, s, d)</tt>
Chris@16:             result_type operator ()(
Chris@16:                 typename impl::expr_param e
Chris@16:               , typename impl::state_param s
Chris@16:               , typename impl::data_param d
Chris@16:             ) const
Chris@16:             {
Chris@16:                 return typename which::template impl<Expr, State, Data>()(e, s, d);
Chris@16:             }
Chris@16:         };
Chris@16:     };
Chris@16: 
Chris@16:     /// \brief For matching one of a set of alternate grammars. Alternates
Chris@16:     /// tried in order to avoid ambiguity. When used as a transform, \c or_\<\>
Chris@16:     /// applies the transform associated with the first grammar that matches
Chris@16:     /// the expression.
Chris@16:     ///
Chris@16:     /// An expression type \c E matches <tt>or_\<B0,B1,...Bn\></tt> if \c E
Chris@16:     /// matches any \c Bx for \c x in <tt>[0,n)</tt>.
Chris@16:     ///
Chris@16:     /// When applying <tt>or_\<B0,B1,...Bn\></tt> as a transform with an
Chris@16:     /// expression \c e of type \c E, state \c s and data \c d, it is
Chris@16:     /// equivalent to <tt>Bx()(e, s, d)</tt>, where \c x is the lowest
Chris@16:     /// number such that <tt>matches\<E,Bx\>::value</tt> is \c true.
Chris@16:     template<BOOST_PROTO_LOGICAL_typename_G>
Chris@16:     struct or_ : transform<or_<BOOST_PROTO_LOGICAL_G> >
Chris@16:     {
Chris@16:         typedef or_ proto_grammar;
Chris@16: 
Chris@16:         /// \param e An expression
Chris@16:         /// \param s The current state
Chris@16:         /// \param d A data of arbitrary type
Chris@16:         /// \pre <tt>matches\<Expr,or_\>::value</tt> is \c true.
Chris@16:         /// \return <tt>which()(e, s, d)</tt>, where <tt>which</tt> is the
Chris@16:         /// sub-grammar that matched <tt>Expr</tt>.
Chris@16: 
Chris@16:         template<typename Expr, typename State, typename Data>
Chris@16:         struct impl
Chris@16:           : detail::matches_<
Chris@16:                 typename Expr::proto_derived_expr
Chris@16:               , typename Expr::proto_grammar
Chris@16:               , or_
Chris@16:             >::which::template impl<Expr, State, Data>
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename Expr, typename State, typename Data>
Chris@16:         struct impl<Expr &, State, Data>
Chris@16:           : detail::matches_<
Chris@16:                 typename Expr::proto_derived_expr
Chris@16:               , typename Expr::proto_grammar
Chris@16:               , or_
Chris@16:             >::which::template impl<Expr &, State, Data>
Chris@16:         {};
Chris@16:     };
Chris@16: 
Chris@16:     /// \brief For matching all of a set of grammars. When used as a
Chris@16:     /// transform, \c and_\<\> applies the transforms associated with
Chris@16:     /// the each grammar in the set, and returns the result of the last.
Chris@16:     ///
Chris@16:     /// An expression type \c E matches <tt>and_\<B0,B1,...Bn\></tt> if \c E
Chris@16:     /// matches all \c Bx for \c x in <tt>[0,n)</tt>.
Chris@16:     ///
Chris@16:     /// When applying <tt>and_\<B0,B1,...Bn\></tt> as a transform with an
Chris@16:     /// expression \c e, state \c s and data \c d, it is
Chris@16:     /// equivalent to <tt>(B0()(e, s, d),B1()(e, s, d),...Bn()(e, s, d))</tt>.
Chris@16:     template<BOOST_PROTO_LOGICAL_typename_G>
Chris@16:     struct and_ : transform<and_<BOOST_PROTO_LOGICAL_G> >
Chris@16:     {
Chris@16:         typedef and_ proto_grammar;
Chris@16: 
Chris@16:         template<typename Expr, typename State, typename Data>
Chris@16:         struct impl
Chris@16:           : detail::_and_impl<and_, Expr, State, Data>
Chris@16:         {};
Chris@16:     };
Chris@16: 
Chris@16:     /// \brief For matching one of a set of alternate grammars, which
Chris@16:     /// are looked up based on some property of an expression. The
Chris@16:     /// property on which to dispatch is specified by the \c Transform
Chris@16:     /// template parameter, which defaults to <tt>tag_of\<_\>()</tt>.
Chris@16:     /// That is, when the \c Trannsform is not specified, the alternate
Chris@16:     /// grammar is looked up using the tag type of the current expression.
Chris@16:     ///
Chris@16:     /// When used as a transform, \c switch_\<\> applies the transform
Chris@16:     /// associated with the grammar that matches the expression.
Chris@16:     ///
Chris@16:     /// \note \c switch_\<\> is functionally identical to \c or_\<\> but
Chris@16:     /// is often more efficient. It does a fast, O(1) lookup using the
Chris@16:     /// result of the specified transform to find a sub-grammar that may
Chris@16:     /// potentially match the expression.
Chris@16:     ///
Chris@16:     /// An expression type \c E matches <tt>switch_\<C,T\></tt> if \c E
Chris@16:     /// matches <tt>C::case_\<boost::result_of\<T(E)\>::type\></tt>.
Chris@16:     ///
Chris@16:     /// When applying <tt>switch_\<C,T\></tt> as a transform with an
Chris@16:     /// expression \c e of type \c E, state \c s of type \S and data
Chris@16:     /// \c d of type \c D, it is equivalent to
Chris@16:     /// <tt>C::case_\<boost::result_of\<T(E,S,D)\>::type\>()(e, s, d)</tt>.
Chris@16:     template<typename Cases, typename Transform>
Chris@16:     struct switch_ : transform<switch_<Cases, Transform> >
Chris@16:     {
Chris@16:         typedef switch_ proto_grammar;
Chris@16: 
Chris@16:         template<typename Expr, typename State, typename Data>
Chris@16:         struct impl
Chris@16:           : Cases::template case_<
Chris@16:                 typename when<_, Transform>::template impl<Expr, State, Data>::result_type
Chris@16:             >::template impl<Expr, State, Data>
Chris@16:         {};
Chris@16:     };
Chris@16: 
Chris@16:     /// INTERNAL ONLY (This is merely a compile-time optimization for the common case)
Chris@16:     ///
Chris@16:     template<typename Cases>
Chris@16:     struct switch_<Cases> : transform<switch_<Cases> >
Chris@16:     {
Chris@16:         typedef switch_ proto_grammar;
Chris@16: 
Chris@16:         template<typename Expr, typename State, typename Data>
Chris@16:         struct impl
Chris@16:           : Cases::template case_<typename Expr::proto_tag>::template impl<Expr, State, Data>
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename Expr, typename State, typename Data>
Chris@16:         struct impl<Expr &, State, Data>
Chris@16:           : Cases::template case_<typename Expr::proto_tag>::template impl<Expr &, State, Data>
Chris@16:         {};
Chris@16:     };
Chris@16: 
Chris@16:     /// \brief For forcing exact matches of terminal types.
Chris@16:     ///
Chris@16:     /// By default, matching terminals ignores references and
Chris@16:     /// cv-qualifiers. For instance, a terminal expression of
Chris@16:     /// type <tt>terminal\<int const &\>::type</tt> will match
Chris@16:     /// the grammar <tt>terminal\<int\></tt>. If that is not
Chris@16:     /// desired, you can force an exact match with
Chris@16:     /// <tt>terminal\<exact\<int\> \></tt>. This will only
Chris@16:     /// match integer terminals where the terminal is held by
Chris@16:     /// value.
Chris@16:     template<typename T>
Chris@16:     struct exact
Chris@16:     {};
Chris@16: 
Chris@16:     /// \brief For matching terminals that are convertible to
Chris@16:     /// a type.
Chris@16:     ///
Chris@16:     /// Use \c convertible_to\<\> to match a terminal that is
Chris@16:     /// convertible to some type. For example, the grammar
Chris@16:     /// <tt>terminal\<convertible_to\<int\> \></tt> will match
Chris@16:     /// any terminal whose argument is convertible to an integer.
Chris@16:     ///
Chris@16:     /// \note The trait \c is_convertible\<\> from Boost.Type_traits
Chris@16:     /// is used to determinal convertibility.
Chris@16:     template<typename T>
Chris@16:     struct convertible_to
Chris@16:     {};
Chris@16: 
Chris@16:     /// \brief For matching a Grammar to a variable number of
Chris@16:     /// sub-expressions.
Chris@16:     ///
Chris@16:     /// An expression type <tt>expr\<AT, listN\<A0,...An,U0,...Um\> \></tt>
Chris@16:     /// matches a grammar <tt>expr\<BT, listM\<B0,...Bn,vararg\<V\> \> \></tt>
Chris@16:     /// if \c BT is \c _ or \c AT, and if \c Ax matches \c Bx
Chris@16:     /// for each \c x in <tt>[0,n)</tt> and if \c Ux matches \c V
Chris@16:     /// for each \c x in <tt>[0,m)</tt>.
Chris@16:     ///
Chris@16:     /// For example:
Chris@16:     ///
Chris@16:     /// \code
Chris@16:     /// // Match any function call expression, irregardless
Chris@16:     /// // of the number of function arguments:
Chris@16:     /// struct Function
Chris@16:     ///   : function< vararg<_> >
Chris@16:     /// {};
Chris@16:     /// \endcode
Chris@16:     ///
Chris@16:     /// When used as a transform, <tt>vararg\<G\></tt> applies
Chris@16:     /// <tt>G</tt>'s transform.
Chris@16:     template<typename Grammar>
Chris@16:     struct vararg
Chris@16:       : Grammar
Chris@16:     {
Chris@16:         /// INTERNAL ONLY
Chris@16:         typedef void proto_is_vararg_;
Chris@16:     };
Chris@16: 
Chris@16:     /// INTERNAL ONLY
Chris@16:     ///
Chris@16:     template<BOOST_PROTO_LOGICAL_typename_G>
Chris@16:     struct is_callable<or_<BOOST_PROTO_LOGICAL_G> >
Chris@16:       : mpl::true_
Chris@16:     {};
Chris@16: 
Chris@16:     /// INTERNAL ONLY
Chris@16:     ///
Chris@16:     template<BOOST_PROTO_LOGICAL_typename_G>
Chris@16:     struct is_callable<and_<BOOST_PROTO_LOGICAL_G> >
Chris@16:       : mpl::true_
Chris@16:     {};
Chris@16: 
Chris@16:     /// INTERNAL ONLY
Chris@16:     ///
Chris@16:     template<typename Grammar>
Chris@16:     struct is_callable<not_<Grammar> >
Chris@16:       : mpl::true_
Chris@16:     {};
Chris@16: 
Chris@16:     /// INTERNAL ONLY
Chris@16:     ///
Chris@16:     template<typename If, typename Then, typename Else>
Chris@16:     struct is_callable<if_<If, Then, Else> >
Chris@16:       : mpl::true_
Chris@16:     {};
Chris@16: 
Chris@16:     /// INTERNAL ONLY
Chris@16:     ///
Chris@16:     template<typename Grammar>
Chris@16:     struct is_callable<vararg<Grammar> >
Chris@16:       : mpl::true_
Chris@16:     {};
Chris@16: 
Chris@16:     /// INTERNAL ONLY
Chris@16:     ///
Chris@16:     template<typename Cases, typename Transform>
Chris@16:     struct is_callable<switch_<Cases, Transform> >
Chris@16:       : mpl::true_
Chris@16:     {};
Chris@16: 
Chris@16: }}
Chris@16: 
Chris@16: #undef BOOST_PROTO_LOGICAL_typename_G
Chris@16: #undef BOOST_PROTO_LOGICAL_G
Chris@16: 
Chris@101: #if defined(_MSC_VER)
Chris@16: # pragma warning(pop)
Chris@16: #endif
Chris@16: 
Chris@16: #endif