[Boost-commit] svn:boost r66376 - sandbox/function/boost/function

Subject: [Boost-commit] svn:boost r66376 - sandbox/function/boost/function
From: dsaritz_at_[hidden]
Date: 2010-11-03 08:25:11

Author: psiha
Date: 2010-11-03 08:25:05 EDT (Wed, 03 Nov 2010)
New Revision: 66376
URL: http://svn.boost.org/trac/boost/changeset/66376

Log:
Fixed a GCC 4.0.1 function-without-ampersand assignment bug.
Minor refactoring.
Text files modified: 
   sandbox/function/boost/function/function_base.hpp     |     1                                         
   sandbox/function/boost/function/function_template.hpp |    54 +++++++++++++++++++++++---------------- 
   2 files changed, 33 insertions(+), 22 deletions(-)

Modified: sandbox/function/boost/function/function_base.hpp
==============================================================================
--- sandbox/function/boost/function/function_base.hpp	(original)
+++ sandbox/function/boost/function/function_base.hpp	2010-11-03 08:25:05 EDT (Wed, 03 Nov 2010)
@@ -40,6 +40,7 @@
 #include <boost/get_pointer.hpp>
 #include <boost/noncopyable.hpp>
 #include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/add_pointer.hpp>
 #include <boost/type_traits/add_reference.hpp>
 #include <boost/type_traits/has_nothrow_copy.hpp>
 #include <boost/type_traits/has_trivial_copy.hpp>

Modified: sandbox/function/boost/function/function_template.hpp
==============================================================================
--- sandbox/function/boost/function/function_template.hpp	(original)
+++ sandbox/function/boost/function/function_template.hpp	2010-11-03 08:25:05 EDT (Wed, 03 Nov 2010)
@@ -314,6 +314,12 @@
         this->do_assign<false, FunctionObj>( f );
     }
 
+    template <typename FunctionObj, typename Allocator>
+    void assign( FunctionObj const & f, Allocator const a )
+    {
+        this->do_assign<false, FunctionObj>( f, a );
+    }
+
     template <signature_type * f>
     void assign()
     {
@@ -380,16 +386,10 @@
 #endif
     operator=( Functor const & f )
     {
-      this->assign(f);
+      this->assign( f );
       return *this;
     }
 
-    template <typename FunctionObj, typename Allocator>
-    void assign( FunctionObj const & f, Allocator const a )
-    {
-        this->do_assign<false, FunctionObj>( f, a );
-    }
-
 
 #ifndef BOOST_NO_SFINAE
     BOOST_FUNCTION_FUNCTION & operator=(clear_type*)
@@ -605,29 +605,39 @@
     void do_assign( FunctionObj const & f, Allocator const a )
     {
         typedef typename detail::function::get_function_tag<FunctionObj>::type tag;
-        // Implementation note:
-        //   If the FunctionObj template parameter is (re)specified explicitly
-        // in the call to dispatch_assign MSVC 10 generates totally bogus code
-        // (causing access-violation crashes) when function pointers are
-        // assigned using the syntax without the ampersand.
-        //                                    (02.11.2010.) (Domagoj Saric)
-        dispatch_assign<direct>( f, a, tag() );
+        dispatch_assign<direct, FunctionObj>( f, a, tag() );
     }
 
     template <bool direct, typename FunctionObj>
-    void do_assign( FunctionObj const & f ) { do_assign<direct>( f, detail::function::fallocator<FunctionObj>() ); }
+    void do_assign( FunctionObj const & f ) { do_assign<direct, FunctionObj>( f, detail::function::fallocator<FunctionObj>() ); }
 
     template <bool direct, typename FunctionObj, typename Allocator>
-    void dispatch_assign( FunctionObj const & f, Allocator const a, detail::function::function_obj_tag     ) { do_assign<direct, FunctionObj>( f      ,        f   , a ); }
-    template <bool direct, typename FunctionObj, typename Allocator> // This one has to be exactly as it is for GCC and Clang...:
-    void dispatch_assign( FunctionObj const   f, Allocator const a, detail::function::function_ptr_tag     ) { do_assign<direct             >( f      ,        f   , a ); }
-    // DPG TBD: Add explicit support for member function
-    // objects, so we invoke through mem_fn() but we retain the
-    // right target_type() values.
+    void dispatch_assign( FunctionObj const & f, Allocator const a, detail::function::function_obj_tag     ) { do_assign<direct,          FunctionObj      >( f      ,        f   , a ); }
+    // Explicit support for member function objects, so we invoke through
+    // mem_fn() but retain the right target_type() values.
     template <bool direct, typename FunctionObj, typename Allocator>
-    void dispatch_assign( FunctionObj const & f, Allocator const a, detail::function::member_ptr_tag       ) { do_assign<direct, FunctionObj>( f      , mem_fn( f ), a ); }
+    void dispatch_assign( FunctionObj const & f, Allocator const a, detail::function::member_ptr_tag       ) { do_assign<direct,          FunctionObj      >( f      , mem_fn( f ), a ); }
     template <bool direct, typename FunctionObj, typename Allocator>
     void dispatch_assign( FunctionObj const & f, Allocator const a, detail::function::function_obj_ref_tag ) { do_assign<direct, typename FunctionObj::type>( f.get(),         f  , a ); }
+    template <bool direct, typename FunctionObj, typename Allocator>
+    void dispatch_assign( FunctionObj const & f, Allocator const a, detail::function::function_ptr_tag     )
+    {
+        // Implementation note:
+        //   Plain function pointers need special care because when assigned
+        // using the syntax without the ampersand they wreck havoc with certain
+        // compilers, causing either compilation failures or broken runtime
+        // behaviour, e.g. not invoking the assigned target with GCC 4.0.1 or
+        // causing access-violation crashes with MSVC (tested 8 and 10).
+        //                                    (03.11.2010.) (Domagoj Saric)
+        typedef typename add_pointer
+        <
+            typename remove_const
+            <
+                typename remove_pointer<FunctionObj>::type
+            >::type
+        >::type non_const_function_pointer_t;
+        do_assign<direct, non_const_function_pointer_t, non_const_function_pointer_t>( f, f, a );
+    }
 
     template <bool direct, typename ActualFunctor, typename StoredFunctor, typename ActualFunctorAllocator>
     void do_assign( ActualFunctor const &, StoredFunctor const & stored_functor, ActualFunctorAllocator const a )