/*=============================================================================
    Copyright (c) 2001-2003 Joel de Guzman
    Copyright (c) 2002-2003 Hartmut Kaiser
    http://spirit.sourceforge.net/

  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 BOOST_SPIRIT_CLOSURE_HPP
#define BOOST_SPIRIT_CLOSURE_HPP

///////////////////////////////////////////////////////////////////////////////
#include <boost/spirit/home/classic/namespace.hpp>
#include <boost/spirit/home/classic/core/parser.hpp>
#include <boost/spirit/home/classic/core/composite/composite.hpp>
#include <boost/spirit/home/classic/core/non_terminal/parser_context.hpp>
#include <boost/spirit/home/classic/attribute/parametric.hpp>
#include <boost/spirit/home/classic/attribute/closure_context.hpp>
#include <boost/spirit/home/classic/attribute/closure_fwd.hpp>

#include <boost/spirit/home/classic/phoenix/closures.hpp>
#include <boost/spirit/home/classic/phoenix/primitives.hpp>
#include <boost/spirit/home/classic/phoenix/casts.hpp>
#include <boost/spirit/home/classic/phoenix/operators.hpp>
#include <boost/spirit/home/classic/phoenix/tuple_helpers.hpp>

#include <boost/static_assert.hpp>

///////////////////////////////////////////////////////////////////////////////
//
//  Spirit predefined maximum closure limit. This limit defines the maximum
//  number of elements a closure can hold. This number defaults to 3. The
//  actual maximum is rounded up in multiples of 3. Thus, if this value
//  is 4, the actual limit is 6. The ultimate maximum limit in this
//  implementation is 15.
//
//  It should NOT be greater than PHOENIX_LIMIT!
//
///////////////////////////////////////////////////////////////////////////////

#if !defined(BOOST_SPIRIT_CLOSURE_LIMIT)
#define BOOST_SPIRIT_CLOSURE_LIMIT PHOENIX_LIMIT
#endif

///////////////////////////////////////////////////////////////////////////////
//
// ensure BOOST_SPIRIT_CLOSURE_LIMIT <= PHOENIX_LIMIT and SPIRIT_CLOSURE_LIMIT <= 15
//
///////////////////////////////////////////////////////////////////////////////
BOOST_STATIC_ASSERT(BOOST_SPIRIT_CLOSURE_LIMIT <= PHOENIX_LIMIT);
BOOST_STATIC_ASSERT(BOOST_SPIRIT_CLOSURE_LIMIT <= 15);

///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {

BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN

    ///////////////////////////////////////////////////////////////////////////
    //
    //  closure_context class
    //
    ///////////////////////////////////////////////////////////////////////////
    template <typename ClosureT>
    class closure_context : public parser_context_base
    {
    public:

        typedef typename ::phoenix::tuple_element<0,
            typename ClosureT::tuple_t>::type attr_t;
        typedef ClosureT base_t;
        typedef closure_context_linker<closure_context<ClosureT> >
        context_linker_t;

        closure_context(ClosureT const& clos)
        : frame(clos) {}

        ~closure_context() {}

        template <typename ParserT, typename ScannerT>
        void pre_parse(ParserT const&, ScannerT const&) {}

        template <typename ResultT, typename ParserT, typename ScannerT>
        ResultT& post_parse(ResultT& hit, ParserT const&, ScannerT const&)
        { hit.value(frame[::phoenix::tuple_index<0>()]); return hit; }

    private:

        ::phoenix::closure_frame<typename ClosureT::phoenix_closure_t> frame;
    };

    ///////////////////////////////////////////////////////////////////////////
    //
    //  init_closure_context class
    //
    //      The init_closure_context class is a special parser context type
    //      which additionally initializes a closure contained in the derived
    //      parser with values from a given tuple. Please note, that this
    //      given tuple does not contain the required values directly, it
    //      contains phoenix::actor objects. These actors have to be
    //      dereferenced to gain the values to be used for initialization
    //      (this is done by the help of the phoenix::convert_actors<>
    //      template).
    //
    ///////////////////////////////////////////////////////////////////////////

    template <typename ClosureT>
    class init_closure_context : public parser_context_base
    {
        typedef typename ClosureT::tuple_t      tuple_t;
        typedef typename ClosureT::closure_t    closure_t;

    public:

        init_closure_context(ClosureT const& clos)
        : frame(clos.subject(), ::phoenix::convert_actors<tuple_t>(clos.init)) {}

        ~init_closure_context() {}

        template <typename ParserT, typename ScannerT>
        void pre_parse(ParserT const& /*p*/, ScannerT const&) {}

        template <typename ResultT, typename ParserT, typename ScannerT>
        ResultT& post_parse(ResultT& hit, ParserT const&, ScannerT const&)
        { hit.value(frame[::phoenix::tuple_index<0>()]); return hit; }

    private:

        ::phoenix::closure_frame<closure_t> frame;
    };

    ///////////////////////////////////////////////////////////////////////////
    //
    //  init_closure_parser class
    //
    ///////////////////////////////////////////////////////////////////////////
    template <typename ParserT, typename ActorTupleT>
    struct init_closure_parser
    : public unary<ParserT, parser<init_closure_parser<ParserT, ActorTupleT> > >
    {
        typedef init_closure_parser<ParserT, ActorTupleT>           self_t;
        typedef unary<ParserT, parser<self_t> >                     base_t;
        typedef typename ParserT::phoenix_closure_t                 closure_t;
        typedef typename ParserT::tuple_t                           tuple_t;
        typedef typename ::phoenix::tuple_element<0, tuple_t>::type   attr_t;

        template <typename ScannerT>
        struct result
        {
            typedef typename match_result<ScannerT, attr_t>::type type;
        };

        init_closure_parser(ParserT const& p, ActorTupleT const& init_)
        : base_t(p), init(init_) {}

        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse_main(ScannerT const& scan) const
        {
            return this->subject().parse_main(scan);
        }

        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef init_closure_context<self_t> init_context_t;
            typedef parser_scanner_linker<ScannerT> scanner_t;
            typedef closure_context_linker<init_context_t> context_t;
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            BOOST_SPIRIT_CONTEXT_PARSE(
                scan, *this, scanner_t, context_t, result_t);
        }

        ActorTupleT init;
    };

    ///////////////////////////////////////////////////////////////////////////
    //
    //  closure class
    //
    ///////////////////////////////////////////////////////////////////////////
    template <
            typename DerivedT
        ,   typename T0
        ,   typename T1
        ,   typename T2

    #if BOOST_SPIRIT_CLOSURE_LIMIT > 3
        ,   typename T3
        ,   typename T4
        ,   typename T5

    #if BOOST_SPIRIT_CLOSURE_LIMIT > 6
        ,   typename T6
        ,   typename T7
        ,   typename T8

    #if BOOST_SPIRIT_CLOSURE_LIMIT > 9
        ,   typename T9
        ,   typename T10
        ,   typename T11

    #if BOOST_SPIRIT_CLOSURE_LIMIT > 12
        ,   typename T12
        ,   typename T13
        ,   typename T14
    #endif
    #endif
    #endif
    #endif
    >
    struct closure :
        public ::phoenix::closure<
            T0, T1, T2
    #if BOOST_SPIRIT_CLOSURE_LIMIT > 3
        ,   T3, T4, T5
    #if BOOST_SPIRIT_CLOSURE_LIMIT > 6
        ,   T6, T7, T8
    #if BOOST_SPIRIT_CLOSURE_LIMIT > 9
        ,   T9, T10, T11
    #if BOOST_SPIRIT_CLOSURE_LIMIT > 12
        ,   T12, T13, T14
    #endif
    #endif
    #endif
    #endif
        >
    {
        typedef ::phoenix::closure<
                T0, T1, T2
    #if BOOST_SPIRIT_CLOSURE_LIMIT > 3
            ,   T3, T4, T5
    #if BOOST_SPIRIT_CLOSURE_LIMIT > 6
            ,   T6, T7, T8
    #if BOOST_SPIRIT_CLOSURE_LIMIT > 9
            ,   T9, T10, T11
    #if BOOST_SPIRIT_CLOSURE_LIMIT > 12
            ,   T12, T13, T14
    #endif
    #endif
    #endif
    #endif
            > phoenix_closure_t;

        typedef closure_context<DerivedT> context_t;

        template <typename DerivedT2>
        struct aux
        {
            DerivedT2& aux_derived()
            { return *static_cast<DerivedT2*>(this); }

            DerivedT2 const& aux_derived() const
            { return *static_cast<DerivedT2 const*>(this); }

        // initialization functions
            template <typename A>
            init_closure_parser<
                DerivedT2,
                ::phoenix::tuple<
                    typename ::phoenix::as_actor<A>::type
                >
            >
            operator()(A const &a) const
            {
                typedef typename ::phoenix::as_actor<A>::type a_t;
                typedef ::phoenix::tuple<a_t> actor_tuple_t;

                return init_closure_parser<DerivedT2, actor_tuple_t>(
                        aux_derived(),
                        actor_tuple_t(
                            ::phoenix::as_actor<A>::convert(a)
                        )
                    );
            }

            template <typename A, typename B>
            init_closure_parser<
                DerivedT2,
                ::phoenix::tuple<
                    typename ::phoenix::as_actor<A>::type,
                    typename ::phoenix::as_actor<B>::type
                >
            >
            operator()(A const &a, B const &b) const
            {
                typedef typename ::phoenix::as_actor<A>::type a_t;
                typedef typename ::phoenix::as_actor<B>::type b_t;
                typedef ::phoenix::tuple<a_t, b_t> actor_tuple_t;

                return init_closure_parser<DerivedT2, actor_tuple_t>(
                        aux_derived(),
                        actor_tuple_t(
                            ::phoenix::as_actor<A>::convert(a),
                            ::phoenix::as_actor<B>::convert(b)
                        )
                    );
            }

            template <typename A, typename B, typename C>
            init_closure_parser<
                DerivedT2,
                ::phoenix::tuple<
                    typename ::phoenix::as_actor<A>::type,
                    typename ::phoenix::as_actor<B>::type,
                    typename ::phoenix::as_actor<C>::type
                >
            >
            operator()(A const &a, B const &b, C const &c) const
            {
                typedef typename ::phoenix::as_actor<A>::type a_t;
                typedef typename ::phoenix::as_actor<B>::type b_t;
                typedef typename ::phoenix::as_actor<C>::type c_t;
                typedef ::phoenix::tuple<a_t, b_t, c_t> actor_tuple_t;

                return init_closure_parser<DerivedT2, actor_tuple_t>(
                        aux_derived(),
                        actor_tuple_t(
                            ::phoenix::as_actor<A>::convert(a),
                            ::phoenix::as_actor<B>::convert(b),
                            ::phoenix::as_actor<C>::convert(c)
                        )
                    );
            }

    #if BOOST_SPIRIT_CLOSURE_LIMIT > 3

            template <
                typename A, typename B, typename C, typename D
            >
            init_closure_parser<
                DerivedT2,
                ::phoenix::tuple<
                    typename ::phoenix::as_actor<A>::type,
                    typename ::phoenix::as_actor<B>::type,
                    typename ::phoenix::as_actor<C>::type,
                    typename ::phoenix::as_actor<D>::type
                >
            >
            operator()(
                A const &a, B const &b, C const &c, D const &d
            ) const
            {
                typedef typename ::phoenix::as_actor<A>::type a_t;
                typedef typename ::phoenix::as_actor<B>::type b_t;
                typedef typename ::phoenix::as_actor<C>::type c_t;
                typedef typename ::phoenix::as_actor<D>::type d_t;
                typedef ::phoenix::tuple<
                            a_t, b_t, c_t, d_t
                        > actor_tuple_t;

                return init_closure_parser<DerivedT2, actor_tuple_t>(
                        aux_derived(),
                        actor_tuple_t(
                            ::phoenix::as_actor<A>::convert(a),
                            ::phoenix::as_actor<B>::convert(b),
                            ::phoenix::as_actor<C>::convert(c),
                            ::phoenix::as_actor<D>::convert(d)
                        )
                    );
            }

            template <
                typename A, typename B, typename C, typename D, typename E
            >
            init_closure_parser<
                DerivedT2,
                ::phoenix::tuple<
                    typename ::phoenix::as_actor<A>::type,
                    typename ::phoenix::as_actor<B>::type,
                    typename ::phoenix::as_actor<C>::type,
                    typename ::phoenix::as_actor<D>::type,
                    typename ::phoenix::as_actor<E>::type
                >
            >
            operator()(
                A const &a, B const &b, C const &c, D const &d, E const &e
            ) const
            {
                typedef typename ::phoenix::as_actor<A>::type a_t;
                typedef typename ::phoenix::as_actor<B>::type b_t;
                typedef typename ::phoenix::as_actor<C>::type c_t;
                typedef typename ::phoenix::as_actor<D>::type d_t;
                typedef typename ::phoenix::as_actor<E>::type e_t;
                typedef ::phoenix::tuple<
                            a_t, b_t, c_t, d_t, e_t
                        > actor_tuple_t;

                return init_closure_parser<DerivedT2, actor_tuple_t>(
                        aux_derived(),
                        actor_tuple_t(
                            ::phoenix::as_actor<A>::convert(a),
                            ::phoenix::as_actor<B>::convert(b),
                            ::phoenix::as_actor<C>::convert(c),
                            ::phoenix::as_actor<D>::convert(d),
                            ::phoenix::as_actor<E>::convert(e)
                        )
                    );
            }

            template <
                typename A, typename B, typename C, typename D, typename E,
                typename F
            >
            init_closure_parser<
                DerivedT2,
                ::phoenix::tuple<
                    typename ::phoenix::as_actor<A>::type,
                    typename ::phoenix::as_actor<B>::type,
                    typename ::phoenix::as_actor<C>::type,
                    typename ::phoenix::as_actor<D>::type,
                    typename ::phoenix::as_actor<E>::type,
                    typename ::phoenix::as_actor<F>::type
                >
            >
            operator()(
                A const &a, B const &b, C const &c, D const &d, E const &e,
                F const &f
            ) const
            {
                typedef typename ::phoenix::as_actor<A>::type a_t;
                typedef typename ::phoenix::as_actor<B>::type b_t;
                typedef typename ::phoenix::as_actor<C>::type c_t;
                typedef typename ::phoenix::as_actor<D>::type d_t;
                typedef typename ::phoenix::as_actor<E>::type e_t;
                typedef typename ::phoenix::as_actor<F>::type f_t;
                typedef ::phoenix::tuple<
                            a_t, b_t, c_t, d_t, e_t, f_t
                        > actor_tuple_t;

                return init_closure_parser<DerivedT2, actor_tuple_t>(
                        aux_derived(),
                        actor_tuple_t(
                            ::phoenix::as_actor<A>::convert(a),
                            ::phoenix::as_actor<B>::convert(b),
                            ::phoenix::as_actor<C>::convert(c),
                            ::phoenix::as_actor<D>::convert(d),
                            ::phoenix::as_actor<E>::convert(e),
                            ::phoenix::as_actor<F>::convert(f)
                        )
                    );
            }

    #if BOOST_SPIRIT_CLOSURE_LIMIT > 6

            template <
                typename A, typename B, typename C, typename D, typename E,
                typename F, typename G
            >
            init_closure_parser<
                DerivedT2,
                ::phoenix::tuple<
                    typename ::phoenix::as_actor<A>::type,
                    typename ::phoenix::as_actor<B>::type,
                    typename ::phoenix::as_actor<C>::type,
                    typename ::phoenix::as_actor<D>::type,
                    typename ::phoenix::as_actor<E>::type,
                    typename ::phoenix::as_actor<F>::type,
                    typename ::phoenix::as_actor<G>::type
                >
            >
            operator()(
                A const &a, B const &b, C const &c, D const &d, E const &e,
                F const &f, G const &g
            ) const
            {
                typedef typename ::phoenix::as_actor<A>::type a_t;
                typedef typename ::phoenix::as_actor<B>::type b_t;
                typedef typename ::phoenix::as_actor<C>::type c_t;
                typedef typename ::phoenix::as_actor<D>::type d_t;
                typedef typename ::phoenix::as_actor<E>::type e_t;
                typedef typename ::phoenix::as_actor<F>::type f_t;
                typedef typename ::phoenix::as_actor<G>::type g_t;
                typedef ::phoenix::tuple<
                            a_t, b_t, c_t, d_t, e_t, f_t, g_t
                        > actor_tuple_t;

                return init_closure_parser<DerivedT2, actor_tuple_t>(
                        aux_derived(),
                        actor_tuple_t(
                            ::phoenix::as_actor<A>::convert(a),
                            ::phoenix::as_actor<B>::convert(b),
                            ::phoenix::as_actor<C>::convert(c),
                            ::phoenix::as_actor<D>::convert(d),
                            ::phoenix::as_actor<E>::convert(e),
                            ::phoenix::as_actor<F>::convert(f),
                            ::phoenix::as_actor<G>::convert(g)
                        )
                    );
            }

            template <
                typename A, typename B, typename C, typename D, typename E,
                typename F, typename G, typename H
            >
            init_closure_parser<
                DerivedT2,
                ::phoenix::tuple<
                    typename ::phoenix::as_actor<A>::type,
                    typename ::phoenix::as_actor<B>::type,
                    typename ::phoenix::as_actor<C>::type,
                    typename ::phoenix::as_actor<D>::type,
                    typename ::phoenix::as_actor<E>::type,
                    typename ::phoenix::as_actor<F>::type,
                    typename ::phoenix::as_actor<G>::type,
                    typename ::phoenix::as_actor<H>::type
                >
            >
            operator()(
                A const &a, B const &b, C const &c, D const &d, E const &e,
                F const &f, G const &g, H const &h
            ) const
            {
                typedef typename ::phoenix::as_actor<A>::type a_t;
                typedef typename ::phoenix::as_actor<B>::type b_t;
                typedef typename ::phoenix::as_actor<C>::type c_t;
                typedef typename ::phoenix::as_actor<D>::type d_t;
                typedef typename ::phoenix::as_actor<E>::type e_t;
                typedef typename ::phoenix::as_actor<F>::type f_t;
                typedef typename ::phoenix::as_actor<G>::type g_t;
                typedef typename ::phoenix::as_actor<H>::type h_t;
                typedef ::phoenix::tuple<
                            a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t
                        > actor_tuple_t;

                return init_closure_parser<DerivedT2, actor_tuple_t>(
                        aux_derived(),
                        actor_tuple_t(
                            ::phoenix::as_actor<A>::convert(a),
                            ::phoenix::as_actor<B>::convert(b),
                            ::phoenix::as_actor<C>::convert(c),
                            ::phoenix::as_actor<D>::convert(d),
                            ::phoenix::as_actor<E>::convert(e),
                            ::phoenix::as_actor<F>::convert(f),
                            ::phoenix::as_actor<G>::convert(g),
                            ::phoenix::as_actor<H>::convert(h)
                        )
                    );
            }

            template <
                typename A, typename B, typename C, typename D, typename E,
                typename F, typename G, typename H, typename I
            >
            init_closure_parser<
                DerivedT2,
                ::phoenix::tuple<
                    typename ::phoenix::as_actor<A>::type,
                    typename ::phoenix::as_actor<B>::type,
                    typename ::phoenix::as_actor<C>::type,
                    typename ::phoenix::as_actor<D>::type,
                    typename ::phoenix::as_actor<E>::type,
                    typename ::phoenix::as_actor<F>::type,
                    typename ::phoenix::as_actor<G>::type,
                    typename ::phoenix::as_actor<H>::type,
                    typename ::phoenix::as_actor<I>::type
                >
            >
            operator()(
                A const &a, B const &b, C const &c, D const &d, E const &e,
                F const &f, G const &g, H const &h, I const &i
            ) const
            {
                typedef typename ::phoenix::as_actor<A>::type a_t;
                typedef typename ::phoenix::as_actor<B>::type b_t;
                typedef typename ::phoenix::as_actor<C>::type c_t;
                typedef typename ::phoenix::as_actor<D>::type d_t;
                typedef typename ::phoenix::as_actor<E>::type e_t;
                typedef typename ::phoenix::as_actor<F>::type f_t;
                typedef typename ::phoenix::as_actor<G>::type g_t;
                typedef typename ::phoenix::as_actor<H>::type h_t;
                typedef typename ::phoenix::as_actor<I>::type i_t;
                typedef ::phoenix::tuple<
                            a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t
                        > actor_tuple_t;

                return init_closure_parser<DerivedT2, actor_tuple_t>(
                        aux_derived(),
                        actor_tuple_t(
                            ::phoenix::as_actor<A>::convert(a),
                            ::phoenix::as_actor<B>::convert(b),
                            ::phoenix::as_actor<C>::convert(c),
                            ::phoenix::as_actor<D>::convert(d),
                            ::phoenix::as_actor<E>::convert(e),
                            ::phoenix::as_actor<F>::convert(f),
                            ::phoenix::as_actor<G>::convert(g),
                            ::phoenix::as_actor<H>::convert(h),
                            ::phoenix::as_actor<I>::convert(i)
                        )
                    );
            }

    #if BOOST_SPIRIT_CLOSURE_LIMIT > 9

            template <
                typename A, typename B, typename C, typename D, typename E,
                typename F, typename G, typename H, typename I, typename J
            >
            init_closure_parser<
                DerivedT2,
                ::phoenix::tuple<
                    typename ::phoenix::as_actor<A>::type,
                    typename ::phoenix::as_actor<B>::type,
                    typename ::phoenix::as_actor<C>::type,
                    typename ::phoenix::as_actor<D>::type,
                    typename ::phoenix::as_actor<E>::type,
                    typename ::phoenix::as_actor<F>::type,
                    typename ::phoenix::as_actor<G>::type,
                    typename ::phoenix::as_actor<H>::type,
                    typename ::phoenix::as_actor<I>::type,
                    typename ::phoenix::as_actor<J>::type
                >
            >
            operator()(
                A const &a, B const &b, C const &c, D const &d, E const &e,
                F const &f, G const &g, H const &h, I const &i, J const &j
            ) const
            {
                typedef typename ::phoenix::as_actor<A>::type a_t;
                typedef typename ::phoenix::as_actor<B>::type b_t;
                typedef typename ::phoenix::as_actor<C>::type c_t;
                typedef typename ::phoenix::as_actor<D>::type d_t;
                typedef typename ::phoenix::as_actor<E>::type e_t;
                typedef typename ::phoenix::as_actor<F>::type f_t;
                typedef typename ::phoenix::as_actor<G>::type g_t;
                typedef typename ::phoenix::as_actor<H>::type h_t;
                typedef typename ::phoenix::as_actor<I>::type i_t;
                typedef typename ::phoenix::as_actor<J>::type j_t;
                typedef ::phoenix::tuple<
                            a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t
                        > actor_tuple_t;

                return init_closure_parser<DerivedT2, actor_tuple_t>(
                        aux_derived(),
                        actor_tuple_t(
                            ::phoenix::as_actor<A>::convert(a),
                            ::phoenix::as_actor<B>::convert(b),
                            ::phoenix::as_actor<C>::convert(c),
                            ::phoenix::as_actor<D>::convert(d),
                            ::phoenix::as_actor<E>::convert(e),
                            ::phoenix::as_actor<F>::convert(f),
                            ::phoenix::as_actor<G>::convert(g),
                            ::phoenix::as_actor<H>::convert(h),
                            ::phoenix::as_actor<I>::convert(i),
                            ::phoenix::as_actor<J>::convert(j)
                        )
                    );
            }

            template <
                typename A, typename B, typename C, typename D, typename E,
                typename F, typename G, typename H, typename I, typename J,
                typename K
            >
            init_closure_parser<
                DerivedT2,
                ::phoenix::tuple<
                    typename ::phoenix::as_actor<A>::type,
                    typename ::phoenix::as_actor<B>::type,
                    typename ::phoenix::as_actor<C>::type,
                    typename ::phoenix::as_actor<D>::type,
                    typename ::phoenix::as_actor<E>::type,
                    typename ::phoenix::as_actor<F>::type,
                    typename ::phoenix::as_actor<G>::type,
                    typename ::phoenix::as_actor<H>::type,
                    typename ::phoenix::as_actor<I>::type,
                    typename ::phoenix::as_actor<J>::type,
                    typename ::phoenix::as_actor<K>::type
                >
            >
            operator()(
                A const &a, B const &b, C const &c, D const &d, E const &e,
                F const &f, G const &g, H const &h, I const &i, J const &j,
                K const &k
            ) const
            {
                typedef typename ::phoenix::as_actor<A>::type a_t;
                typedef typename ::phoenix::as_actor<B>::type b_t;
                typedef typename ::phoenix::as_actor<C>::type c_t;
                typedef typename ::phoenix::as_actor<D>::type d_t;
                typedef typename ::phoenix::as_actor<E>::type e_t;
                typedef typename ::phoenix::as_actor<F>::type f_t;
                typedef typename ::phoenix::as_actor<G>::type g_t;
                typedef typename ::phoenix::as_actor<H>::type h_t;
                typedef typename ::phoenix::as_actor<I>::type i_t;
                typedef typename ::phoenix::as_actor<J>::type j_t;
                typedef typename ::phoenix::as_actor<K>::type k_t;
                typedef ::phoenix::tuple<
                            a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t,
                            k_t
                        > actor_tuple_t;

                return init_closure_parser<DerivedT2, actor_tuple_t>(
                        aux_derived(),
                        actor_tuple_t(
                            ::phoenix::as_actor<A>::convert(a),
                            ::phoenix::as_actor<B>::convert(b),
                            ::phoenix::as_actor<C>::convert(c),
                            ::phoenix::as_actor<D>::convert(d),
                            ::phoenix::as_actor<E>::convert(e),
                            ::phoenix::as_actor<F>::convert(f),
                            ::phoenix::as_actor<G>::convert(g),
                            ::phoenix::as_actor<H>::convert(h),
                            ::phoenix::as_actor<I>::convert(i),
                            ::phoenix::as_actor<J>::convert(j),
                            ::phoenix::as_actor<K>::convert(k)
                        )
                    );
            }

            template <
                typename A, typename B, typename C, typename D, typename E,
                typename F, typename G, typename H, typename I, typename J,
                typename K, typename L
            >
            init_closure_parser<
                DerivedT2,
                ::phoenix::tuple<
                    typename ::phoenix::as_actor<A>::type,
                    typename ::phoenix::as_actor<B>::type,
                    typename ::phoenix::as_actor<C>::type,
                    typename ::phoenix::as_actor<D>::type,
                    typename ::phoenix::as_actor<E>::type,
                    typename ::phoenix::as_actor<F>::type,
                    typename ::phoenix::as_actor<G>::type,
                    typename ::phoenix::as_actor<H>::type,
                    typename ::phoenix::as_actor<I>::type,
                    typename ::phoenix::as_actor<J>::type,
                    typename ::phoenix::as_actor<K>::type,
                    typename ::phoenix::as_actor<L>::type
                >
            >
            operator()(
                A const &a, B const &b, C const &c, D const &d, E const &e,
                F const &f, G const &g, H const &h, I const &i, J const &j,
                K const &k, L const &l
            ) const
            {
                typedef typename ::phoenix::as_actor<A>::type a_t;
                typedef typename ::phoenix::as_actor<B>::type b_t;
                typedef typename ::phoenix::as_actor<C>::type c_t;
                typedef typename ::phoenix::as_actor<D>::type d_t;
                typedef typename ::phoenix::as_actor<E>::type e_t;
                typedef typename ::phoenix::as_actor<F>::type f_t;
                typedef typename ::phoenix::as_actor<G>::type g_t;
                typedef typename ::phoenix::as_actor<H>::type h_t;
                typedef typename ::phoenix::as_actor<I>::type i_t;
                typedef typename ::phoenix::as_actor<J>::type j_t;
                typedef typename ::phoenix::as_actor<K>::type k_t;
                typedef typename ::phoenix::as_actor<L>::type l_t;
                typedef ::phoenix::tuple<
                            a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t,
                            k_t, l_t
                        > actor_tuple_t;

                return init_closure_parser<DerivedT2, actor_tuple_t>(
                        aux_derived(),
                        actor_tuple_t(
                            ::phoenix::as_actor<A>::convert(a),
                            ::phoenix::as_actor<B>::convert(b),
                            ::phoenix::as_actor<C>::convert(c),
                            ::phoenix::as_actor<D>::convert(d),
                            ::phoenix::as_actor<E>::convert(e),
                            ::phoenix::as_actor<F>::convert(f),
                            ::phoenix::as_actor<G>::convert(g),
                            ::phoenix::as_actor<H>::convert(h),
                            ::phoenix::as_actor<I>::convert(i),
                            ::phoenix::as_actor<J>::convert(j),
                            ::phoenix::as_actor<K>::convert(k),
                            ::phoenix::as_actor<L>::convert(l)
                        )
                    );
            }

    #if BOOST_SPIRIT_CLOSURE_LIMIT > 12

            template <
                typename A, typename B, typename C, typename D, typename E,
                typename F, typename G, typename H, typename I, typename J,
                typename K, typename L, typename M
            >
            init_closure_parser<
                DerivedT2,
                ::phoenix::tuple<
                    typename ::phoenix::as_actor<A>::type,
                    typename ::phoenix::as_actor<B>::type,
                    typename ::phoenix::as_actor<C>::type,
                    typename ::phoenix::as_actor<D>::type,
                    typename ::phoenix::as_actor<E>::type,
                    typename ::phoenix::as_actor<F>::type,
                    typename ::phoenix::as_actor<G>::type,
                    typename ::phoenix::as_actor<H>::type,
                    typename ::phoenix::as_actor<I>::type,
                    typename ::phoenix::as_actor<J>::type,
                    typename ::phoenix::as_actor<K>::type,
                    typename ::phoenix::as_actor<L>::type,
                    typename ::phoenix::as_actor<M>::type
                >
            >
            operator()(
                A const &a, B const &b, C const &c, D const &d, E const &e,
                F const &f, G const &g, H const &h, I const &i, J const &j,
                K const &k, L const &l, M const &m
            ) const
            {
                typedef typename ::phoenix::as_actor<A>::type a_t;
                typedef typename ::phoenix::as_actor<B>::type b_t;
                typedef typename ::phoenix::as_actor<C>::type c_t;
                typedef typename ::phoenix::as_actor<D>::type d_t;
                typedef typename ::phoenix::as_actor<E>::type e_t;
                typedef typename ::phoenix::as_actor<F>::type f_t;
                typedef typename ::phoenix::as_actor<G>::type g_t;
                typedef typename ::phoenix::as_actor<H>::type h_t;
                typedef typename ::phoenix::as_actor<I>::type i_t;
                typedef typename ::phoenix::as_actor<J>::type j_t;
                typedef typename ::phoenix::as_actor<K>::type k_t;
                typedef typename ::phoenix::as_actor<L>::type l_t;
                typedef typename ::phoenix::as_actor<M>::type m_t;
                typedef ::phoenix::tuple<
                            a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t,
                            k_t, l_t, m_t
                        > actor_tuple_t;

                return init_closure_parser<DerivedT2, actor_tuple_t>(
                        aux_derived(),
                        actor_tuple_t(
                            ::phoenix::as_actor<A>::convert(a),
                            ::phoenix::as_actor<B>::convert(b),
                            ::phoenix::as_actor<C>::convert(c),
                            ::phoenix::as_actor<D>::convert(d),
                            ::phoenix::as_actor<E>::convert(e),
                            ::phoenix::as_actor<F>::convert(f),
                            ::phoenix::as_actor<G>::convert(g),
                            ::phoenix::as_actor<H>::convert(h),
                            ::phoenix::as_actor<I>::convert(i),
                            ::phoenix::as_actor<J>::convert(j),
                            ::phoenix::as_actor<K>::convert(k),
                            ::phoenix::as_actor<L>::convert(l),
                            ::phoenix::as_actor<M>::convert(m)
                        )
                    );
            }

            template <
                typename A, typename B, typename C, typename D, typename E,
                typename F, typename G, typename H, typename I, typename J,
                typename K, typename L, typename M, typename N
            >
            init_closure_parser<
                DerivedT2,
                ::phoenix::tuple<
                    typename ::phoenix::as_actor<A>::type,
                    typename ::phoenix::as_actor<B>::type,
                    typename ::phoenix::as_actor<C>::type,
                    typename ::phoenix::as_actor<D>::type,
                    typename ::phoenix::as_actor<E>::type,
                    typename ::phoenix::as_actor<F>::type,
                    typename ::phoenix::as_actor<G>::type,
                    typename ::phoenix::as_actor<H>::type,
                    typename ::phoenix::as_actor<I>::type,
                    typename ::phoenix::as_actor<J>::type,
                    typename ::phoenix::as_actor<K>::type,
                    typename ::phoenix::as_actor<L>::type,
                    typename ::phoenix::as_actor<M>::type,
                    typename ::phoenix::as_actor<N>::type
                >
            >
            operator()(
                A const &a, B const &b, C const &c, D const &d, E const &e,
                F const &f, G const &g, H const &h, I const &i, J const &j,
                K const &k, L const &l, M const &m, N const &n
            ) const
            {
                typedef typename ::phoenix::as_actor<A>::type a_t;
                typedef typename ::phoenix::as_actor<B>::type b_t;
                typedef typename ::phoenix::as_actor<C>::type c_t;
                typedef typename ::phoenix::as_actor<D>::type d_t;
                typedef typename ::phoenix::as_actor<E>::type e_t;
                typedef typename ::phoenix::as_actor<F>::type f_t;
                typedef typename ::phoenix::as_actor<G>::type g_t;
                typedef typename ::phoenix::as_actor<H>::type h_t;
                typedef typename ::phoenix::as_actor<I>::type i_t;
                typedef typename ::phoenix::as_actor<J>::type j_t;
                typedef typename ::phoenix::as_actor<K>::type k_t;
                typedef typename ::phoenix::as_actor<L>::type l_t;
                typedef typename ::phoenix::as_actor<M>::type m_t;
                typedef typename ::phoenix::as_actor<N>::type n_t;
                typedef ::phoenix::tuple<
                            a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t,
                            k_t, l_t, m_t, n_t
                        > actor_tuple_t;

                return init_closure_parser<DerivedT2, actor_tuple_t>(
                        aux_derived(),
                        actor_tuple_t(
                            ::phoenix::as_actor<A>::convert(a),
                            ::phoenix::as_actor<B>::convert(b),
                            ::phoenix::as_actor<C>::convert(c),
                            ::phoenix::as_actor<D>::convert(d),
                            ::phoenix::as_actor<E>::convert(e),
                            ::phoenix::as_actor<F>::convert(f),
                            ::phoenix::as_actor<G>::convert(g),
                            ::phoenix::as_actor<H>::convert(h),
                            ::phoenix::as_actor<I>::convert(i),
                            ::phoenix::as_actor<J>::convert(j),
                            ::phoenix::as_actor<K>::convert(k),
                            ::phoenix::as_actor<L>::convert(l),
                            ::phoenix::as_actor<M>::convert(m),
                            ::phoenix::as_actor<N>::convert(n)
                        )
                    );
            }

            template <
                typename A, typename B, typename C, typename D, typename E,
                typename F, typename G, typename H, typename I, typename J,
                typename K, typename L, typename M, typename N, typename O
            >
            init_closure_parser<
                DerivedT2,
                ::phoenix::tuple<
                    typename ::phoenix::as_actor<A>::type,
                    typename ::phoenix::as_actor<B>::type,
                    typename ::phoenix::as_actor<C>::type,
                    typename ::phoenix::as_actor<D>::type,
                    typename ::phoenix::as_actor<E>::type,
                    typename ::phoenix::as_actor<F>::type,
                    typename ::phoenix::as_actor<G>::type,
                    typename ::phoenix::as_actor<H>::type,
                    typename ::phoenix::as_actor<I>::type,
                    typename ::phoenix::as_actor<J>::type,
                    typename ::phoenix::as_actor<K>::type,
                    typename ::phoenix::as_actor<L>::type,
                    typename ::phoenix::as_actor<M>::type,
                    typename ::phoenix::as_actor<N>::type,
                    typename ::phoenix::as_actor<O>::type
                >
            >
            operator()(
                A const &a, B const &b, C const &c, D const &d, E const &e,
                F const &f, G const &g, H const &h, I const &i, J const &j,
                K const &k, L const &l, M const &m, N const &n, O const &o
            ) const
            {
                typedef typename ::phoenix::as_actor<A>::type a_t;
                typedef typename ::phoenix::as_actor<B>::type b_t;
                typedef typename ::phoenix::as_actor<C>::type c_t;
                typedef typename ::phoenix::as_actor<D>::type d_t;
                typedef typename ::phoenix::as_actor<E>::type e_t;
                typedef typename ::phoenix::as_actor<F>::type f_t;
                typedef typename ::phoenix::as_actor<G>::type g_t;
                typedef typename ::phoenix::as_actor<H>::type h_t;
                typedef typename ::phoenix::as_actor<I>::type i_t;
                typedef typename ::phoenix::as_actor<J>::type j_t;
                typedef typename ::phoenix::as_actor<K>::type k_t;
                typedef typename ::phoenix::as_actor<L>::type l_t;
                typedef typename ::phoenix::as_actor<M>::type m_t;
                typedef typename ::phoenix::as_actor<N>::type n_t;
                typedef typename ::phoenix::as_actor<O>::type o_t;
                typedef ::phoenix::tuple<
                            a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t,
                            k_t, l_t, m_t, n_t, o_t
                        > actor_tuple_t;

                return init_closure_parser<DerivedT2, actor_tuple_t>(
                        aux_derived(),
                        actor_tuple_t(
                            ::phoenix::as_actor<A>::convert(a),
                            ::phoenix::as_actor<B>::convert(b),
                            ::phoenix::as_actor<C>::convert(c),
                            ::phoenix::as_actor<D>::convert(d),
                            ::phoenix::as_actor<E>::convert(e),
                            ::phoenix::as_actor<F>::convert(f),
                            ::phoenix::as_actor<G>::convert(g),
                            ::phoenix::as_actor<H>::convert(h),
                            ::phoenix::as_actor<I>::convert(i),
                            ::phoenix::as_actor<J>::convert(j),
                            ::phoenix::as_actor<K>::convert(k),
                            ::phoenix::as_actor<L>::convert(l),
                            ::phoenix::as_actor<M>::convert(m),
                            ::phoenix::as_actor<N>::convert(n),
                            ::phoenix::as_actor<O>::convert(o)
                        )
                    );
            }

    #endif
    #endif
    #endif
    #endif
        };

        ~closure() {}
    };

    ///////////////////////////////////////////////////////////////////////////
    //
    //  overloads for chseq_p and str_p taking in phoenix actors
    //
    ///////////////////////////////////////////////////////////////////////////
    template <typename ActorT>
    struct container_begin
    {
        typedef container_begin<ActorT> self_t;

        template <typename TupleT>
        struct result
        {
            typedef typename ::phoenix::actor_result<ActorT, TupleT>
                ::plain_type::iterator type;
        };

        container_begin(ActorT actor_)
        : actor(actor_) {}

        template <typename TupleT>
        typename ::phoenix::actor_result<self_t, TupleT>::type
        eval(TupleT const& /*args*/) const
        { return actor().begin(); }

        ActorT actor;
    };

    template <typename ActorT>
    struct container_end
    {
        typedef container_begin<ActorT> self_t;

        template <typename TupleT>
        struct result
        {
            typedef typename ::phoenix::actor_result<ActorT, TupleT>
                ::plain_type::iterator type;
        };

        container_end(ActorT actor_)
        : actor(actor_) {}

        template <typename TupleT>
        typename ::phoenix::actor_result<self_t, TupleT>::type
        eval(TupleT const& /*args*/) const
        { return actor().end(); }

        ActorT actor;
    };

    template <typename BaseT>
    inline f_chseq<
        ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > >,
        ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > >
    >
    f_chseq_p(::phoenix::actor<BaseT> const& a)
    {
        typedef ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > >
            container_begin_t;
        typedef ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > >
            container_end_t;
        typedef f_chseq<container_begin_t, container_end_t> result_t;

        return result_t(container_begin_t(a), container_end_t(a));
    }

    template <typename BaseT>
    inline f_strlit<
        ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > >,
        ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > >
    >
    f_str_p(::phoenix::actor<BaseT> const& a)
    {
        typedef ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > >
            container_begin_t;
        typedef ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > >
            container_end_t;
        typedef f_strlit<container_begin_t, container_end_t> result_t;

        return result_t(container_begin_t(a), container_end_t(a));
    }

BOOST_SPIRIT_CLASSIC_NAMESPACE_END

}} // namespace BOOST_SPIRIT_CLASSIC_NS

#endif
