diff options
Diffstat (limited to '3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail')
6 files changed, 434 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/actor.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/actor.hpp new file mode 100644 index 0000000..66666c5 --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/actor.hpp @@ -0,0 +1,65 @@ +/*============================================================================= + Copyright (c) 2001-2007 Joel de Guzman + + 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_PP_IS_ITERATING +#ifndef PHOENIX_CORE_DETAIL_ACTOR_HPP +#define PHOENIX_CORE_DETAIL_ACTOR_HPP + +#include <boost/preprocessor/iterate.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/preprocessor/facilities/intercept.hpp> + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (3, PHOENIX_ACTOR_LIMIT, \ + "boost/spirit/home/phoenix/core/detail/actor.hpp")) +#include BOOST_PP_ITERATE() + +#endif + +/////////////////////////////////////////////////////////////////////////////// +// +// Preprocessor vertical repetition code +// +/////////////////////////////////////////////////////////////////////////////// +#else // defined(BOOST_PP_IS_ITERATING) + +#define N BOOST_PP_ITERATION() + + template <BOOST_PP_ENUM_PARAMS(N, typename T)> + actor(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& _)) + : Eval(BOOST_PP_ENUM_PARAMS(N, _)) {} + + template <typename F, BOOST_PP_ENUM_PARAMS(N, typename A)> + struct result<F(BOOST_PP_ENUM_PARAMS(N, A))> + : eval_result< + eval_type + , basic_environment< + BOOST_PP_ENUM_BINARY_PARAMS( + N + , typename remove_reference<A + , >::type BOOST_PP_INTERCEPT + ) + > + > + {}; + + template <BOOST_PP_ENUM_PARAMS(N, typename T)> + typename result< + actor(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & BOOST_PP_INTERCEPT)) + >::type + operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & _)) const + { + return eval_type::eval( + basic_environment<BOOST_PP_ENUM_PARAMS(N, T)>( + BOOST_PP_ENUM_PARAMS(N, _)) + ); + } + +#undef N +#endif // defined(BOOST_PP_IS_ITERATING) + + diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/basic_environment.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/basic_environment.hpp new file mode 100644 index 0000000..986ecf2 --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/basic_environment.hpp @@ -0,0 +1,38 @@ +/*============================================================================= + Copyright (c) 2001-2007 Joel de Guzman + + 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_PP_IS_ITERATING +#ifndef PHOENIX_CORE_DETAIL_BASIC_ENVIRONMENT_HPP +#define PHOENIX_CORE_DETAIL_BASIC_ENVIRONMENT_HPP + +#include <boost/preprocessor/iterate.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (3, PHOENIX_ARG_LIMIT, \ + "boost/spirit/home/phoenix/core/detail/basic_environment.hpp")) +#include BOOST_PP_ITERATE() + +#endif + +/////////////////////////////////////////////////////////////////////////////// +// +// Preprocessor vertical repetition code +// +/////////////////////////////////////////////////////////////////////////////// +#else // defined(BOOST_PP_IS_ITERATING) + +#define N BOOST_PP_ITERATION() + + template <BOOST_PP_ENUM_PARAMS(N, typename U)> + basic_environment(BOOST_PP_ENUM_BINARY_PARAMS(N, U, & _)) + : args_(BOOST_PP_ENUM_PARAMS(N, _)) {} + +#undef N +#endif // defined(BOOST_PP_IS_ITERATING) + + diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/compose.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/compose.hpp new file mode 100644 index 0000000..945a3d3 --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/compose.hpp @@ -0,0 +1,47 @@ +/*============================================================================= + Copyright (c) 2001-2007 Joel de Guzman + + 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_PP_IS_ITERATING +#ifndef PHOENIX_CORE_DETAIL_COMPOSE_DETAIL_HPP +#define PHOENIX_CORE_DETAIL_COMPOSE_DETAIL_HPP + +#include <boost/preprocessor/iterate.hpp> +#include <boost/preprocessor/repetition/enum.hpp> + +#define PHOENIX_AS_ACTOR_CONVERT(z, n, data) \ + as_actor<BOOST_PP_CAT(T, n)>::convert(BOOST_PP_CAT(_, n)) + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (3, PHOENIX_COMPOSITE_LIMIT, \ + "boost/spirit/home/phoenix/core/detail/compose.hpp")) +#include BOOST_PP_ITERATE() + +#undef PHOENIX_AS_ACTOR_CONVERT +#endif + +/////////////////////////////////////////////////////////////////////////////// +// +// Preprocessor vertical repetition code +// +/////////////////////////////////////////////////////////////////////////////// +#else // defined(BOOST_PP_IS_ITERATING) + +#define N BOOST_PP_ITERATION() + + template <typename EvalPolicy, BOOST_PP_ENUM_PARAMS(N, typename T)> + inline actor< + typename as_composite<EvalPolicy, BOOST_PP_ENUM_PARAMS(N, T)>::type> + compose(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& _)) + { + return actor< + typename as_composite<EvalPolicy, BOOST_PP_ENUM_PARAMS(N, T)>::type>( + BOOST_PP_ENUM(N, PHOENIX_AS_ACTOR_CONVERT, _)); + } + +#undef N +#endif // defined(BOOST_PP_IS_ITERATING) + + diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/composite.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/composite.hpp new file mode 100644 index 0000000..6970f7c --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/composite.hpp @@ -0,0 +1,36 @@ +/*============================================================================= + Copyright (c) 2001-2007 Joel de Guzman + + 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_PP_IS_ITERATING +#ifndef PHOENIX_CORE_DETAIL_COMPOSITE_HPP +#define PHOENIX_CORE_DETAIL_COMPOSITE_HPP + +#include <boost/preprocessor/iterate.hpp> + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (3, PHOENIX_COMPOSITE_LIMIT, \ + "boost/spirit/home/phoenix/core/detail/composite.hpp")) +#include BOOST_PP_ITERATE() + +#endif + +/////////////////////////////////////////////////////////////////////////////// +// +// Preprocessor vertical repetition code +// +/////////////////////////////////////////////////////////////////////////////// +#else // defined(BOOST_PP_IS_ITERATING) + +#define N BOOST_PP_ITERATION() + + template <BOOST_PP_ENUM_PARAMS(N, typename U)> + composite(BOOST_PP_ENUM_BINARY_PARAMS(N, U, & _)) + : base_type(BOOST_PP_ENUM_PARAMS(N, _)) {} + +#undef N +#endif // defined(BOOST_PP_IS_ITERATING) + + diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/composite_eval.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/composite_eval.hpp new file mode 100644 index 0000000..14f12af --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/composite_eval.hpp @@ -0,0 +1,106 @@ +/*============================================================================= + Copyright (c) 2001-2007 Joel de Guzman + + 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_PP_IS_ITERATING +#ifndef PHOENIX_CORE_DETAIL_COMPOSITE_EVAL_HPP +#define PHOENIX_CORE_DETAIL_COMPOSITE_EVAL_HPP + +#include <boost/preprocessor/iterate.hpp> +#include <boost/preprocessor/repetition/enum.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> + + namespace detail + { + template <int N> + struct composite_eval; + + template <> + struct composite_eval<0> + { + template <typename Composite, typename Env> + struct result + { + typedef typename Composite::eval_policy_type:: + template result<Env>::type + type; + }; + + template <typename RT, typename Composite, typename Env> + static RT + call(Composite const& /*composite*/, Env const& env) + { + typedef typename Composite::eval_policy_type eval_policy_type; + return eval_policy_type::template eval<RT>(env); + } + }; + + template <typename Actor, typename Env> + struct eval_is_actor + : is_actor<typename Actor::template result<Env>::type> {}; + + template <typename Actor, typename Env> + struct eval_is_void + : is_same<typename Actor::template result<Env>::type, fusion::void_> {}; + } + +#define PHOENIX_GET_ACTOR_TYPE(z, n, data) \ + typedef \ + typename fusion::result_of::value_at_c<Composite, n>::type \ + BOOST_PP_CAT(actor, n); + +#define PHOENIX_GET_ACTOR(z, n, data) \ + fusion::at_c<n>(composite) + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (1, PHOENIX_COMPOSITE_LIMIT, \ + "boost/spirit/home/phoenix/core/detail/composite_eval.hpp")) +#include BOOST_PP_ITERATE() + +#undef PHOENIX_GET_ACTOR +#undef PHOENIX_GET_ACTOR_TYPE +#endif + +/////////////////////////////////////////////////////////////////////////////// +// +// Preprocessor vertical repetition code +// +/////////////////////////////////////////////////////////////////////////////// +#else // defined(BOOST_PP_IS_ITERATING) + +#define N BOOST_PP_ITERATION() + + namespace detail + { + template <> + struct composite_eval<N> + { + template <typename Composite, typename Env> + struct result + { + BOOST_PP_REPEAT(N, PHOENIX_GET_ACTOR_TYPE, _) + + typedef typename + Composite::eval_policy_type::template result< + Env, BOOST_PP_ENUM_PARAMS(N, actor) + >::type + type; + }; + + template <typename RT, typename Composite, typename Env> + static RT + call(Composite const& composite, Env const& env) + { + typedef typename Composite::eval_policy_type eval_policy_type; + return eval_policy_type::template eval<RT>( + env, BOOST_PP_ENUM(N, PHOENIX_GET_ACTOR, _)); + } + }; + } + +#undef N +#endif // defined(BOOST_PP_IS_ITERATING) + + diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/function_eval.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/function_eval.hpp new file mode 100644 index 0000000..711b32c --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/function_eval.hpp @@ -0,0 +1,142 @@ +/*============================================================================= + Copyright (c) 2001-2007 Joel de Guzman + + 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) +==============================================================================*/ +#if !defined(BOOST_PP_IS_ITERATING) +#if !defined(PHOENIX_CORE_DETAIL_FUNCTION_EVAL_HPP) +#define PHOENIX_CORE_DETAIL_FUNCTION_EVAL_HPP + +#include <boost/preprocessor/iterate.hpp> +#include <boost/preprocessor/enum.hpp> +#include <boost/preprocessor/repeat.hpp> +#include <boost/preprocessor/dec.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/find.hpp> +#include <boost/mpl/identity.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/type_traits/remove_reference.hpp> + +// we assume that mpl::vectorN, where N = PHOENIX_COMPOSITE_LIMIT +// is included already. + +namespace boost { namespace phoenix { namespace detail +{ + template <int N> + struct function_eval; + + template <> + struct function_eval<0> + { + template <typename Env, typename F> + struct result + { + typedef typename + remove_reference< + typename F::template result<Env>::type + >::type + fn; + typedef typename fn::result_type type; + }; + + template <typename RT, typename Env, typename F> + static RT + eval(Env const& env, F const& f) + { + return f.eval(env)(); + } + }; + + template <typename T> + T& help_rvalue_deduction(T& x) + { + return x; + } + + template <typename T> + T const& help_rvalue_deduction(T const& x) + { + return x; + } + +// When we call f(_0, _1...) we remove the reference when deducing f's +// return type. $$$ Explain why $$$ + +#define PHOENIX_GET_ARG(z, n, data) \ + typedef typename \ + remove_reference< \ + typename BOOST_PP_CAT(A, n)::template result<Env>::type \ + >::type \ + BOOST_PP_CAT(a, n); + +#define PHOENIX_EVAL_ARG(z, n, data) \ + help_rvalue_deduction(BOOST_PP_CAT(_, n).eval(env)) + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (1, BOOST_PP_DEC(PHOENIX_COMPOSITE_LIMIT), \ + "boost/spirit/home/phoenix/core/detail/function_eval.hpp")) +#include BOOST_PP_ITERATE() + +}}} // namespace boost::phoenix::detail + +#undef PHOENIX_GET_ARG +#undef PHOENIX_EVAL_ARG +#endif + +/////////////////////////////////////////////////////////////////////////////// +// +// Preprocessor vertical repetition code +// +/////////////////////////////////////////////////////////////////////////////// +#else // defined(BOOST_PP_IS_ITERATING) + +#define N BOOST_PP_ITERATION() + + template <> + struct function_eval<N> + { + template <typename Env, typename F + , BOOST_PP_ENUM_PARAMS(N, typename A)> + struct result + { + typedef typename + remove_reference< + typename F::template result<Env>::type + >::type + fn; + BOOST_PP_REPEAT(N, PHOENIX_GET_ARG, _) + + typedef BOOST_PP_CAT(mpl::vector, N) + <BOOST_PP_ENUM_PARAMS(N, a)> + args; + + typedef typename + fn::template result<BOOST_PP_ENUM_PARAMS(N, a)> + function_apply; + + typedef typename + mpl::eval_if< + is_same< + typename mpl::find<args, fusion::void_>::type + , typename mpl::end<args>::type> + , function_apply + , mpl::identity<fusion::void_> + >::type + type; + }; + + template <typename RT, typename Env, typename F + , BOOST_PP_ENUM_PARAMS(N, typename A)> + static RT + eval(Env const& env, F const& f + , BOOST_PP_ENUM_BINARY_PARAMS(N, A, & _)) + { + return f.eval(env)(BOOST_PP_ENUM(N, PHOENIX_EVAL_ARG, _)); + } + }; + +#undef N +#endif // defined(BOOST_PP_IS_ITERATING) + + |