285 lines
8.7 KiB
C++
285 lines
8.7 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;
|
|
|
|
local_tuple(TupleArgsT const& args, TupleLocsT const& locs_)
|
|
: TupleArgsT(args), locs(locs_) {}
|
|
|
|
mutable TupleLocsT locs;
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// local_var_result
|
|
//
|
|
// This is a return type computer. Given a constant integer N and a
|
|
// tuple, get the Nth local variable type. If TupleT is not really
|
|
// a local_tuple, we just return nil_t. Otherwise we get the Nth
|
|
// local variable type.
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
template <int N, typename TupleT>
|
|
struct local_var_result {
|
|
|
|
typedef nil_t type;
|
|
};
|
|
|
|
//////////////////////////////////
|
|
template <int N, typename TupleArgsT, typename TupleLocsT>
|
|
struct local_var_result<N, local_tuple<TupleArgsT, TupleLocsT> > {
|
|
|
|
typedef typename tuple_element<N, TupleLocsT>::type& type;
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// 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. Note that the member function eval
|
|
// expects a local_tuple argument. Otherwise the expression
|
|
// 'tuple.locs' will fail (compile-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>
|
|
struct local_var {
|
|
|
|
template <typename TupleT>
|
|
struct result {
|
|
|
|
typedef typename local_var_result<N, TupleT>::type type;
|
|
};
|
|
|
|
template <typename TupleT>
|
|
typename local_var_result<N, TupleT>::type
|
|
eval(TupleT const& tuple) const
|
|
{
|
|
return tuple.locs[tuple_index<N>()];
|
|
}
|
|
};
|
|
|
|
//////////////////////////////////
|
|
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()
|
|
{
|
|
int init[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
|
|
vector<int> c(init, init + 10);
|
|
typedef vector<int>::iterator iterator;
|
|
|
|
// find the first element > 5, print each element
|
|
// as we traverse the container c. Print the result
|
|
// if one is found.
|
|
|
|
find_if(c.begin(), c.end(),
|
|
context<bool>()
|
|
[
|
|
cout << arg1,
|
|
result = arg1 > 5,
|
|
if_(!result)
|
|
[
|
|
cout << val(", ")
|
|
]
|
|
.else_
|
|
[
|
|
cout << val(" found result == ") << arg1
|
|
]
|
|
]
|
|
);
|
|
|
|
return 0;
|
|
}
|