312 lines
9.8 KiB
C++
312 lines
9.8 KiB
C++
/*=============================================================================
|
|
Phoenix V1.2.1
|
|
Copyright (c) 2001-2003 Joel de Guzman
|
|
|
|
Use, modification and distribution is subject to 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)
|
|
==============================================================================*/
|
|
#include <vector>
|
|
#include <algorithm>
|
|
#include <iostream>
|
|
|
|
#define PHOENIX_LIMIT 5
|
|
#include <boost/spirit/include/phoenix1_operators.hpp>
|
|
#include <boost/spirit/include/phoenix1_primitives.hpp>
|
|
#include <boost/spirit/include/phoenix1_composite.hpp>
|
|
#include <boost/spirit/include/phoenix1_special_ops.hpp>
|
|
#include <boost/spirit/include/phoenix1_statements.hpp>
|
|
|
|
namespace phoenix {
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// local_tuple
|
|
//
|
|
// This *is a* tuple like the one we see in TupleT in any actor
|
|
// base class' eval member function. local_tuple should look and
|
|
// feel the same as a tupled-args, that's why it is derived from
|
|
// TupleArgsT. It has an added member, locs which is another tuple
|
|
// where the local variables will be stored. locs is mutable to
|
|
// allow read-write access to our locals regardless of
|
|
// local_tuple's constness (The eval member function accepts it as
|
|
// a const argument).
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
template <typename TupleArgsT, typename TupleLocsT>
|
|
struct local_tuple : public TupleArgsT {
|
|
|
|
typedef TupleLocsT local_vars_t;
|
|
typedef TupleArgsT parent_t;
|
|
|
|
local_tuple(TupleArgsT const& args, TupleLocsT const& locs_)
|
|
: TupleArgsT(args), locs(locs_) {}
|
|
|
|
TupleArgsT& parent() { return *this; }
|
|
TupleArgsT const& parent() const { return *this; }
|
|
|
|
mutable TupleLocsT locs;
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// local_var_result
|
|
//
|
|
// This is a return type computer. Given a constant integer N, a
|
|
// parent index and a tuple, get the Nth local variable type. The
|
|
// parent index is an integer specifying which parent scope to
|
|
// access; 0==current scope, 1==parent scope, 2==parent's parent
|
|
// scope.
|
|
//
|
|
// This is a metaprogram with partial specializations. There is a
|
|
// general case, a special case for local_tuples and a terminating
|
|
// special case for local_tuples.
|
|
//
|
|
// General case: If TupleT is not really a local_tuple, we just return nil_t.
|
|
//
|
|
// local_tuples case:
|
|
// Parent index is 0: We get the Nth local variable.
|
|
// Otherwise: We subclass from local_tuples<N, Parent-1, TupleArgsT>
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
template <int N, int Parent, typename TupleT>
|
|
struct local_var_result {
|
|
|
|
typedef nil_t type;
|
|
};
|
|
|
|
//////////////////////////////////
|
|
template <int N, int Parent, typename TupleArgsT, typename TupleLocsT>
|
|
struct local_var_result<N, Parent, local_tuple<TupleArgsT, TupleLocsT> >
|
|
: public local_var_result<N, Parent-1, TupleArgsT> {};
|
|
|
|
//////////////////////////////////
|
|
template <int N, typename TupleArgsT, typename TupleLocsT>
|
|
struct local_var_result<N, 0, local_tuple<TupleArgsT, TupleLocsT> > {
|
|
|
|
typedef typename tuple_element<
|
|
N, TupleLocsT
|
|
>::type& type;
|
|
|
|
static type get(local_tuple<TupleArgsT, TupleLocsT> const& tuple)
|
|
{ return tuple.locs[tuple_index<N>()]; }
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// local_var
|
|
//
|
|
// This class looks so curiously like the argument class. local_var
|
|
// provides access to the Nth local variable packed in the tuple
|
|
// duo local_tuple above. Parent specifies the Nth parent scope.
|
|
// 0==current scope, 1==parent scope, 2==parent's parent scope. The
|
|
// member function parent<N>() may be called to provide access to
|
|
// outer scopes.
|
|
//
|
|
// Note that the member function eval expects a local_tuple
|
|
// argument. Otherwise there will be acompile-time error. local_var
|
|
// primitives only work within the context of a context_composite
|
|
// (see below).
|
|
//
|
|
// Provided are some predefined local_var actors for 0..N local
|
|
// variable access: loc1..locN.
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
template <int N, int Parent = 0>
|
|
struct local_var {
|
|
|
|
template <typename TupleT>
|
|
struct result {
|
|
|
|
typedef typename local_var_result<N, Parent, TupleT>::type type;
|
|
};
|
|
|
|
template <typename TupleT>
|
|
typename local_var_result<N, Parent, TupleT>::type
|
|
eval(TupleT const& tuple) const
|
|
{
|
|
return local_var_result<N, Parent, TupleT>::get(tuple);
|
|
}
|
|
|
|
template <int PIndex>
|
|
actor<local_var<N, Parent+PIndex> >
|
|
parent() const
|
|
{
|
|
return local_var<N, Parent+PIndex>();
|
|
}
|
|
};
|
|
|
|
//////////////////////////////////
|
|
namespace locals {
|
|
|
|
actor<local_var<0> > const result = local_var<0>();
|
|
actor<local_var<1> > const loc1 = local_var<1>();
|
|
actor<local_var<2> > const loc2 = local_var<2>();
|
|
actor<local_var<3> > const loc3 = local_var<3>();
|
|
actor<local_var<4> > const loc4 = local_var<4>();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// context_composite
|
|
//
|
|
// This class encapsulates an actor and some local variable
|
|
// initializers packed in a tuple.
|
|
//
|
|
// context_composite is just like a proxy and delegates the actual
|
|
// evaluation to the actor. The actor does the actual work. In the
|
|
// eval member function, before invoking the embedded actor's eval
|
|
// member function, we first stuff an instance of our locals and
|
|
// bundle both 'args' and 'locals' in a local_tuple. This
|
|
// local_tuple instance is created in the stack initializing it
|
|
// with our locals member. We then pass this local_tuple instance
|
|
// as an argument to the actor's eval member function.
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
template <typename ActorT, typename LocsT>
|
|
struct context_composite {
|
|
|
|
typedef context_composite<ActorT, LocsT> self_t;
|
|
|
|
template <typename TupleT>
|
|
struct result { typedef typename tuple_element<0, LocsT>::type type; };
|
|
|
|
context_composite(ActorT const& actor_, LocsT const& locals_)
|
|
: actor(actor_), locals(locals_) {}
|
|
|
|
template <typename TupleT>
|
|
typename tuple_element<0, LocsT>::type
|
|
eval(TupleT const& args) const
|
|
{
|
|
local_tuple<TupleT, LocsT> local_context(args, locals);
|
|
actor.eval(local_context);
|
|
return local_context.locs[tuple_index<0>()];
|
|
}
|
|
|
|
ActorT actor;
|
|
LocsT locals;
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// context_gen
|
|
//
|
|
// At construction time, this class is given some local var-
|
|
// initializers packed in a tuple. We just store this for later.
|
|
// The operator[] of this class creates the actual context_composite
|
|
// given an actor. This is responsible for the construct
|
|
// context<types>[actor].
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
template <typename LocsT>
|
|
struct context_gen {
|
|
|
|
context_gen(LocsT const& locals_)
|
|
: locals(locals_) {}
|
|
|
|
template <typename ActorT>
|
|
actor<context_composite<typename as_actor<ActorT>::type, LocsT> >
|
|
operator[](ActorT const& actor)
|
|
{
|
|
return context_composite<typename as_actor<ActorT>::type, LocsT>
|
|
(as_actor<ActorT>::convert(actor), locals);
|
|
}
|
|
|
|
LocsT locals;
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Front end generator functions. These generators are overloaded for
|
|
// 1..N local variables. context<T0,... TN>(i0,...iN) generate context_gen
|
|
// objects (see above).
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
template <typename T0>
|
|
inline context_gen<tuple<T0> >
|
|
context()
|
|
{
|
|
typedef tuple<T0> tuple_t;
|
|
return context_gen<tuple_t>(tuple_t(T0()));
|
|
}
|
|
|
|
//////////////////////////////////
|
|
template <typename T0, typename T1>
|
|
inline context_gen<tuple<T0, T1> >
|
|
context(
|
|
T1 const& _1 = T1()
|
|
)
|
|
{
|
|
typedef tuple<T0, T1> tuple_t;
|
|
return context_gen<tuple_t>(tuple_t(T0(), _1));
|
|
}
|
|
|
|
//////////////////////////////////
|
|
template <typename T0, typename T1, typename T2>
|
|
inline context_gen<tuple<T0, T1, T2> >
|
|
context(
|
|
T1 const& _1 = T1(),
|
|
T2 const& _2 = T2()
|
|
)
|
|
{
|
|
typedef tuple<T0, T1, T2> tuple_t;
|
|
return context_gen<tuple_t>(tuple_t(T0(), _1, _2));
|
|
}
|
|
|
|
//////////////////////////////////
|
|
template <typename T0, typename T1, typename T2, typename T3>
|
|
inline context_gen<tuple<T0, T1, T2, T3> >
|
|
context(
|
|
T1 const& _1 = T1(),
|
|
T2 const& _2 = T2(),
|
|
T3 const& _3 = T3()
|
|
)
|
|
{
|
|
typedef tuple<T0, T1, T2, T3> tuple_t;
|
|
return context_gen<tuple_t>(tuple_t(T0(), _1, _2, _3));
|
|
}
|
|
|
|
//////////////////////////////////
|
|
template <typename T0, typename T1, typename T2, typename T3, typename T4>
|
|
inline context_gen<tuple<T0, T1, T2, T3, T4> >
|
|
context(
|
|
T1 const& _1 = T1(),
|
|
T2 const& _2 = T2(),
|
|
T3 const& _3 = T3(),
|
|
T4 const& _4 = T4()
|
|
)
|
|
{
|
|
typedef tuple<T0, T1, T2, T3> tuple_t;
|
|
return context_gen<tuple_t>(tuple_t(T0(), _1, _2, _3, _4));
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
}
|
|
|
|
//////////////////////////////////
|
|
using namespace std;
|
|
using namespace phoenix;
|
|
using namespace phoenix::locals;
|
|
|
|
//////////////////////////////////
|
|
int
|
|
main()
|
|
{
|
|
context<nil_t>(1)
|
|
[
|
|
cout << loc1 << '\n',
|
|
context<nil_t>(2)
|
|
[
|
|
cout << loc1.parent<1>() << ' ' << loc1 << '\n',
|
|
context<nil_t>(3)
|
|
[
|
|
cout << loc1.parent<2>() << ' ' << loc1.parent<1>() << ' ' << loc1 << '\n'
|
|
]
|
|
]
|
|
]
|
|
|
|
();
|
|
|
|
return 0;
|
|
}
|