Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/spirit/home/phoenix/operator')
16 files changed, 1110 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/arithmetic.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/arithmetic.hpp new file mode 100644 index 0000000..e51b23e --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/arithmetic.hpp @@ -0,0 +1,115 @@ +/*============================================================================= + 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 PHOENIX_OPERATOR_ARITHMETIC_HPP +#define PHOENIX_OPERATOR_ARITHMETIC_HPP + +#include <boost/spirit/home/phoenix/core/composite.hpp> +#include <boost/spirit/home/phoenix/core/compose.hpp> +#include <boost/spirit/home/phoenix/detail/type_deduction.hpp> +#include <boost/spirit/home/phoenix/operator/detail/unary_eval.hpp> +#include <boost/spirit/home/phoenix/operator/detail/unary_compose.hpp> +#include <boost/spirit/home/phoenix/operator/detail/binary_eval.hpp> +#include <boost/spirit/home/phoenix/operator/detail/binary_compose.hpp> + +namespace boost { namespace phoenix +{ + struct negate_eval; + struct posit_eval; + struct pre_increment_eval; + struct pre_decrement_eval; + struct post_increment_eval; + struct post_decrement_eval; + + struct plus_assign_eval; + struct minus_assign_eval; + struct multiplies_assign_eval; + struct divides_assign_eval; + struct modulus_assign_eval; + + struct plus_eval; + struct minus_eval; + struct multiplies_eval; + struct divides_eval; + struct modulus_eval; + + BOOST_UNARY_RESULT_OF(-x, result_of_negate) + BOOST_UNARY_RESULT_OF(+x, result_of_posit) + BOOST_UNARY_RESULT_OF(++x, result_of_pre_increment) + BOOST_UNARY_RESULT_OF(--x, result_of_pre_decrement) + BOOST_UNARY_RESULT_OF(x++, result_of_post_increment) + BOOST_UNARY_RESULT_OF(x--, result_of_post_decrement) + + BOOST_BINARY_RESULT_OF(x += y, result_of_plus_assign) + BOOST_BINARY_RESULT_OF(x -= y, result_of_minus_assign) + BOOST_BINARY_RESULT_OF(x *= y, result_of_multiplies_assign) + BOOST_BINARY_RESULT_OF(x /= y, result_of_divides_assign) + BOOST_BINARY_RESULT_OF(x %= y, result_of_modulus_assign) + + BOOST_BINARY_RESULT_OF(x + y, result_of_plus) + BOOST_BINARY_RESULT_OF(x - y, result_of_minus) + BOOST_BINARY_RESULT_OF(x * y, result_of_multiplies) + BOOST_BINARY_RESULT_OF(x / y, result_of_divides) + BOOST_BINARY_RESULT_OF(x % y, result_of_modulus) + +#define x a0.eval(env) +#define y a1.eval(env) + + PHOENIX_UNARY_EVAL(negate_eval, result_of_negate, -x) + PHOENIX_UNARY_EVAL(posit_eval, result_of_posit, +x) + PHOENIX_UNARY_EVAL(pre_increment_eval, result_of_pre_increment, ++x) + PHOENIX_UNARY_EVAL(pre_decrement_eval, result_of_pre_decrement, --x) + PHOENIX_UNARY_EVAL(post_increment_eval, result_of_post_increment, x++) + PHOENIX_UNARY_EVAL(post_decrement_eval, result_of_post_decrement, x--) + + PHOENIX_BINARY_EVAL(plus_assign_eval, result_of_plus_assign, x += y) + PHOENIX_BINARY_EVAL(minus_assign_eval, result_of_minus_assign, x -= y) + PHOENIX_BINARY_EVAL(multiplies_assign_eval, result_of_multiplies_assign, x *= y) + PHOENIX_BINARY_EVAL(divides_assign_eval, result_of_divides_assign, x /= y) + PHOENIX_BINARY_EVAL(modulus_assign_eval, result_of_modulus_assign, x %= y) + + PHOENIX_BINARY_EVAL(plus_eval, result_of_plus, x + y) + PHOENIX_BINARY_EVAL(minus_eval, result_of_minus, x - y) + PHOENIX_BINARY_EVAL(multiplies_eval, result_of_multiplies, x * y) + PHOENIX_BINARY_EVAL(divides_eval, result_of_divides, x / y) + PHOENIX_BINARY_EVAL(modulus_eval, result_of_modulus, x % y) + + PHOENIX_UNARY_COMPOSE(negate_eval, -) + PHOENIX_UNARY_COMPOSE(posit_eval, +) + PHOENIX_UNARY_COMPOSE(pre_increment_eval, ++) + PHOENIX_UNARY_COMPOSE(pre_decrement_eval, --) + + template <typename T0> + inline actor<typename as_composite<post_increment_eval, actor<T0> >::type> + operator++(actor<T0> const& a0, int) // special case + { + return compose<post_increment_eval>(a0); + } + + template <typename T0> + inline actor<typename as_composite<post_decrement_eval, actor<T0> >::type> + operator--(actor<T0> const& a0, int) // special case + { + return compose<post_decrement_eval>(a0); + } + + PHOENIX_BINARY_COMPOSE(plus_assign_eval, +=) + PHOENIX_BINARY_COMPOSE(minus_assign_eval, -=) + PHOENIX_BINARY_COMPOSE(multiplies_assign_eval, *=) + PHOENIX_BINARY_COMPOSE(divides_assign_eval, /=) + PHOENIX_BINARY_COMPOSE(modulus_assign_eval, %=) + + PHOENIX_BINARY_COMPOSE(plus_eval, +) + PHOENIX_BINARY_COMPOSE(minus_eval, -) + PHOENIX_BINARY_COMPOSE(multiplies_eval, *) + PHOENIX_BINARY_COMPOSE(divides_eval, /) + PHOENIX_BINARY_COMPOSE(modulus_eval, %) + +#undef x +#undef y +}} + +#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/bitwise.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/bitwise.hpp new file mode 100644 index 0000000..0450db4 --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/bitwise.hpp @@ -0,0 +1,91 @@ +/*============================================================================= + 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 PHOENIX_OPERATOR_BITWISE_HPP +#define PHOENIX_OPERATOR_BITWISE_HPP + +#include <boost/spirit/home/phoenix/core/composite.hpp> +#include <boost/spirit/home/phoenix/core/compose.hpp> +#include <boost/spirit/home/phoenix/detail/type_deduction.hpp> +#include <boost/spirit/home/phoenix/operator/detail/unary_eval.hpp> +#include <boost/spirit/home/phoenix/operator/detail/unary_compose.hpp> +#include <boost/spirit/home/phoenix/operator/detail/binary_eval.hpp> +#include <boost/spirit/home/phoenix/operator/detail/binary_compose.hpp> + +#ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable : 4800) +#endif + +namespace boost { namespace phoenix +{ + struct invert_eval; + + struct and_assign_eval; + struct or_assign_eval; + struct xor_assign_eval; + struct shift_left_assign_eval; + struct shift_right_assign_eval; + + struct and_eval; + struct or_eval; + struct xor_eval; + struct shift_left_eval; + struct shift_right_eval; + + BOOST_UNARY_RESULT_OF(~x, result_of_invert) + + BOOST_BINARY_RESULT_OF(x &= y, result_of_and_assign) + BOOST_BINARY_RESULT_OF(x |= y, result_of_or_assign) + BOOST_BINARY_RESULT_OF(x ^= y, result_of_xor_assign) + BOOST_BINARY_RESULT_OF(x <<= y, result_of_shift_left_assign) + BOOST_BINARY_RESULT_OF(x >>= y, result_of_shift_right_assign) + + BOOST_BINARY_RESULT_OF(x & y, result_of_and) + BOOST_BINARY_RESULT_OF(x | y, result_of_or) + BOOST_BINARY_RESULT_OF(x ^ y, result_of_xor) + BOOST_BINARY_RESULT_OF(x << y, result_of_shift_left) + BOOST_BINARY_RESULT_OF(x >> y, result_of_shift_right) + +#define x a0.eval(env) +#define y a1.eval(env) + + PHOENIX_UNARY_EVAL(invert_eval, result_of_invert, ~x) + PHOENIX_UNARY_COMPOSE(invert_eval, ~) + + PHOENIX_BINARY_EVAL(and_assign_eval, result_of_and_assign, x &= y) + PHOENIX_BINARY_EVAL(or_assign_eval, result_of_or_assign, x |= y) + PHOENIX_BINARY_EVAL(xor_assign_eval, result_of_xor_assign, x ^= y) + PHOENIX_BINARY_EVAL(shift_left_assign_eval, result_of_shift_left_assign, x <<= y) + PHOENIX_BINARY_EVAL(shift_right_assign_eval, result_of_shift_right_assign, x >>= y) + + PHOENIX_BINARY_EVAL(and_eval, result_of_and, x & y) + PHOENIX_BINARY_EVAL(or_eval, result_of_or, x | y) + PHOENIX_BINARY_EVAL(xor_eval, result_of_xor, x ^ y) + PHOENIX_BINARY_EVAL(shift_left_eval, result_of_shift_left, x << y) + PHOENIX_BINARY_EVAL(shift_right_eval, result_of_shift_right, x >> y) + + PHOENIX_BINARY_COMPOSE(and_assign_eval, &=) + PHOENIX_BINARY_COMPOSE(or_assign_eval, |=) + PHOENIX_BINARY_COMPOSE(xor_assign_eval, ^=) + PHOENIX_BINARY_COMPOSE(shift_left_assign_eval, <<=) + PHOENIX_BINARY_COMPOSE(shift_right_assign_eval, >>=) + + PHOENIX_BINARY_COMPOSE(and_eval, &) + PHOENIX_BINARY_COMPOSE(or_eval, |) + PHOENIX_BINARY_COMPOSE(xor_eval, ^) + PHOENIX_BINARY_COMPOSE(shift_left_eval, <<) + PHOENIX_BINARY_COMPOSE(shift_right_eval, >>) + +#undef x +#undef y +}} + +#if defined(BOOST_MSVC) +# pragma warning(pop) +#endif + +#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/comparison.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/comparison.hpp new file mode 100644 index 0000000..fe9298c --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/comparison.hpp @@ -0,0 +1,55 @@ +/*============================================================================= + 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 PHOENIX_OPERATOR_COMPARISON_HPP +#define PHOENIX_OPERATOR_COMPARISON_HPP + +#include <boost/spirit/home/phoenix/core/composite.hpp> +#include <boost/spirit/home/phoenix/core/compose.hpp> +#include <boost/spirit/home/phoenix/detail/type_deduction.hpp> +#include <boost/spirit/home/phoenix/operator/detail/unary_eval.hpp> +#include <boost/spirit/home/phoenix/operator/detail/unary_compose.hpp> +#include <boost/spirit/home/phoenix/operator/detail/binary_eval.hpp> +#include <boost/spirit/home/phoenix/operator/detail/binary_compose.hpp> + +namespace boost { namespace phoenix +{ + struct equal_to_eval; + struct not_equal_to_eval; + struct less_eval; + struct less_equal_eval; + struct greater_eval; + struct greater_equal_eval; + + BOOST_BINARY_RESULT_OF(x == y, result_of_equal_to) + BOOST_BINARY_RESULT_OF(x != y, result_of_not_equal_to) + BOOST_BINARY_RESULT_OF(x < y, result_of_less) + BOOST_BINARY_RESULT_OF(x <= y, result_of_less_equal) + BOOST_BINARY_RESULT_OF(x > y, result_of_greater) + BOOST_BINARY_RESULT_OF(x >= y, result_of_greater_equal) + +#define x a0.eval(env) +#define y a1.eval(env) + + PHOENIX_BINARY_EVAL(equal_to_eval, result_of_equal_to, x == y) + PHOENIX_BINARY_EVAL(not_equal_to_eval, result_of_not_equal_to, x != y) + PHOENIX_BINARY_EVAL(less_eval, result_of_less, x < y) + PHOENIX_BINARY_EVAL(less_equal_eval, result_of_less_equal, x <= y) + PHOENIX_BINARY_EVAL(greater_eval, result_of_greater, x > y) + PHOENIX_BINARY_EVAL(greater_equal_eval, result_of_greater_equal, x >= y) + + PHOENIX_BINARY_COMPOSE(equal_to_eval, ==) + PHOENIX_BINARY_COMPOSE(not_equal_to_eval, !=) + PHOENIX_BINARY_COMPOSE(less_eval, <) + PHOENIX_BINARY_COMPOSE(less_equal_eval, <=) + PHOENIX_BINARY_COMPOSE(greater_eval, >) + PHOENIX_BINARY_COMPOSE(greater_equal_eval, >=) + +#undef x +#undef y +}} + +#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/binary_compose.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/binary_compose.hpp new file mode 100644 index 0000000..49335fd --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/binary_compose.hpp @@ -0,0 +1,32 @@ +/*============================================================================= + 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 PHOENIX_OPERATOR_DETAIL_BINARY_COMPOSE_HPP +#define PHOENIX_OPERATOR_DETAIL_BINARY_COMPOSE_HPP + +#define PHOENIX_BINARY_COMPOSE(eval_name, op) \ + template <typename T0, typename T1> \ + inline actor<typename as_composite<eval_name, actor<T0>, actor<T1> >::type> \ + operator op (actor<T0> const& a0, actor<T1> const& a1) \ + { \ + return compose<eval_name>(a0, a1); \ + } \ + \ + template <typename T0, typename T1> \ + inline actor<typename as_composite<eval_name, actor<T0>, T1>::type> \ + operator op (actor<T0> const& a0, T1 const& a1) \ + { \ + return compose<eval_name>(a0, a1); \ + } \ + \ + template <typename T0, typename T1> \ + inline actor<typename as_composite<eval_name, T0, actor<T1> >::type> \ + operator op (T0 const& a0, actor<T1> const& a1) \ + { \ + return compose<eval_name>(a0, a1); \ + } + +#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/binary_eval.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/binary_eval.hpp new file mode 100644 index 0000000..1789882 --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/binary_eval.hpp @@ -0,0 +1,44 @@ +/*============================================================================= + 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 PHOENIX_OPERATOR_DETAIL_BINARY_EVAL_HPP +#define PHOENIX_OPERATOR_DETAIL_BINARY_EVAL_HPP + +#include <boost/mpl/or.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/identity.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/spirit/home/phoenix/core/compose.hpp> + +#define PHOENIX_BINARY_EVAL(eval_name, op_result, expr) \ + struct eval_name \ + { \ + template <typename Env, typename A0, typename A1> \ + struct result \ + { \ + typedef typename A0::template result<Env>::type x_type; \ + typedef typename A1::template result<Env>::type y_type; \ + \ + typedef typename \ + mpl::eval_if< \ + mpl::or_<is_actor<x_type>, is_actor<y_type> > \ + , re_curry<eval_name, x_type, y_type> \ + , op_result<x_type, y_type> \ + >::type \ + type; \ + }; \ + \ + template <typename RT, typename Env, typename A0, typename A1> \ + static RT \ + eval(Env const& env, A0& a0, A1& a1) \ + { \ + return expr; \ + } \ + }; + +#undef x +#undef y +#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/io.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/io.hpp new file mode 100644 index 0000000..d82a153 --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/io.hpp @@ -0,0 +1,78 @@ +/*============================================================================= + 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 PHOENIX_OPERATOR_DETAIL_IO_HPP +#define PHOENIX_OPERATOR_DETAIL_IO_HPP + +#include <boost/spirit/home/phoenix/operator/bitwise.hpp> +#include <boost/spirit/home/phoenix/core/reference.hpp> +#include <boost/utility/addressof.hpp> +#include <boost/utility/enable_if.hpp> +#include <iostream> + +namespace boost { namespace phoenix { namespace detail +{ + typedef char(&no)[1]; + typedef char(&yes)[2]; + + template <typename CharType, typename CharTrait> + yes ostream_test(std::basic_ostream<CharType, CharTrait>*); + no ostream_test(...); + + template <typename CharType, typename CharTrait> + yes istream_test(std::basic_istream<CharType, CharTrait>*); + no istream_test(...); + + template <typename T> + struct is_ostream + { + static T x; + BOOST_STATIC_CONSTANT(bool, + value = sizeof(detail::ostream_test(boost::addressof(x))) == sizeof(yes)); + }; + + template <typename T> + struct is_istream + { + static T x; + BOOST_STATIC_CONSTANT(bool, + value = sizeof(detail::istream_test(boost::addressof(x))) == sizeof(yes)); + }; + + template <typename T0, typename T1> + struct enable_if_ostream : + enable_if< + detail::is_ostream<T0> + , actor< + typename as_composite< + shift_left_eval + , actor<reference<T0> > + , actor<T1> + >::type + > + > + {}; + + template <typename T0, typename T1> + struct enable_if_istream : + enable_if< + detail::is_istream<T0> + , actor< + typename as_composite< + shift_right_eval + , actor<reference<T0> > + , actor<T1> + >::type + > + > + {}; + + typedef std::ios_base& (*iomanip_type)(std::ios_base&); + typedef std::istream& (*imanip_type)(std::istream&); + typedef std::ostream& (*omanip_type)(std::ostream&); +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_eval.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_eval.hpp new file mode 100644 index 0000000..cb77613 --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_eval.hpp @@ -0,0 +1,76 @@ +/*============================================================================= + Copyright (c) 2005-2007 Dan Marsden + Copyright (c) 2005-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_OPERATOR_DETAIL_MEM_FUN_PTR_EVAL_HPP +#define PHOENIX_OPERATOR_DETAIL_MEM_FUN_PTR_EVAL_HPP + +#include <boost/spirit/home/phoenix/core/limits.hpp> +#include <boost/spirit/home/phoenix/core/actor.hpp> + +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/preprocessor/arithmetic/sub.hpp> +#include <boost/preprocessor/arithmetic/dec.hpp> + +#include <boost/mpl/void.hpp> + +#include <boost/type_traits/function_traits.hpp> + +#include <boost/get_pointer.hpp> + +#include <boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_return.hpp> + +namespace boost { namespace phoenix { + + struct mem_fun_ptr_eval + { + template<typename Env, typename PtrActor, typename MemFunPtrActor, + BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PP_SUB(PHOENIX_MEMBER_LIMIT, 2), typename Arg, mpl::void_)> + + struct result + : detail::mem_fun_ptr_return<typename eval_result<MemFunPtrActor, Env>::type> { }; + + template<typename Rt, typename Env, typename PtrActor, typename MemFunPtrActor> + static typename result<Env,PtrActor,MemFunPtrActor>::type + eval(const Env& env, PtrActor& ptrActor, MemFunPtrActor& memFunPtrActor) + { + return (get_pointer(ptrActor.eval(env))->*memFunPtrActor.eval(env))(); + } + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (1, BOOST_PP_DEC(BOOST_PP_DEC(PHOENIX_MEMBER_LIMIT)), "boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_eval.hpp")) + +#include BOOST_PP_ITERATE() + + }; +}} + +#endif + +#else + +#define PHOENIX_ITERATION BOOST_PP_ITERATION() + +#define PHOENIX_EVAL_ARG(z,n,_) arg ## n.eval(env) + + template<typename Rt, typename Env, typename PtrActor, typename MemFunPtrActor, + BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, typename Arg)> + static typename result<Env,PtrActor,MemFunPtrActor, BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION,Arg)>::type + eval(const Env& env, PtrActor& ptrActor, MemFunPtrActor& memFunPtrActor, + BOOST_PP_ENUM_BINARY_PARAMS(PHOENIX_ITERATION, Arg, & arg)) + { + return (get_pointer(ptrActor.eval(env))->*memFunPtrActor.eval(env))( + BOOST_PP_ENUM(PHOENIX_ITERATION,PHOENIX_EVAL_ARG,_)); + } + +#undef PHOENIX_EVAL_ARG +#undef PHOENIX_ITERATION + +#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_gen.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_gen.hpp new file mode 100644 index 0000000..31d5413 --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_gen.hpp @@ -0,0 +1,69 @@ +/*============================================================================= + Copyright (c) 2005-2007 Dan Marsden + Copyright (c) 2005-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_OPERATOR_DETAIL_MEM_FUN_PTR_GEN_HPP +#define PHOENIX_OPERATOR_DETAIL_MEM_FUN_PTR_GEN_HPP + +#include <boost/spirit/home/phoenix/core/composite.hpp> +#include <boost/spirit/home/phoenix/core/compose.hpp> +#include <boost/spirit/home/phoenix/core/as_actor.hpp> +#include <boost/spirit/home/phoenix/core/limits.hpp> +#include <boost/spirit/home/phoenix/core/actor.hpp> + +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/preprocessor/arithmetic/dec.hpp> + +#include <boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_eval.hpp> + +namespace boost { namespace phoenix { + template<typename Actor, typename MemFunPtr> + struct mem_fun_ptr_gen + { + mem_fun_ptr_gen( + const Actor& actor, MemFunPtr memFunPtr) + : mActor(actor), mMemFunPtr(memFunPtr) { } + + actor<typename as_composite<mem_fun_ptr_eval, Actor, typename as_actor<MemFunPtr>::type>::type> + operator()() const + { + return compose<mem_fun_ptr_eval>( + mActor, as_actor<MemFunPtr>::convert(mMemFunPtr)); + } + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (1, BOOST_PP_DEC(BOOST_PP_DEC(PHOENIX_MEMBER_LIMIT)), "boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_gen.hpp")) + +#include BOOST_PP_ITERATE() + + Actor mActor; + MemFunPtr mMemFunPtr; + }; +}} + +#endif +#else + +#define PHOENIX_ITERATION BOOST_PP_ITERATION() + + template<BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, typename Arg)> + actor<typename as_composite< + mem_fun_ptr_eval, Actor, typename as_actor<MemFunPtr>::type, + BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, Arg)>::type> + operator()( + BOOST_PP_ENUM_BINARY_PARAMS(PHOENIX_ITERATION, const Arg, &arg)) const + { + return compose<mem_fun_ptr_eval>( + mActor, as_actor<MemFunPtr>::convert(mMemFunPtr), + BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, arg)); + } + +#undef PHOENIX_ITERATION + +#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_return.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_return.hpp new file mode 100644 index 0000000..102f17f --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_return.hpp @@ -0,0 +1,65 @@ +/*============================================================================= + Copyright (c) 2005-2007 Dan Marsden + Copyright (c) 2005-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_OPERATOR_DETAIL_MEM_FUN_PTR_RETURN_HPP +#define PHOENIX_OPERATOR_DETAIL_MEM_FUN_PTR_RETURN_HPP + +#include <boost/spirit/home/phoenix/core/limits.hpp> + +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> + +namespace boost { namespace phoenix { +namespace detail +{ + template<typename MemFunPtr> + struct mem_fun_ptr_return; + + template<typename Ret, typename Class> + struct mem_fun_ptr_return<Ret (Class::*)()> + { + typedef Ret type; + }; + + template<typename Ret, typename Class> + struct mem_fun_ptr_return<Ret (Class::*)() const> + { + typedef Ret type; + }; + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (1, PHOENIX_MEMBER_LIMIT, "boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_return.hpp")) + +#include BOOST_PP_ITERATE() + +} +}} + +#endif + +#else + +#define PHOENIX_ITERATION BOOST_PP_ITERATION() + + template<typename Ret, typename Class, + BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, typename T)> + struct mem_fun_ptr_return<Ret (Class::*)(BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, T))> + { + typedef Ret type; + }; + + template<typename Ret, typename Class, + BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, typename T)> + struct mem_fun_ptr_return<Ret (Class::*)(BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, T)) const> + { + typedef Ret type; + }; + +#undef PHOENIX_ITERATION + +#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/unary_compose.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/unary_compose.hpp new file mode 100644 index 0000000..fd9a8c7 --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/unary_compose.hpp @@ -0,0 +1,18 @@ +/*============================================================================= + 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 PHOENIX_OPERATOR_DETAIL_UNARY_COMPOSE_HPP +#define PHOENIX_OPERATOR_DETAIL_UNARY_COMPOSE_HPP + +#define PHOENIX_UNARY_COMPOSE(eval_name, op) \ + template <typename T0> \ + inline actor<typename as_composite<eval_name, actor<T0> >::type> \ + operator op (actor<T0> const& a0) \ + { \ + return compose<eval_name>(a0); \ + } + +#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/unary_eval.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/unary_eval.hpp new file mode 100644 index 0000000..501f6df --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/unary_eval.hpp @@ -0,0 +1,40 @@ +/*============================================================================= + 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 PHOENIX_OPERATOR_DETAIL_UNARY_EVAL_HPP +#define PHOENIX_OPERATOR_DETAIL_UNARY_EVAL_HPP + +#include <boost/mpl/eval_if.hpp> +#include <boost/spirit/home/phoenix/core/compose.hpp> + +#define PHOENIX_UNARY_EVAL(eval_name, op_result, expr) \ + struct eval_name \ + { \ + template <typename Env, typename A0> \ + struct result \ + { \ + typedef typename A0::template result<Env>::type x_type; \ + \ + typedef typename \ + mpl::eval_if< \ + is_actor<x_type> \ + , re_curry<eval_name, x_type> \ + , op_result<x_type> \ + >::type \ + type; \ + }; \ + \ + template <typename RT, typename Env, typename A0> \ + static RT \ + eval(Env const& env, A0& a0) \ + { \ + return expr; \ + } \ + }; + +#endif + + diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/if_else.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/if_else.hpp new file mode 100644 index 0000000..8492e90 --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/if_else.hpp @@ -0,0 +1,78 @@ +/*============================================================================= + 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 PHOENIX_OPERATOR_IF_ELSE_HPP +#define PHOENIX_OPERATOR_IF_ELSE_HPP + +#include <boost/mpl/and.hpp> +#include <boost/mpl/if.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/type_traits/is_reference.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/spirit/home/phoenix/core/composite.hpp> +#include <boost/spirit/home/phoenix/core/compose.hpp> +#include <boost/spirit/home/phoenix/detail/type_deduction.hpp> + +namespace boost { namespace phoenix +{ + BOOST_BINARY_RESULT_OF(true ? x : y, result_of_if_else) + + struct if_else_op_eval + { + template < + typename Env + , typename Cond + , typename Then + , typename Else + > + struct result + { + typedef typename Then::template result<Env>::type then_type; + typedef typename Else::template result<Env>::type else_type; + + typedef typename + result_of_if_else<then_type, else_type>::type + ite_result; + + // Note: c ? x : y can return an lvalue! Allow if_else_op_eval + // to return an lvalue IFF then_type and else_type are both lvalues + // with the same type. + + typedef typename + mpl::if_< + mpl::and_< + is_same<then_type, else_type> + , is_reference<then_type> + > + , ite_result + , typename remove_reference<ite_result>::type + >::type + type; + }; + + template < + typename RT + , typename Env + , typename Cond + , typename Then + , typename Else + > + static RT + eval(Env const& env, Cond& cond, Then& then, Else& else_) + { + return cond.eval(env) ? then.eval(env) : else_.eval(env); + } + }; + + template <typename Cond, typename Then, typename Else> + inline actor<typename as_composite<if_else_op_eval, Cond, Then, Else>::type> + if_else(Cond const& cond, Then const& then, Else const& else_) + { + return compose<if_else_op_eval>(cond, then, else_); + } +}} + +#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/io.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/io.hpp new file mode 100644 index 0000000..360a46f --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/io.hpp @@ -0,0 +1,86 @@ +/*============================================================================= + 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 PHOENIX_OPERATOR_IO_HPP +#define PHOENIX_OPERATOR_IO_HPP + +#include <boost/spirit/home/phoenix/operator/detail/io.hpp> + +namespace boost { namespace phoenix +{ +/////////////////////////////////////////////////////////////////////////////// +// +// overloads for std::basic_ostream and std::basic_istream +// +/////////////////////////////////////////////////////////////////////////////// + template <typename T0, typename T1> + inline typename detail::enable_if_ostream<T0, T1>::type + operator<<(T0& a0, actor<T1> const& a1) + { + return compose<shift_left_eval>(phoenix::ref(a0), a1); + } + + template <typename T0, typename T1> + inline typename detail::enable_if_istream<T0, T1>::type + operator>>(T0& a0, actor<T1> const& a1) + { + return compose<shift_right_eval>(phoenix::ref(a0), a1); + } + + // resolve ambiguities with fusion. + template <typename T1> + inline typename detail::enable_if_ostream<std::ostream, T1>::type + operator<<(std::ostream& a0, actor<T1> const& a1) + { + return compose<shift_left_eval>(phoenix::ref(a0), a1); + } + + template <typename T1> + inline typename detail::enable_if_istream<std::istream, T1>::type + operator>>(std::istream& a0, actor<T1> const& a1) + { + return compose<shift_right_eval>(phoenix::ref(a0), a1); + } + +/////////////////////////////////////////////////////////////////////////////// +// +// overloads for I/O manipulators. +// +/////////////////////////////////////////////////////////////////////////////// + template <typename T0> + inline actor<typename as_composite< + shift_left_eval, actor<T0>, detail::omanip_type>::type> + operator<<(actor<T0> const& a0, detail::omanip_type a1) + { + return compose<shift_left_eval>(a0, a1); + } + + template <typename T0> + inline actor<typename as_composite< + shift_left_eval, actor<T0>, detail::iomanip_type>::type> + operator<<(actor<T0> const& a0, detail::iomanip_type a1) + { + return compose<shift_left_eval>(a0, a1); + } + + template <typename T0> + inline actor<typename as_composite< + shift_right_eval, actor<T0>, detail::imanip_type>::type> + operator>>(actor<T0> const& a0, detail::imanip_type a1) + { + return compose<shift_right_eval>(a0, a1); + } + + template <typename T0> + inline actor<typename as_composite< + shift_right_eval, actor<T0>, detail::iomanip_type>::type> + operator>>(actor<T0> const& a0, detail::iomanip_type a1) + { + return compose<shift_right_eval>(a0, a1); + } +}} + +#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/logical.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/logical.hpp new file mode 100644 index 0000000..84619aa --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/logical.hpp @@ -0,0 +1,43 @@ +/*============================================================================= + 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 PHOENIX_OPERATOR_LOGICAL_HPP +#define PHOENIX_OPERATOR_LOGICAL_HPP + +#include <boost/spirit/home/phoenix/core/composite.hpp> +#include <boost/spirit/home/phoenix/core/compose.hpp> +#include <boost/spirit/home/phoenix/detail/type_deduction.hpp> +#include <boost/spirit/home/phoenix/operator/detail/unary_eval.hpp> +#include <boost/spirit/home/phoenix/operator/detail/unary_compose.hpp> +#include <boost/spirit/home/phoenix/operator/detail/binary_eval.hpp> +#include <boost/spirit/home/phoenix/operator/detail/binary_compose.hpp> + +namespace boost { namespace phoenix +{ + struct logical_not_eval; + struct logical_and_eval; + struct logical_or_eval; + + BOOST_UNARY_RESULT_OF(!x, result_of_logical_not) + BOOST_BINARY_RESULT_OF(x && y, result_of_logical_and) + BOOST_BINARY_RESULT_OF(x || y, result_of_logical_or) + +#define x a0.eval(env) +#define y a1.eval(env) + + PHOENIX_UNARY_EVAL(logical_not_eval, result_of_logical_not, !x) + PHOENIX_BINARY_EVAL(logical_and_eval, result_of_logical_and, x && y) + PHOENIX_BINARY_EVAL(logical_or_eval, result_of_logical_or, x || y) + + PHOENIX_UNARY_COMPOSE(logical_not_eval, !) + PHOENIX_BINARY_COMPOSE(logical_and_eval, &&) + PHOENIX_BINARY_COMPOSE(logical_or_eval, ||) + +#undef x +#undef y +}} + +#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/member.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/member.hpp new file mode 100644 index 0000000..27f3e8d --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/member.hpp @@ -0,0 +1,145 @@ +/*============================================================================= + Copyright (c) 2005-2007 Dan Marsden + Copyright (c) 2005-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 PHOENIX_OPERATOR_MEMBER_HPP +#define PHOENIX_OPERATOR_MEMBER_HPP + +#include <boost/spirit/home/phoenix/core/actor.hpp> +#include <boost/spirit/home/phoenix/core/composite.hpp> +#include <boost/spirit/home/phoenix/core/compose.hpp> + +#include <boost/type_traits/add_reference.hpp> +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/is_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/type_traits/is_member_pointer.hpp> +#include <boost/type_traits/is_member_function_pointer.hpp> + +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/identity.hpp> +#include <boost/mpl/and.hpp> +#include <boost/mpl/not.hpp> + +#include <boost/utility/enable_if.hpp> + +#include <boost/get_pointer.hpp> + +#include <boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_gen.hpp> + +#include <memory> + +namespace boost { + template<typename T> class shared_ptr; + template<typename T> class scoped_ptr; + +namespace phoenix { + namespace detail + { + template<typename T> + struct member_type; + + template<typename Class, typename MemberType> + struct member_type<MemberType (Class::*)> + { + typedef MemberType type; + }; + } + + namespace meta + { + template<typename T> + struct pointed_type; + + template<typename T> + struct pointed_type<T*> + { + typedef T type; + }; + + template<typename T> + struct pointed_type<shared_ptr<T> > + { + typedef T type; + }; + + template<typename T> + struct pointed_type<scoped_ptr<T> > + { + typedef T type; + }; + + template<typename T> + struct pointed_type<std::auto_ptr<T> > + { + typedef T type; + }; + } + + struct member_object_eval + { + template<typename Env, typename PtrActor, typename MemPtrActor> + struct result + { + typedef typename detail::member_type< + typename eval_result<MemPtrActor, Env>::type>::type member_type; + + typedef typename meta::pointed_type< + typename remove_reference< + typename eval_result<PtrActor, Env>::type>::type>::type object_type; + + typedef typename add_reference< + typename mpl::eval_if< + is_const<object_type>, + add_const<member_type>, + mpl::identity<member_type> >::type>::type type; + }; + + template<typename Rt, typename Env, typename PtrActor, typename MemPtrActor> + static typename result<Env,PtrActor,MemPtrActor>::type + eval(const Env& env, PtrActor& ptrActor, MemPtrActor& memPtrActor) + { + return get_pointer(ptrActor.eval(env))->*memPtrActor.eval(env); + } + }; + + namespace member_object + { + template<typename T0, typename MemObjPtr> + typename enable_if< + mpl::and_<is_member_pointer<MemObjPtr>, mpl::not_<is_member_function_pointer<MemObjPtr> > >, + actor<typename as_composite< + member_object_eval, actor<T0>, + typename as_actor<MemObjPtr>::type>::type> >::type + operator->*( + const actor<T0>& ptrActor, + MemObjPtr memObjPtr) + { + return compose<member_object_eval>( + ptrActor, + as_actor<MemObjPtr>::convert(memObjPtr)); + } + } + + namespace member_function + { + template<typename T0, typename MemFunPtr> + typename enable_if< + is_member_function_pointer<MemFunPtr>, + mem_fun_ptr_gen<actor<T0>, MemFunPtr> >::type + operator->*(const actor<T0>& ptrActor, MemFunPtr memFunPtr) + { + return mem_fun_ptr_gen<actor<T0>, MemFunPtr>( + ptrActor, memFunPtr); + } + } + + using member_object::operator->*; + using member_function::operator->*; +}} + +#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/self.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/self.hpp new file mode 100644 index 0000000..294adf6 --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/self.hpp @@ -0,0 +1,75 @@ +/*============================================================================= + 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 PHOENIX_OPERATOR_SELF_HPP +#define PHOENIX_OPERATOR_SELF_HPP + +#include <boost/spirit/home/phoenix/core/composite.hpp> +#include <boost/spirit/home/phoenix/core/compose.hpp> +#include <boost/spirit/home/phoenix/detail/type_deduction.hpp> +#include <boost/spirit/home/phoenix/operator/detail/unary_eval.hpp> +#include <boost/spirit/home/phoenix/operator/detail/unary_compose.hpp> +#include <boost/spirit/home/phoenix/operator/detail/binary_eval.hpp> +#include <boost/spirit/home/phoenix/operator/detail/binary_compose.hpp> + +namespace boost { namespace phoenix +{ + struct reference_eval; + struct dereference_eval; + struct assign_eval; + struct index_eval; + + BOOST_UNARY_RESULT_OF(&x, result_of_reference) + BOOST_UNARY_RESULT_OF(*x, result_of_dereference) + BOOST_BINARY_RESULT_OF(x = y, result_of_assign) + BOOST_ASYMMETRIC_BINARY_RESULT_OF(x[y], result_of_index) + + namespace detail + { + template <typename T0, typename T1> + struct make_assign_composite + { + typedef actor<typename as_composite<assign_eval, T0, T1>::type> type; + }; + + template <typename T0, typename T1> + struct make_index_composite + { + typedef actor<typename as_composite<index_eval, T0, T1>::type> type; + }; + } + + template <typename Base> + template <typename T1> + typename detail::make_assign_composite<actor<Base>, T1>::type + actor<Base>::operator=(T1 const& a1) const + { + return compose<assign_eval>(*this, a1); + } + + template <typename Base> + template <typename T1> + typename detail::make_index_composite<actor<Base>, T1>::type + actor<Base>::operator[](T1 const& a1) const + { + return compose<index_eval>(*this, a1); + } + +#define x a0.eval(env) +#define y a1.eval(env) + + PHOENIX_UNARY_EVAL(reference_eval, result_of_reference, &x) + PHOENIX_UNARY_EVAL(dereference_eval, result_of_dereference, *x) + PHOENIX_UNARY_COMPOSE(reference_eval, &) + PHOENIX_UNARY_COMPOSE(dereference_eval, *) + + PHOENIX_BINARY_EVAL(assign_eval, result_of_assign, x = y) + PHOENIX_BINARY_EVAL(index_eval, result_of_index, x[y]) +}} + +#undef x +#undef y +#endif |