FM / cpp03

/usr/include/boost/phoenix/bind/detail/cpp03/

/usr/include/boost/phoenix/bind/detail/cpp03

Name	Size	Mode	Actions
preprocessed/	-	0755	rm
bind_function.hpp	3494	0644	edit dl rm
bind_function_object.hpp	2368	0644	edit dl rm
bind_member_function.hpp	7612	0644	edit dl rm
function_ptr.hpp	4071	0644	edit dl rm
member_function_ptr.hpp	4460	0644	edit dl rm

Edit: /usr/include/boost/phoenix/bind/detail/cpp03/function_ptr.hpp (4071B)

/*=============================================================================
    Copyright (c) 2001-2007 Joel de Guzman

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

#if !BOOST_PHOENIX_IS_ITERATING

#include <boost/phoenix/core/limits.hpp>
#include <boost/phoenix/support/iterate.hpp>

namespace boost { namespace phoenix { namespace detail
{
    template <int N, typename Dummy = void>
    struct function_ptr_impl
    {
        template <typename RT, typename FP>
        struct impl;
    };

template <int N, typename RT, typename FP>
    struct function_ptr : function_ptr_impl<N>::template impl<RT, FP>
    {
        typedef typename function_ptr_impl<N>::template impl<RT, FP> base;

function_ptr(FP fp_)
            : base(fp_) {}
        
        using base::fp;

bool operator==(function_ptr const & rhs) const
        {
            return fp == rhs.fp;
        }

template <int M, typename RhsRT, typename RhsFP>
        bool operator==(function_ptr<M, RhsRT, RhsFP> const & /*rhs*/) const
        {
            return false;
        }

};

template <typename Dummy>
    struct function_ptr_impl<0, Dummy>
    {
        template <typename RT, typename FP>
        struct impl
        {
            typedef RT result_type;

impl(FP fp_)
                : fp(fp_) {}

RT operator()() const
            {
                return fp();
            }

FP fp;
        };
    };

template <typename Dummy>
    struct function_ptr_impl<1, Dummy>
    {
        template <typename RT, typename FP>
        struct impl
        {
            typedef RT result_type;

impl(FP fp_)
                : fp(fp_) {}

template <typename A>
            RT operator()(A &a) const
            {
                return fp(a);
            }

FP fp;
        };
    };

#if !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)
    #include <boost/phoenix/bind/detail/cpp03/preprocessed/function_ptr.hpp>
#else

#if defined(__WAVE__) && defined (BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
    #pragma wave option(preserve: 2, line: 0, output: "preprocessed/function_ptr_" BOOST_PHOENIX_LIMIT_STR ".hpp")
#endif

/*=============================================================================
    Copyright (c) 2001-2007 Joel de Guzman

#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
    #pragma wave option(preserve: 1)
#endif

#define BOOST_PHOENIX_ITERATION_PARAMS                                          \
    (3, (2, BOOST_PHOENIX_COMPOSITE_LIMIT,                                      \
    <boost/phoenix/bind/detail/cpp03/function_ptr.hpp>))
#include BOOST_PHOENIX_ITERATE()

#if defined(__WAVE__) && defined (BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
    #pragma wave option(output: null)
#endif

#endif

}}} // namespace boost::phoenix::detail

///////////////////////////////////////////////////////////////////////////////
//
//  Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#else // defined(BOOST_PP_IS_ITERATING)

template <typename Dummy>
    struct function_ptr_impl<BOOST_PHOENIX_ITERATION, Dummy>
    {
        template <typename RT, typename FP>
        struct impl
        {
            typedef RT result_type;

impl(FP fp_)
                : fp(fp_) {}

template <BOOST_PHOENIX_typename_A>
            RT operator()(BOOST_PHOENIX_A_ref_a) const
            {
                return fp(BOOST_PHOENIX_a);
            }

FP fp;
        };
    };

#endif // defined(BOOST_PP_IS_ITERATING)

/*============================================================================= Copyright (c) 2001-2007 Joel de Guzman 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) ==============================================================================*/ #if !BOOST_PHOENIX_IS_ITERATING #include #include namespace boost { namespace phoenix { namespace detail { template struct function_ptr_impl { template struct impl; }; template struct function_ptr : function_ptr_impl::template impl { typedef typename function_ptr_impl::template impl base; function_ptr(FP fp_) : base(fp_) {} using base::fp; bool operator==(function_ptr const & rhs) const { return fp == rhs.fp; } template bool operator==(function_ptr const & /*rhs*/) const { return false; } }; template struct function_ptr_impl<0, Dummy> { template struct impl { typedef RT result_type; impl(FP fp_) : fp(fp_) {} RT operator()() const { return fp(); } FP fp; }; }; template struct function_ptr_impl<1, Dummy> { template struct impl { typedef RT result_type; impl(FP fp_) : fp(fp_) {} template RT operator()(A &a) const { return fp(a); } FP fp; }; }; #if !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES) #include #else #if defined(__WAVE__) && defined (BOOST_PHOENIX_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/function_ptr_" BOOST_PHOENIX_LIMIT_STR ".hpp") #endif /*============================================================================= Copyright (c) 2001-2007 Joel de Guzman 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) ==============================================================================*/ #if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PHOENIX_ITERATION_PARAMS \ (3, (2, BOOST_PHOENIX_COMPOSITE_LIMIT, \ )) #include BOOST_PHOENIX_ITERATE() #if defined(__WAVE__) && defined (BOOST_PHOENIX_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #endif }}} // namespace boost::phoenix::detail /////////////////////////////////////////////////////////////////////////////// // // Preprocessor vertical repetition code // /////////////////////////////////////////////////////////////////////////////// #else // defined(BOOST_PP_IS_ITERATING) template struct function_ptr_impl { template struct impl { typedef RT result_type; impl(FP fp_) : fp(fp_) {} template RT operator()(BOOST_PHOENIX_A_ref_a) const { return fp(BOOST_PHOENIX_a); } FP fp; }; }; #endif // defined(BOOST_PP_IS_ITERATING)