comparison DEPENDENCIES/generic/include/boost/spirit/home/classic/phoenix/closures.hpp @ 16:2665513ce2d3

Add boost headers

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