FM / detail

/usr/include/boost/phoenix/scope/detail/

/usr/include/boost/phoenix/scope/detail

Name	Size	Mode	Actions
cpp03/	-	0755	rm
local_gen.hpp	1915	0644	edit dl rm
local_variable.hpp	8543	0644	edit dl rm

Edit: /usr/include/boost/phoenix/scope/detail/local_variable.hpp (8543B)

/*=============================================================================
    Copyright (c) 2001-2007 Joel de Guzman
    Copyright (c) 2004 Daniel Wallin
    Copyright (c) 2011 Thomas Heller

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

#include <boost/mpl/int.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/fusion/include/at.hpp>
#include <boost/fusion/include/value_at.hpp>
#include <boost/preprocessor/enum.hpp>
#include <boost/preprocessor/repeat.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/type_traits/is_reference.hpp>

#define BOOST_PHOENIX_MAP_LOCAL_TEMPLATE_PARAM(z, n, data) \
    typename T##n = unused<n>

#define BOOST_PHOENIX_MAP_LOCAL_DISPATCH(z, n, data)  \
    typedef char(&result##n)[n+2];              \
    static result##n get(T##n*);

namespace boost { namespace phoenix
{
    template <typename Env, typename OuterEnv, typename Locals, typename Map>
    struct scoped_environment;

namespace detail
    {
        template <typename Key>
        struct local
        {
            typedef Key key_type;
        };

namespace result_of
        {
            template <typename Locals, typename Context>
            struct initialize_locals;
            
            template <typename Context>
            struct initialize_locals<vector0<>, Context>
            {
                typedef vector0<> type;
            };

#define M1(Z, N, D)                                                     \
            typename boost::phoenix::result_of::eval<                           \
                BOOST_PP_CAT(A, N)                                              \
              , Context                                                         \
            >::type                                                             \
        /**/

#define M0(Z, N, D)                                                     \
            template <BOOST_PHOENIX_typename_A(N), typename Context>            \
            struct initialize_locals<                                           \
                BOOST_PP_CAT(vector, N)<                                        \
                    BOOST_PHOENIX_A(N)                                          \
                >                                                               \
              , Context                                                         \
            >                                                                   \
            {                                                                   \
                typedef                                                         \
                    BOOST_PP_CAT(vector, N)<                                    \
                        BOOST_PP_ENUM(N, M1, _)                                 \
                    >                                                           \
                    type;                                                       \
            };                                                                  \
        /**/
            BOOST_PP_REPEAT_FROM_TO(1, BOOST_PHOENIX_LIMIT, M0, _)
        #undef M0
        }

template <typename Context>
        vector0<>
        initialize_locals(vector0<> const &, Context const &)
        {
            vector0<> vars;
            return vars;
        }
    #define M2(Z, N, D)                                                         \
        eval(locals. BOOST_PP_CAT(a, N), ctx)                                   \
    /**/
        
    #define M0(Z, N, D)                                                         \
        template <BOOST_PHOENIX_typename_A(N), typename Context>                \
        BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM(N, M1, _)>                        \
        initialize_locals(                                                      \
            BOOST_PP_CAT(vector, N)<BOOST_PHOENIX_A(N)> const & locals          \
          , Context const & ctx                                                 \
        )                                                                       \
        {                                                                       \
            BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM(N, M1, _)> vars               \
                = {BOOST_PP_ENUM(N, M2, _)};                                    \
            return vars;                                                        \
        }                                                                       \
    /**/
        BOOST_PP_REPEAT_FROM_TO(1, BOOST_PHOENIX_LIMIT, M0, _)
        #undef M0
        #undef M1
        #undef M2

template <int N>
        struct unused;

template <
            BOOST_PP_ENUM(
                BOOST_PHOENIX_LOCAL_LIMIT
              , BOOST_PHOENIX_MAP_LOCAL_TEMPLATE_PARAM
              , _
            )
        >
        struct map_local_index_to_tuple
        {
            typedef char(&not_found)[1];
            static not_found get(...);

BOOST_PP_REPEAT(BOOST_PHOENIX_LOCAL_LIMIT, BOOST_PHOENIX_MAP_LOCAL_DISPATCH, _)
        };
        
        template<typename T>
        T* generate_pointer();

template <typename Map, typename Tag>
        struct get_index
        {
            BOOST_STATIC_CONSTANT(int,
                value = (
                    static_cast<int>((sizeof(Map::get(generate_pointer<Tag>()))) / sizeof(char)) - 2
                ));

// if value == -1, Tag is not found
            typedef mpl::int_<value> type;
        };

template <typename Local, typename Env>
        struct apply_local;

template <typename Local, typename Env>
        struct outer_local
        {
            typedef typename
                apply_local<Local, typename Env::outer_env_type>::type
            type;
        };

template <typename Locals, int Index>
        struct get_local_or_void
        {
            typedef typename
                mpl::eval_if_c<
                    Index < Locals::size_value
                  , fusion::result_of::at_c<Locals, Index>
                  , mpl::identity<fusion::void_>
                >::type
                type;
        };

template <typename Local, typename Env, int Index>
        struct get_local_from_index
        {
            typedef typename
                mpl::eval_if_c<
                    Index == -1
                  , outer_local<Local, Env>
                  , get_local_or_void<typename Env::locals_type, Index>
                >::type
                type;
        };

template <typename Local, typename Env>
        struct get_local
        {
            static const int index_value = get_index<typename Env::map_type, Local>::value;

typedef typename
                get_local_from_index<Local, Env, index_value>::type
            type;
        };

template <typename Local, typename Env>
        struct apply_local
        {
            // $$$ TODO: static assert that Env is a scoped_environment $$$
            typedef typename get_local<Local, Env>::type type;
        };

template <typename Key>
        struct eval_local
        {
            template <typename RT, int Index, typename Env>
            static RT
            get(Env const& env, mpl::false_)
            {
                return RT(fusion::at_c<Index>(env.locals));
            }

template <typename RT, int Index, typename Env>
            static RT
            get(Env const& env, mpl::true_)
            {
                static const int index_value = get_index<typename Env::outer_env_type::map_type, detail::local<Key> >::value;

return get<RT, index_value>(
                    env.outer_env
                  , mpl::bool_<index_value == -1>());
            }

template <typename RT, int Index, typename Env>
            static RT
            get(Env const& env)
            {
                return get<RT, Index>(
                    env
                  , mpl::bool_<Index == -1>());
            }
        };
    }
}}

#undef BOOST_PHOENIX_MAP_LOCAL_TEMPLATE_PARAM
#undef BOOST_PHOENIX_MAP_LOCAL_DISPATCH

#endif

/*============================================================================= Copyright (c) 2001-2007 Joel de Guzman Copyright (c) 2004 Daniel Wallin Copyright (c) 2011 Thomas Heller 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 PHOENIX_SCOPE_DETAIL_LOCAL_VARIABLE_HPP #define PHOENIX_SCOPE_DETAIL_LOCAL_VARIABLE_HPP #include #include #include #include #include #include #include #include #include #include #define BOOST_PHOENIX_MAP_LOCAL_TEMPLATE_PARAM(z, n, data) \ typename T##n = unused #define BOOST_PHOENIX_MAP_LOCAL_DISPATCH(z, n, data) \ typedef char(&result##n)[n+2]; \ static result##n get(T##n*); namespace boost { namespace phoenix { template struct scoped_environment; namespace detail { template struct local { typedef Key key_type; }; namespace result_of { template struct initialize_locals; template struct initialize_locals, Context> { typedef vector0<> type; }; #define M1(Z, N, D) \ typename boost::phoenix::result_of::eval< \ BOOST_PP_CAT(A, N) \ , Context \ >::type \ /**/ #define M0(Z, N, D) \ template \ struct initialize_locals< \ BOOST_PP_CAT(vector, N)< \ BOOST_PHOENIX_A(N) \ > \ , Context \ > \ { \ typedef \ BOOST_PP_CAT(vector, N)< \ BOOST_PP_ENUM(N, M1, _) \ > \ type; \ }; \ /**/ BOOST_PP_REPEAT_FROM_TO(1, BOOST_PHOENIX_LIMIT, M0, _) #undef M0 } template vector0<> initialize_locals(vector0<> const &, Context const &) { vector0<> vars; return vars; } #define M2(Z, N, D) \ eval(locals. BOOST_PP_CAT(a, N), ctx) \ /**/ #define M0(Z, N, D) \ template \ BOOST_PP_CAT(vector, N) \ initialize_locals( \ BOOST_PP_CAT(vector, N) const & locals \ , Context const & ctx \ ) \ { \ BOOST_PP_CAT(vector, N) vars \ = {BOOST_PP_ENUM(N, M2, _)}; \ return vars; \ } \ /**/ BOOST_PP_REPEAT_FROM_TO(1, BOOST_PHOENIX_LIMIT, M0, _) #undef M0 #undef M1 #undef M2 template struct unused; template < BOOST_PP_ENUM( BOOST_PHOENIX_LOCAL_LIMIT , BOOST_PHOENIX_MAP_LOCAL_TEMPLATE_PARAM , _ ) > struct map_local_index_to_tuple { typedef char(¬_found)[1]; static not_found get(...); BOOST_PP_REPEAT(BOOST_PHOENIX_LOCAL_LIMIT, BOOST_PHOENIX_MAP_LOCAL_DISPATCH, _) }; template T* generate_pointer(); template struct get_index { BOOST_STATIC_CONSTANT(int, value = ( static_cast((sizeof(Map::get(generate_pointer()))) / sizeof(char)) - 2 )); // if value == -1, Tag is not found typedef mpl::int_ type; }; template struct apply_local; template struct outer_local { typedef typename apply_local::type type; }; template struct get_local_or_void { typedef typename mpl::eval_if_c< Index < Locals::size_value , fusion::result_of::at_c , mpl::identity >::type type; }; template struct get_local_from_index { typedef typename mpl::eval_if_c< Index == -1 , outer_local , get_local_or_void >::type type; }; template struct get_local { static const int index_value = get_index::value; typedef typename get_local_from_index::type type; }; template struct apply_local { // $$$ TODO: static assert that Env is a scoped_environment $$$ typedef typename get_local::type type; }; template struct eval_local { template static RT get(Env const& env, mpl::false_) { return RT(fusion::at_c(env.locals)); } template static RT get(Env const& env, mpl::true_) { static const int index_value = get_index >::value; return get( env.outer_env , mpl::bool_()); } template static RT get(Env const& env) { return get( env , mpl::bool_()); } }; } }} #undef BOOST_PHOENIX_MAP_LOCAL_TEMPLATE_PARAM #undef BOOST_PHOENIX_MAP_LOCAL_DISPATCH #endif