| /*============================================================================= |
| Copyright (c) 2001-2007 Joel de Guzman |
| Copyright (c) 2004 Daniel Wallin |
| |
| 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_SCOPE_DYNAMIC_HPP |
| #define PHOENIX_SCOPE_DYNAMIC_HPP |
| |
| #include <boost/spirit/home/phoenix/core/limits.hpp> |
| #include <boost/fusion/include/at.hpp> |
| #include <boost/fusion/include/vector.hpp> |
| #include <boost/spirit/home/phoenix/core/actor.hpp> |
| |
| #include <boost/preprocessor/cat.hpp> |
| #include <boost/preprocessor/punctuation/comma_if.hpp> |
| #include <boost/preprocessor/seq/for_each_i.hpp> |
| #include <boost/preprocessor/tuple/elem.hpp> |
| #include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> |
| #include <boost/preprocessor/repetition/enum_params.hpp> |
| #include <boost/preprocessor/cat.hpp> |
| #include <boost/preprocessor/inc.hpp> |
| |
| #include <boost/noncopyable.hpp> |
| #include <boost/assert.hpp> |
| |
| #define PHOENIX_DYNAMIC_MEMBER(z, n, data) \ |
| typedef actor<dynamic_member<n, self_type> > \ |
| BOOST_PP_CAT(member, BOOST_PP_INC(n)); |
| |
| namespace boost { namespace phoenix |
| { |
| template <typename DynamicScope> |
| struct dynamic_frame : noncopyable |
| { |
| typedef typename DynamicScope::tuple_type tuple_type; |
| |
| dynamic_frame(DynamicScope const& scope) |
| : tuple() |
| , save(scope.frame) |
| , scope(scope) |
| { |
| scope.frame = this; |
| } |
| |
| template <typename Tuple> |
| dynamic_frame(DynamicScope const& scope, Tuple const& init) |
| : tuple(init) |
| , save(scope.frame) |
| , scope(scope) |
| { |
| scope.frame = this; |
| } |
| |
| ~dynamic_frame() |
| { |
| scope.frame = save; |
| } |
| |
| tuple_type& data() { return tuple; } |
| tuple_type const& data() const { return tuple; } |
| |
| private: |
| |
| tuple_type tuple; |
| dynamic_frame* save; |
| DynamicScope const& scope; |
| }; |
| |
| template <int N, typename DynamicScope> |
| struct dynamic_member |
| { |
| typedef mpl::false_ no_nullary; |
| typedef typename DynamicScope::tuple_type tuple_type; |
| |
| dynamic_member(DynamicScope const& scope) |
| : scope(scope) {} |
| |
| template <typename Env> |
| struct result |
| { |
| typedef typename |
| fusion::result_of::at_c<tuple_type, N>::type |
| type; |
| }; |
| |
| template <typename Env> |
| typename result<Env>::type |
| eval(Env const& /*env*/) const |
| { |
| BOOST_ASSERT(scope.frame != 0); |
| return fusion::at_c<N>(scope.frame->data()); |
| } |
| |
| private: |
| |
| DynamicScope const& scope; |
| }; |
| |
| template <BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(PHOENIX_DYNAMIC_LIMIT, typename T, void_)> |
| struct dynamic : noncopyable |
| { |
| typedef fusion::vector<BOOST_PP_ENUM_PARAMS(PHOENIX_DYNAMIC_LIMIT, T)> tuple_type; |
| typedef dynamic<BOOST_PP_ENUM_PARAMS(PHOENIX_DYNAMIC_LIMIT, T)> self_type; |
| typedef dynamic_frame<self_type> dynamic_frame_type; |
| |
| dynamic() |
| : frame(0) {} |
| |
| BOOST_PP_REPEAT(PHOENIX_DYNAMIC_LIMIT, PHOENIX_DYNAMIC_MEMBER, _) |
| |
| private: |
| |
| template <int N, typename DynamicScope> |
| friend struct dynamic_member; |
| |
| template <typename DynamicScope> |
| friend struct dynamic_frame; |
| |
| mutable dynamic_frame_type* frame; |
| }; |
| }} |
| |
| #if defined(BOOST_MSVC) |
| # pragma warning(push) |
| # pragma warning(disable:4355) |
| #endif |
| |
| /* |
| PHOENIX_DYNAMIC macro(name, type-name sequence) |
| Example: |
| |
| PHOENIX_DYNAMIC( |
| my_dynamic, |
| (int, num) |
| (std::string, message) |
| (double, real) |
| ); |
| |
| which expands to: |
| |
| struct my_dynamic : ::boost::phoenix::dynamic<int, std::string, double> |
| { |
| my_dynamic() : num(*this), message(*this), real(*this) {} |
| |
| member1 num; |
| member2 message; |
| member3 real; |
| }; |
| |
| PHOENIX_DYNAMIC takes the input (containing a binary sequence) |
| and converts that sequence to a unary sequence of |
| binary tuples and passes it on to PHOENIX_DYNAMIC_I. |
| |
| Thanks to Paul Mensonides for the PP macro help |
| */ |
| |
| #define PHOENIX_DYNAMIC(name, bseq) \ |
| PHOENIX_DYNAMIC_I(name, BOOST_PP_CAT(PHOENIX_DYNAMIC_X bseq, 0)) \ |
| |
| #define PHOENIX_DYNAMIC_X(x, y) ((x, y)) PHOENIX_DYNAMIC_Y |
| #define PHOENIX_DYNAMIC_Y(x, y) ((x, y)) PHOENIX_DYNAMIC_X |
| #define PHOENIX_DYNAMIC_X0 |
| #define PHOENIX_DYNAMIC_Y0 |
| |
| // PHOENIX_DYNAMIC_I generates the overarching structure and uses |
| // SEQ_FOR_EACH_I to generate the "linear" substructures. |
| |
| #define PHOENIX_DYNAMIC_I(name, seq) \ |
| struct name : \ |
| ::boost::phoenix::dynamic< \ |
| BOOST_PP_SEQ_FOR_EACH_I(PHOENIX_DYNAMIC_A, ~, seq)> { \ |
| name() : BOOST_PP_SEQ_FOR_EACH_I(PHOENIX_DYNAMIC_B, ~, seq) {} \ |
| BOOST_PP_SEQ_FOR_EACH_I(PHOENIX_DYNAMIC_C, ~, seq) \ |
| } \ |
| |
| #define PHOENIX_DYNAMIC_A(r, _, i, xy) \ |
| BOOST_PP_COMMA_IF(i) BOOST_PP_TUPLE_ELEM(2, 0, xy) \ |
| |
| #define PHOENIX_DYNAMIC_B(r, _, i, xy) \ |
| BOOST_PP_COMMA_IF(i) BOOST_PP_TUPLE_ELEM(2, 1, xy)(*this) \ |
| |
| #define PHOENIX_DYNAMIC_C(r, _, i, xy) \ |
| BOOST_PP_CAT(member, BOOST_PP_INC(i)) BOOST_PP_TUPLE_ELEM(2, 1, xy); \ |
| |
| #undef PHOENIX_DYNAMIC_MEMBER |
| |
| #if defined(BOOST_MSVC) |
| # pragma warning(pop) |
| #endif |
| |
| #endif |