blob: f67a6d047652b99c72baf7ef5cb3d6956b475640 [file] [log] [blame]
/*=============================================================================
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;
}