anulax
/
glm
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity
OpenGL Mathematics (GLM)
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
1093 Commits
1 Branch
0 Tags
73 MiB
 
 
 
Tag: Branch: Tree: aebcd7ec3f
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from "aebcd7ec3f"
${ noResults }
glm/test/external/boost/spirit/home/classic/phoenix/closures.hpp

446 lines
14 KiB
Raw Blame History

/*=============================================================================
Phoenix V1.2.1
Copyright (c) 2001-2002 Joel de Guzman
MT code Copyright (c) 2002-2003 Martin Wille
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 CLASSIC_PHOENIX_CLOSURES_HPP
#define CLASSIC_PHOENIX_CLOSURES_HPP
///////////////////////////////////////////////////////////////////////////////
#include <boost/spirit/home/classic/phoenix/actor.hpp>
#include <boost/assert.hpp>
#ifdef PHOENIX_THREADSAFE
#include <boost/thread/tss.hpp>
#include <boost/thread/once.hpp>
#endif
///////////////////////////////////////////////////////////////////////////////
namespace phoenix {
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
#pragma warning(push)
#pragma warning(disable:4512) //assignment operator could not be generated
#endif
///////////////////////////////////////////////////////////////////////////////
//
// Adaptable closures
//
// The framework will not be complete without some form of closures
// support. Closures encapsulate a stack frame where local
// variables are created upon entering a function and destructed
// upon exiting. Closures provide an environment for local
// variables to reside. Closures can hold heterogeneous types.
//
// Phoenix closures are true hardware stack based closures. At the
// very least, closures enable true reentrancy in lambda functions.
// A closure provides access to a function stack frame where local
// variables reside. Modeled after Pascal nested stack frames,
// closures can be nested just like nested functions where code in
// inner closures may access local variables from in-scope outer
// closures (accessing inner scopes from outer scopes is an error
// and will cause a run-time assertion failure).
//
// There are three (3) interacting classes:
//
// 1) closure:
//
// At the point of declaration, a closure does not yet create a
// stack frame nor instantiate any variables. A closure declaration
// declares the types and names[note] of the local variables. The
// closure class is meant to be subclassed. It is the
// responsibility of a closure subclass to supply the names for
// each of the local variable in the closure. Example:
//
// struct my_closure : closure<int, string, double> {
//
// member1 num; // names the 1st (int) local variable
// member2 message; // names the 2nd (string) local variable
// member3 real; // names the 3rd (double) local variable
// };
//
// my_closure clos;
//
// Now that we have a closure 'clos', its local variables can be
// accessed lazily using the dot notation. Each qualified local
// variable can be used just like any primitive actor (see
// primitives.hpp). Examples:
//
// clos.num = 30
// clos.message = arg1
// clos.real = clos.num * 1e6
//
// The examples above are lazily evaluated. As usual, these
// expressions return composite actors that will be evaluated
// through a second function call invocation (see operators.hpp).
// Each of the members (clos.xxx) is an actor. As such, applying
// the operator() will reveal its identity:
//
// clos.num() // will return the current value of clos.num
//
// *** [note] Acknowledgement: Juan Carlos Arevalo-Baeza (JCAB)
// introduced and initilally implemented the closure member names
// that uses the dot notation.
//
// 2) closure_member
//
// The named local variables of closure 'clos' above are actually
// closure members. The closure_member class is an actor and
// conforms to its conceptual interface. member1..memberN are
// predefined typedefs that correspond to each of the listed types
// in the closure template parameters.
//
// 3) closure_frame
//
// When a closure member is finally evaluated, it should refer to
// an actual instance of the variable in the hardware stack.
// Without doing so, the process is not complete and the evaluated
// member will result to an assertion failure. Remember that the
// closure is just a declaration. The local variables that a
// closure refers to must still be instantiated.
//
// The closure_frame class does the actual instantiation of the
// local variables and links these variables with the closure and
// all its members. There can be multiple instances of
// closure_frames typically situated in the stack inside a
// function. Each closure_frame instance initiates a stack frame
// with a new set of closure local variables. Example:
//
// void foo()
// {
// closure_frame<my_closure> frame(clos);
// /* do something */
// }
//
// where 'clos' is an instance of our closure 'my_closure' above.
// Take note that the usage above precludes locally declared
// classes. If my_closure is a locally declared type, we can still
// use its self_type as a paramater to closure_frame:
//
// closure_frame<my_closure::self_type> frame(clos);
//
// Upon instantiation, the closure_frame links the local variables
// to the closure. The previous link to another closure_frame
// instance created before is saved. Upon destruction, the
// closure_frame unlinks itself from the closure and relinks the
// preceding closure_frame prior to this instance.
//
// The local variables in the closure 'clos' above is default
// constructed in the stack inside function 'foo'. Once 'foo' is
// exited, all of these local variables are destructed. In some
// cases, default construction is not desirable and we need to
// initialize the local closure variables with some values. This
// can be done by passing in the initializers in a compatible
// tuple. A compatible tuple is one with the same number of
// elements as the destination and where each element from the
// destination can be constructed from each corresponding element
// in the source. Example:
//
// tuple<int, char const*, int> init(123, "Hello", 1000);
// closure_frame<my_closure> frame(clos, init);
//
// Here now, our closure_frame's variables are initialized with
// int: 123, char const*: "Hello" and int: 1000.
//
///////////////////////////////////////////////////////////////////////////////
namespace impl
{
///////////////////////////////////////////////////////////////////////
// closure_frame_holder is a simple class that encapsulates the
// storage for a frame pointer. It uses thread specific data in
// case when multithreading is enabled, an ordinary pointer otherwise
//
// it has get() and set() member functions. set() has to be used
// _after_ get(). get() contains intialisation code in the multi
// threading case
//
// closure_frame_holder is used by the closure<> class to store
// the pointer to the current frame.
//
#ifndef PHOENIX_THREADSAFE
template <typename FrameT>
struct closure_frame_holder
{
typedef FrameT frame_t;
typedef frame_t *frame_ptr;
closure_frame_holder() : frame(0) {}
frame_ptr &get() { return frame; }
void set(frame_t *f) { frame = f; }
private:
frame_ptr frame;
// no copies, no assignments
closure_frame_holder(closure_frame_holder const &);
closure_frame_holder &operator=(closure_frame_holder const &);
};
#else
template <typename FrameT>
struct closure_frame_holder
{
typedef FrameT frame_t;
typedef frame_t *frame_ptr;
closure_frame_holder() : tsp_frame() {}
frame_ptr &get()
{
if (!tsp_frame.get())
tsp_frame.reset(new frame_ptr(0));
return *tsp_frame;
}
void set(frame_ptr f)
{
*tsp_frame = f;
}
private:
boost::thread_specific_ptr<frame_ptr> tsp_frame;
// no copies, no assignments
closure_frame_holder(closure_frame_holder const &);
closure_frame_holder &operator=(closure_frame_holder const &);
};
#endif
} // namespace phoenix::impl
///////////////////////////////////////////////////////////////////////////////
//
// closure_frame class
//
///////////////////////////////////////////////////////////////////////////////
template <typename ClosureT>
class closure_frame : public ClosureT::tuple_t {
public:
closure_frame(ClosureT const& clos)
: ClosureT::tuple_t(), save(clos.frame.get()), frame(clos.frame)
{ clos.frame.set(this); }
template <typename TupleT>
closure_frame(ClosureT const& clos, TupleT const& init)
: ClosureT::tuple_t(init), save(clos.frame.get()), frame(clos.frame)
{ clos.frame.set(this); }
~closure_frame()
{ frame.set(save); }
private:
closure_frame(closure_frame const&); // no copy
closure_frame& operator=(closure_frame const&); // no assign
closure_frame* save;
impl::closure_frame_holder<closure_frame>& frame;
};
///////////////////////////////////////////////////////////////////////////////
//
// closure_member class
//
///////////////////////////////////////////////////////////////////////////////
template <int N, typename ClosureT>
class closure_member {
public:
typedef typename ClosureT::tuple_t tuple_t;
closure_member()
: frame(ClosureT::closure_frame_holder_ref()) {}
template <typename TupleT>
struct result {
typedef typename tuple_element<
N, typename ClosureT::tuple_t
>::rtype type;
};
template <typename TupleT>
typename tuple_element<N, typename ClosureT::tuple_t>::rtype
eval(TupleT const& /*args*/) const
{
using namespace std;
BOOST_ASSERT(frame.get() != 0);
return (*frame.get())[tuple_index<N>()];
}
private:
impl::closure_frame_holder<typename ClosureT::closure_frame_t> &frame;
};
///////////////////////////////////////////////////////////////////////////////
//
// closure class
//
///////////////////////////////////////////////////////////////////////////////
template <
typename T0 = nil_t
, typename T1 = nil_t
, typename T2 = nil_t
#if PHOENIX_LIMIT > 3
, typename T3 = nil_t
, typename T4 = nil_t
, typename T5 = nil_t
#if PHOENIX_LIMIT > 6
, typename T6 = nil_t
, typename T7 = nil_t
, typename T8 = nil_t
#if PHOENIX_LIMIT > 9
, typename T9 = nil_t
, typename T10 = nil_t
, typename T11 = nil_t
#if PHOENIX_LIMIT > 12
, typename T12 = nil_t
, typename T13 = nil_t
, typename T14 = nil_t
#endif
#endif
#endif
#endif
>
class closure {
public:
typedef tuple<
T0, T1, T2
#if PHOENIX_LIMIT > 3
, T3, T4, T5
#if PHOENIX_LIMIT > 6
, T6, T7, T8
#if PHOENIX_LIMIT > 9
, T9, T10, T11
#if PHOENIX_LIMIT > 12
, T12, T13, T14
#endif
#endif
#endif
#endif
> tuple_t;
typedef closure<
T0, T1, T2
#if PHOENIX_LIMIT > 3
, T3, T4, T5
#if PHOENIX_LIMIT > 6
, T6, T7, T8
#if PHOENIX_LIMIT > 9
, T9, T10, T11
#if PHOENIX_LIMIT > 12
, T12, T13, T14
#endif
#endif
#endif
#endif
> self_t;
typedef closure_frame<self_t> closure_frame_t;
closure()
: frame() { closure_frame_holder_ref(&frame); }
typedef actor<closure_member<0, self_t> > member1;
typedef actor<closure_member<1, self_t> > member2;
typedef actor<closure_member<2, self_t> > member3;
#if PHOENIX_LIMIT > 3
typedef actor<closure_member<3, self_t> > member4;
typedef actor<closure_member<4, self_t> > member5;
typedef actor<closure_member<5, self_t> > member6;
#if PHOENIX_LIMIT > 6
typedef actor<closure_member<6, self_t> > member7;
typedef actor<closure_member<7, self_t> > member8;
typedef actor<closure_member<8, self_t> > member9;
#if PHOENIX_LIMIT > 9
typedef actor<closure_member<9, self_t> > member10;
typedef actor<closure_member<10, self_t> > member11;
typedef actor<closure_member<11, self_t> > member12;
#if PHOENIX_LIMIT > 12
typedef actor<closure_member<12, self_t> > member13;
typedef actor<closure_member<13, self_t> > member14;
typedef actor<closure_member<14, self_t> > member15;
#endif
#endif
#endif
#endif
#if !defined(__MWERKS__) || (__MWERKS__ > 0x3002)
private:
#endif
closure(closure const&); // no copy
closure& operator=(closure const&); // no assign
#if !defined(__MWERKS__) || (__MWERKS__ > 0x3002)
template <int N, typename ClosureT>
friend class closure_member;
template <typename ClosureT>
friend class closure_frame;
#endif
typedef impl::closure_frame_holder<closure_frame_t> holder_t;
#ifdef PHOENIX_THREADSAFE
static boost::thread_specific_ptr<holder_t*> &
tsp_frame_instance()
{
static boost::thread_specific_ptr<holder_t*> the_instance;
return the_instance;
}
static void
tsp_frame_instance_init()
{
tsp_frame_instance();
}
#endif
static holder_t &
closure_frame_holder_ref(holder_t* holder_ = 0)
{
#ifdef PHOENIX_THREADSAFE
static boost::once_flag been_here = BOOST_ONCE_INIT;
boost::call_once(been_here, tsp_frame_instance_init);
boost::thread_specific_ptr<holder_t*> &tsp_frame = tsp_frame_instance();
if (!tsp_frame.get())
tsp_frame.reset(new holder_t *(0));
holder_t *& holder = *tsp_frame;
#else
static holder_t* holder = 0;
#endif
if (holder_ != 0)
holder = holder_;
return *holder;
}
mutable holder_t frame;
};
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
#pragma warning(pop)
#endif
}
// namespace phoenix
#endif