FM / core

/usr/include/boost/phoenix/core

Name	Size	Mode	Actions
detail/	-	0755	rm
actor.hpp	7772	0644	edit dl rm
argument.hpp	4695	0644	edit dl rm
arity.hpp	2552	0644	edit dl rm
as_actor.hpp	798	0644	edit dl rm
call.hpp	4088	0644	edit dl rm
debug.hpp	655	0644	edit dl rm
domain.hpp	2343	0644	edit dl rm
environment.hpp	14939	0644	edit dl rm
expression.hpp	3033	0644	edit dl rm
function_equal.hpp	5511	0644	edit dl rm
is_actor.hpp	1303	0644	edit dl rm
is_nullary.hpp	5297	0644	edit dl rm
is_value.hpp	1619	0644	edit dl rm
limits.hpp	6110	0644	edit dl rm
meta_grammar.hpp	4867	0644	edit dl rm
nothing.hpp	1730	0644	edit dl rm
reference.hpp	4665	0644	edit dl rm
terminal.hpp	5124	0644	edit dl rm
terminal_fwd.hpp	808	0644	edit dl rm
v2_eval.hpp	1756	0644	edit dl rm
value.hpp	4118	0644	edit dl rm

Edit: /usr/include/boost/phoenix/core/call.hpp (4088B)

/*==============================================================================
    Copyright (c) 2005-2010 Joel de Guzman
    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 BOOST_PHOENIX_CORE_CALL_HPP
#define BOOST_PHOENIX_CORE_CALL_HPP

#include <boost/phoenix/core/limits.hpp>
#include <boost/phoenix/core/environment.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/traits.hpp>
#include <boost/proto/transform/impl.hpp>

#ifndef BOOST_PHOENIX_NO_VARIADIC_CALL
#   include <boost/phoenix/core/detail/index_sequence.hpp>
#endif

namespace boost { namespace phoenix
{
    namespace detail
    {
        template <
            typename Fun
          , typename Expr
          , typename State
          , typename Data
          , long Arity = proto::arity_of<Expr>::value
        >
        struct call_impl;

template <typename Fun, typename Expr, typename State, typename Data>
        struct call_impl<Fun, Expr, State, Data, 0>
            : proto::transform_impl<Expr, State, Data>
        {
            typedef
                typename boost::phoenix::result_of::context<State, Data>::type
                context_type;

typedef
                typename boost::result_of<
                    Fun(Expr, context_type)
                >::type
                result_type;

result_type operator()(
                typename call_impl::expr_param e
              , typename call_impl::state_param s
              , typename call_impl::data_param d
            ) const
            {
                return Fun()(e, boost::phoenix::context(s, d));
            }
        };

#ifdef BOOST_PHOENIX_NO_VARIADIC_CALL
        #include <boost/phoenix/core/detail/cpp03/call.hpp>
#else
        template <typename Fun, typename Expr, typename State, typename Data
                , typename Indices>
        struct call_impl_;

template <typename Fun, typename Expr, typename State, typename Data
                , std::size_t... Indices>
        struct call_impl_<Fun, Expr, State, Data, index_sequence<Indices...> >
            : proto::transform_impl<Expr, State, Data>
        {
            typedef
                typename boost::phoenix::result_of::context<State, Data>::type
                context_type;
            template <std::size_t Index>
            struct result_of_expr
            {
                typedef
                    typename proto::result_of::child_c<Expr, Index>::type
                    type;
            };
            typedef
                typename boost::result_of<
                    Fun(
                        typename result_of_expr<Indices>::type...
                      , context_type
                    )
                >::type
                result_type;
            result_type operator()(
                typename call_impl_::expr_param e
              , typename call_impl_::state_param s
              , typename call_impl_::data_param d
            ) const
            {
                return
                    Fun()(
                        proto::child_c<Indices>(e)...
                      , boost::phoenix::context(s, d)
                    );
            }
        };

template <typename Fun, typename Expr, typename State, typename Data, long Arity>
        struct call_impl
            : call_impl_<Fun, Expr, State, Data, typename make_index_sequence<Arity>::type>
        {
        };
#endif
    }

template <typename Fun, typename Dummy = void>
    struct call
        : proto::transform<call<Fun> >
    {
        template <typename Expr, typename State, typename Data>
        struct impl
            : detail::call_impl<Fun, Expr, State, Data>
        {};
    };
}

namespace proto
    {
        template <typename Fun, typename Dummy>
        struct is_callable<phoenix::call<Fun, Dummy> > : mpl::true_ {};
    }
}

#endif

/*============================================================================== Copyright (c) 2005-2010 Joel de Guzman 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 BOOST_PHOENIX_CORE_CALL_HPP #define BOOST_PHOENIX_CORE_CALL_HPP #include #include #include #include #include #ifndef BOOST_PHOENIX_NO_VARIADIC_CALL # include #endif namespace boost { namespace phoenix { namespace detail { template < typename Fun , typename Expr , typename State , typename Data , long Arity = proto::arity_of::value > struct call_impl; template struct call_impl : proto::transform_impl { typedef typename boost::phoenix::result_of::context::type context_type; typedef typename boost::result_of< Fun(Expr, context_type) >::type result_type; result_type operator()( typename call_impl::expr_param e , typename call_impl::state_param s , typename call_impl::data_param d ) const { return Fun()(e, boost::phoenix::context(s, d)); } }; #ifdef BOOST_PHOENIX_NO_VARIADIC_CALL #include #else template struct call_impl_; template struct call_impl_ > : proto::transform_impl { typedef typename boost::phoenix::result_of::context::type context_type; template struct result_of_expr { typedef typename proto::result_of::child_c::type type; }; typedef typename boost::result_of< Fun( typename result_of_expr::type... , context_type ) >::type result_type; result_type operator()( typename call_impl_::expr_param e , typename call_impl_::state_param s , typename call_impl_::data_param d ) const { return Fun()( proto::child_c(e)... , boost::phoenix::context(s, d) ); } }; template struct call_impl : call_impl_::type> { }; #endif } template struct call : proto::transform > { template struct impl : detail::call_impl {}; }; } namespace proto { template struct is_callable > : mpl::true_ {}; } } #endif