996 lines
41 KiB
C++
Executable File
996 lines
41 KiB
C++
Executable File
#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/xpressive/proto/detail/prefix.hpp> // must be first include
|
|
#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/repetition/enum.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_params.hpp>
|
|
#include <boost/preprocessor/repetition/enum_shifted.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/config.hpp>
|
|
#include <boost/mpl/logical.hpp>
|
|
#include <boost/mpl/apply.hpp>
|
|
#include <boost/mpl/aux_/template_arity.hpp>
|
|
#include <boost/mpl/aux_/lambda_arity_param.hpp>
|
|
#include <boost/utility/enable_if.hpp>
|
|
#include <boost/type_traits/is_array.hpp>
|
|
#include <boost/type_traits/is_convertible.hpp>
|
|
#include <boost/type_traits/is_reference.hpp>
|
|
#include <boost/type_traits/is_pointer.hpp>
|
|
#include <boost/xpressive/proto/proto_fwd.hpp>
|
|
#include <boost/xpressive/proto/traits.hpp>
|
|
#include <boost/xpressive/proto/transform/when.hpp>
|
|
#include <boost/xpressive/proto/detail/suffix.hpp> // must be last include
|
|
|
|
// 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
|
|
{
|
|
struct ignore;
|
|
|
|
template<typename Expr, typename Grammar>
|
|
struct matches_;
|
|
|
|
// and_ and or_ implementation
|
|
template<bool B, typename Expr, typename G0>
|
|
struct or1
|
|
: mpl::bool_<B>
|
|
{
|
|
typedef G0 which;
|
|
};
|
|
|
|
template<bool B>
|
|
struct and1
|
|
: mpl::bool_<B>
|
|
{};
|
|
|
|
template<bool B, typename Pred>
|
|
struct and2;
|
|
|
|
template<typename And>
|
|
struct last;
|
|
|
|
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], 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::expr<ignore, Args1, Args1::size>, proto::expr<ignore, Args2, Args1::size> >
|
|
{};
|
|
|
|
template<typename Args1, typename Args2, typename Back>
|
|
struct vararg_matches<Args1, Args2, Back, true, false, typename Back::proto_is_vararg_>
|
|
: and2<
|
|
matches_<proto::expr<ignore, Args1, Args2::size>, proto::expr<ignore, Args2, Args2::size> >::value
|
|
, vararg_matches_impl<Args1, typename Back::proto_base_expr, Args2::size + 1, Args1::size>
|
|
>
|
|
{};
|
|
|
|
// How terminal_matches<> handles references and cv-qualifiers.
|
|
// The cv and ref_ matter *only* if the grammar has a top-level ref_.
|
|
//
|
|
// Expr | Grammar | Match
|
|
// ------------------------------
|
|
// 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_
|
|
{};
|
|
#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::expr<Tag, Args1, N1>, proto::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::expr<Tag, Args1, N1>, proto::expr<proto::_, Args2, N2> >
|
|
: vararg_matches< Args1, Args2, typename Args2::back_, (N1+2 > N2), (N2 > N1) >
|
|
{};
|
|
|
|
template<typename Args1, typename Args2, long N2>
|
|
struct matches_< proto::expr<tag::terminal, Args1, 0>, proto::expr<proto::_, Args2, N2> >
|
|
: mpl::false_
|
|
{};
|
|
|
|
template<typename Tag, typename Args1, typename Args2>
|
|
struct matches_< proto::expr<Tag, Args1, 1>, proto::expr<Tag, Args2, 1> >
|
|
: matches_<typename Args1::arg0::proto_base_expr, typename Args2::arg0::proto_base_expr>
|
|
{};
|
|
|
|
template<typename Tag, typename Args1, typename Args2>
|
|
struct matches_< proto::expr<Tag, Args1, 1>, proto::expr<proto::_, Args2, 1> >
|
|
: matches_<typename Args1::arg0::proto_base_expr, typename Args2::arg0::proto_base_expr>
|
|
{};
|
|
|
|
template<typename Args1, typename Args2>
|
|
struct matches_< proto::expr<tag::terminal, Args1, 0>, proto::expr<tag::terminal, Args2, 0> >
|
|
: terminal_matches<typename Args1::arg0, typename Args2::arg0>
|
|
{};
|
|
|
|
#define BOOST_PROTO_MATCHES_N_FUN(z, n, data)\
|
|
matches_<\
|
|
typename Args1::BOOST_PP_CAT(arg, n)::proto_base_expr\
|
|
, typename Args2::BOOST_PP_CAT(arg, n)::proto_base_expr\
|
|
>
|
|
|
|
#define BOOST_PROTO_DEFINE_MATCHES(z, n, data)\
|
|
matches_<\
|
|
typename Expr::proto_base_expr\
|
|
, typename BOOST_PP_CAT(G, n)::proto_base_expr\
|
|
>
|
|
|
|
#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/xpressive/proto/matches.hpp>, 1))
|
|
#else
|
|
#define BOOST_PP_ITERATION_PARAMS_1 (4, (2, BOOST_PROTO_MAX_ARITY, <boost/xpressive/proto/matches.hpp>, 1))
|
|
#endif
|
|
#include BOOST_PP_ITERATE()
|
|
|
|
#define BOOST_PP_ITERATION_PARAMS_1 (4, (2, BOOST_PROTO_MAX_ARITY, <boost/xpressive/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 Expr, typename If, typename Then, typename Else>
|
|
struct matches_<Expr, proto::if_<If, Then, Else> >
|
|
: mpl::eval_if<
|
|
typename when<_, If>::template result<void(Expr, int, int)>::type
|
|
, matches_<Expr, typename Then::proto_base_expr>
|
|
, matches_<Expr, typename Else::proto_base_expr>
|
|
>::type
|
|
{};
|
|
|
|
template<typename Expr, typename If>
|
|
struct matches_<Expr, proto::if_<If> >
|
|
: when<_, If>::template result<void(Expr, int, int)>::type
|
|
{};
|
|
|
|
// handle proto::not_
|
|
template<typename Expr, typename Grammar>
|
|
struct matches_<Expr, not_<Grammar> >
|
|
: mpl::not_<matches_<Expr, typename Grammar::proto_base_expr> >
|
|
{};
|
|
|
|
// handle proto::switch_
|
|
template<typename Expr, typename Cases>
|
|
struct matches_<Expr, switch_<Cases> >
|
|
: matches_<
|
|
Expr
|
|
, typename Cases::template case_<typename Expr::proto_tag>::proto_base_expr
|
|
>
|
|
{};
|
|
}
|
|
|
|
namespace result_of
|
|
{
|
|
/// \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_base_expr</tt> matches
|
|
/// <tt>Grammar::proto_base_expr</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, argsN\<A0,A1,...An\> \></tt>
|
|
/// matches a grammar <tt>expr\<BT, argsN\<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, argsN\<A0,...An,U0,...Um\> \></tt>
|
|
/// matches a grammar <tt>expr\<BT, argsM\<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>when\<_,T\>::::result\<void(E,int,int)\>::::type::value</tt>
|
|
/// is \c true and \c E matches \c U; or, if
|
|
/// <tt>when\<_,T\>::::result\<void(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\<tag::terminal,args0\<A\> \></tt> matches
|
|
/// a grammar <tt>expr\<BT,args0\<B\> \></tt> if \c BT is \c _ or
|
|
/// \c tag::terminal and 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_base_expr
|
|
, typename Grammar::proto_base_expr
|
|
>
|
|
{};
|
|
}
|
|
|
|
namespace wildcardns_
|
|
{
|
|
/// \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 _ : proto::callable
|
|
{
|
|
typedef _ proto_base_expr;
|
|
|
|
template<typename Sig>
|
|
struct result;
|
|
|
|
template<typename This, typename Expr, typename State, typename Visitor>
|
|
struct result<This(Expr, State, Visitor)>
|
|
{
|
|
typedef Expr type;
|
|
};
|
|
|
|
/// \param expr An expression
|
|
/// \return \c expr
|
|
template<typename Expr, typename State, typename Visitor>
|
|
Expr const &operator ()(Expr const &expr, State const &, Visitor &) const
|
|
{
|
|
return expr;
|
|
}
|
|
};
|
|
}
|
|
|
|
namespace control
|
|
{
|
|
/// \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_ : proto::callable
|
|
{
|
|
typedef not_ proto_base_expr;
|
|
|
|
template<typename Sig>
|
|
struct result;
|
|
|
|
template<typename This, typename Expr, typename State, typename Visitor>
|
|
struct result<This(Expr, State, Visitor)>
|
|
{
|
|
typedef Expr type;
|
|
};
|
|
|
|
/// \param expr An expression
|
|
/// \pre <tt>matches\<Expr,not_\>::::value</tt> is \c true.
|
|
/// \return \c expr
|
|
template<typename Expr, typename State, typename Visitor>
|
|
Expr const &operator ()(Expr const &expr, State const &, Visitor &) const
|
|
{
|
|
return expr;
|
|
}
|
|
};
|
|
|
|
/// \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>when\<_,If\>::::result\<void(E,int,int)\>::::type::value</tt>
|
|
/// is \c true and \c E matches \c U; or, if
|
|
/// <tt>when\<_,If\>::::result\<void(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>when\<_,If\>::::result\<void(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<_arg>() >
|
|
/// >
|
|
/// {};
|
|
/// \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 visitor \c V,
|
|
/// if <tt>when\<_,If\>::::result\<void(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<_arg>()
|
|
/// , mpl::true_()
|
|
/// , mpl::false_()
|
|
/// >
|
|
/// >
|
|
/// {};
|
|
/// \endcode
|
|
template<
|
|
typename If
|
|
, typename Then BOOST_PROTO_FOR_DOXYGEN_ONLY(= _)
|
|
, typename Else BOOST_PROTO_FOR_DOXYGEN_ONLY(= not_<_>)
|
|
>
|
|
struct if_ : proto::callable
|
|
{
|
|
typedef if_ proto_base_expr;
|
|
|
|
template<typename Sig>
|
|
struct result;
|
|
|
|
template<typename This, typename Expr, typename State, typename Visitor>
|
|
struct result<This(Expr, State, Visitor)>
|
|
{
|
|
typedef
|
|
typename when<_, If>::template result<void(Expr, State, Visitor)>::type
|
|
condition;
|
|
|
|
typedef
|
|
typename mpl::if_<
|
|
condition
|
|
, when<_, Then>
|
|
, when<_, Else>
|
|
>::type
|
|
which;
|
|
|
|
typedef typename which::template result<void(Expr, State, Visitor)>::type type;
|
|
};
|
|
|
|
/// \param expr An expression
|
|
/// \param state The current state
|
|
/// \param visitor A visitor of arbitrary type
|
|
/// \return <tt>result\<void(Expr, State, Visitor)\>::::which()(expr, state, visitor)</tt>
|
|
template<typename Expr, typename State, typename Visitor>
|
|
typename result<void(Expr, State, Visitor)>::type
|
|
operator ()(Expr const &expr, State const &state, Visitor &visitor) const
|
|
{
|
|
typedef
|
|
typename result<void(Expr, State, Visitor)>::which
|
|
which;
|
|
|
|
return which()(expr, state, visitor);
|
|
}
|
|
};
|
|
|
|
/// \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 visitor \c v, it is
|
|
/// equivalent to <tt>Bx()(e, s, v)</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_ : proto::callable
|
|
{
|
|
typedef or_ proto_base_expr;
|
|
|
|
template<typename Sig>
|
|
struct result;
|
|
|
|
template<typename This, typename Expr, typename State, typename Visitor>
|
|
struct result<This(Expr, State, Visitor)>
|
|
{
|
|
typedef typename detail::matches_<Expr, or_>::which which;
|
|
typedef typename which::template result<void(Expr, State, Visitor)>::type type;
|
|
};
|
|
|
|
/// \param expr An expression
|
|
/// \param state The current state
|
|
/// \param visitor A visitor of arbitrary type
|
|
/// \pre <tt>matches\<Expr,or_\>::::value</tt> is \c true.
|
|
/// \return <tt>result\<void(Expr, State, Visitor)\>::::which()(expr, state, visitor)</tt>
|
|
template<typename Expr, typename State, typename Visitor>
|
|
typename result<void(Expr, State, Visitor)>::type
|
|
operator ()(Expr const &expr, State const &state, Visitor &visitor) const
|
|
{
|
|
typedef typename detail::matches_<Expr, or_>::which which;
|
|
return which()(expr, state, visitor);
|
|
}
|
|
};
|
|
|
|
/// \brief For matching all of a set of grammars. When used as a
|
|
/// transform, \c and_\<\> applies the transform associated with
|
|
/// the last grammar in the set.
|
|
///
|
|
/// 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 visitor \c v, it is
|
|
/// equivalent to <tt>Bn()(e, s, v)</tt>.
|
|
template<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G)>
|
|
struct and_ : proto::callable
|
|
{
|
|
typedef and_ proto_base_expr;
|
|
|
|
template<typename Sig>
|
|
struct result;
|
|
|
|
template<typename This, typename Expr, typename State, typename Visitor>
|
|
struct result<This(Expr, State, Visitor)>
|
|
{
|
|
typedef typename detail::last<and_>::type which;
|
|
typedef typename which::template result<void(Expr, State, Visitor)>::type type;
|
|
};
|
|
|
|
/// \param expr An expression
|
|
/// \param state The current state
|
|
/// \param visitor A visitor of arbitrary type
|
|
/// \pre <tt>matches\<Expr,and_\>::::value</tt> is \c true.
|
|
/// \return <tt>result\<void(Expr, State, Visitor)\>::::which()(expr, state, visitor)</tt>
|
|
template<typename Expr, typename State, typename Visitor>
|
|
typename result<void(Expr, State, Visitor)>::type
|
|
operator ()(Expr const &expr, State const &state, Visitor &visitor) const
|
|
{
|
|
typedef typename detail::last<and_>::type which;
|
|
return which()(expr, state, visitor);
|
|
}
|
|
};
|
|
|
|
/// \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 visitor \c v, it is
|
|
/// equivalent to <tt>C::case_\<E::proto_tag\>()(e, s, v)</tt>.
|
|
template<typename Cases>
|
|
struct switch_ : proto::callable
|
|
{
|
|
typedef switch_ proto_base_expr;
|
|
|
|
template<typename Sig>
|
|
struct result;
|
|
|
|
template<typename This, typename Expr, typename State, typename Visitor>
|
|
struct result<This(Expr, State, Visitor)>
|
|
{
|
|
typedef typename Cases::template case_<typename Expr::proto_tag> which;
|
|
typedef typename which::template result<void(Expr, State, Visitor)>::type type;
|
|
};
|
|
|
|
/// \param expr An expression
|
|
/// \param state The current state
|
|
/// \param visitor A visitor of arbitrary type
|
|
/// \pre <tt>matches\<Expr,switch_\>::::value</tt> is \c true.
|
|
/// \return <tt>result\<void(Expr, State, Visitor)\>::::which()(expr, state, visitor)</tt>
|
|
template<typename Expr, typename State, typename Visitor>
|
|
typename result<void(Expr, State, Visitor)>::type
|
|
operator ()(Expr const &expr, State const &state, Visitor &visitor) const
|
|
{
|
|
typedef typename Cases::template case_<typename Expr::proto_tag> which;
|
|
return which()(expr, state, visitor);
|
|
}
|
|
};
|
|
|
|
/// \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, argsN\<A0,...An,U0,...Um\> \></tt>
|
|
/// matches a grammar <tt>expr\<BT, argsM\<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
|
|
{
|
|
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()
|
|
|
|
template<bool B, BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(N), typename P)>
|
|
struct BOOST_PP_CAT(and, N)
|
|
: 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)
|
|
>
|
|
{};
|
|
|
|
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)>
|
|
struct last<proto::and_<BOOST_PP_ENUM_PARAMS(N, G)> >
|
|
{
|
|
typedef BOOST_PP_CAT(G, BOOST_PP_DEC(N)) type;
|
|
};
|
|
|
|
template<bool B, typename Expr, BOOST_PP_ENUM_PARAMS(N, typename G)>
|
|
struct BOOST_PP_CAT(or, N)
|
|
: BOOST_PP_CAT(or, BOOST_PP_DEC(N))<
|
|
matches_<Expr, typename G1::proto_base_expr>::value
|
|
, Expr, BOOST_PP_ENUM_SHIFTED_PARAMS(N, G)
|
|
>
|
|
{};
|
|
|
|
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_<typename Expr::proto_base_expr, typename G0::proto_base_expr>::value,
|
|
typename Expr::proto_base_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>
|
|
: and2<
|
|
matches_<typename Args::BOOST_PP_CAT(arg, BOOST_PP_DEC(N))::proto_base_expr, 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 Args::BOOST_PP_CAT(arg, BOOST_PP_DEC(N))::proto_base_expr, 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::expr<Tag, Args1, N>, proto::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::expr<Tag, Args1, N>, proto::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
|
|
|