/*============================================================================= | |
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 |