Release 1.37.0

[SVN r49549]

doc/Jamfile.v2

@@ -6,10 +6,5 @@
 project boost/doc ;
 import boostbook : boostbook ;
 
-boostbook function-doc 
-	: 
-	function.xml 
-	:
-        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
-	;
+boostbook function-doc : function.xml ;
 

doc/tutorial.xml

@@ -35,12 +35,12 @@ form to use for your compiler.
         <row>
           <entry>
             <itemizedlist spacing="compact">
-              <listitem><simpara>GNU C++ 2.95.x, 3.0.x and later versions</simpara></listitem>
+              <listitem><simpara>GNU C++ 2.95.x, 3.0.x, 3.1.x</simpara></listitem>
               <listitem><simpara>Comeau C++ 4.2.45.2</simpara></listitem>
               <listitem><simpara>SGI MIPSpro 7.3.0</simpara></listitem>
               <listitem><simpara>Intel C++ 5.0, 6.0</simpara></listitem>
               <listitem><simpara>Compaq's cxx 6.2</simpara></listitem>
-	      <listitem><simpara>Microsoft Visual C++ 7.1 and later versions</simpara></listitem>
+	      <listitem><simpara>Microsoft Visual C++ 7.1</simpara></listitem>
             </itemizedlist>
           </entry>
           <entry>

include/boost/function.hpp

@@ -23,8 +23,8 @@
 // in anything that may be included by function_template.hpp doesn't break
 #include <boost/function/detail/prologue.hpp>
 
-// Older Visual Age C++ version do not handle the file iteration well
-#if BOOST_WORKAROUND(__IBMCPP__, >= 500) && BOOST_WORKAROUND(__IBMCPP__, < 800)
+// Visual Age C++ doesn't handle the file iteration well
+#if BOOST_WORKAROUND(__IBMCPP__, >= 500)
 #  if BOOST_FUNCTION_MAX_ARGS >= 0
 #    include <boost/function/function0.hpp>
 #  endif

include/boost/function/function_base.hpp

@@ -15,12 +15,9 @@
 #include <string>
 #include <memory>
 #include <new>
+#include <typeinfo>
 #include <boost/config.hpp>
-#include <boost/detail/sp_typeinfo.hpp>
 #include <boost/assert.hpp>
-#include <boost/integer.hpp>
-#include <boost/type_traits/has_trivial_copy.hpp>
-#include <boost/type_traits/has_trivial_destructor.hpp>
 #include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/is_volatile.hpp>
@@ -45,7 +42,7 @@
 #endif       
 
 // Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
-#ifdef BOOST_NO_STD_TYPEINFO
+#ifdef BOOST_NO_EXCEPTION_STD_NAMESPACE
 // Embedded VC++ does not have type_info in namespace std
 #  define BOOST_FUNCTION_STD_NS
 #else
@@ -54,9 +51,7 @@
 
 // Borrowed from Boost.Python library: determines the cases where we
 // need to use std::type_info::name to compare instead of operator==.
-#if defined( BOOST_NO_TYPEID )
-#  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
-#elif (defined(__GNUC__) && __GNUC__ >= 3) \
+# if (defined(__GNUC__) && __GNUC__ >= 3) \
  || defined(_AIX) \
  || (   defined(__sgi) && defined(__host_mips))
 #  include <cstring>
@@ -105,7 +100,7 @@ namespace boost {
         // For pointers to std::type_info objects
         struct type_t {
           // (get_functor_type_tag, check_functor_type_tag).
-          const detail::sp_typeinfo* type;
+          const BOOST_FUNCTION_STD_NS::type_info* type;
 
           // Whether the type is const-qualified.
           bool const_qualified;
@@ -217,12 +212,12 @@ namespace boost {
 
           case check_functor_type_tag:
             {
-              const detail::sp_typeinfo& check_type 
+              const BOOST_FUNCTION_STD_NS::type_info& check_type 
                 = *out_buffer.type.type;
 
               // Check whether we have the same type. We can add
               // cv-qualifiers, but we can't take them away.
-              if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(F))
+              if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F))
                   && (!in_buffer.obj_ref.is_const_qualified 
                       || out_buffer.type.const_qualified)
                   && (!in_buffer.obj_ref.is_volatile_qualified
@@ -234,7 +229,7 @@ namespace boost {
             return;
 
           case get_functor_type_tag:
-            out_buffer.type.type = &BOOST_SP_TYPEID(F);
+            out_buffer.type.type = &typeid(F);
             out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified;
             out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified;
             return;
@@ -264,12 +259,6 @@ namespace boost {
           A(a)
         {
         }
-        
-        functor_wrapper(const functor_wrapper& f) :
-          F(static_cast<const F&>(f)),
-          A(static_cast<const A&>(f))
-        {
-        }
       };
 
       /**
@@ -294,14 +283,14 @@ namespace boost {
           } else if (op == destroy_functor_tag)
             out_buffer.func_ptr = 0;
           else if (op == check_functor_type_tag) {
-            const detail::sp_typeinfo& check_type 
+            const BOOST_FUNCTION_STD_NS::type_info& check_type 
               = *out_buffer.type.type;
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
               out_buffer.obj_ptr = &in_buffer.func_ptr;
             else
               out_buffer.obj_ptr = 0;
           } else /* op == get_functor_type_tag */ {
-            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
+            out_buffer.type.type = &typeid(Functor);
             out_buffer.type.const_qualified = false;
             out_buffer.type.volatile_qualified = false;
           }
@@ -315,27 +304,23 @@ namespace boost {
           if (op == clone_functor_tag || op == move_functor_tag) {
             const functor_type* in_functor = 
               reinterpret_cast<const functor_type*>(&in_buffer.data);
-            new (reinterpret_cast<void*>(&out_buffer.data)) functor_type(*in_functor);
+            new ((void*)&out_buffer.data) functor_type(*in_functor);
 
             if (op == move_functor_tag) {
-              functor_type* f = reinterpret_cast<functor_type*>(&in_buffer.data);
-              (void)f; // suppress warning about the value of f not being used (MSVC)
-              f->~Functor();
+              reinterpret_cast<functor_type*>(&in_buffer.data)->~Functor();
             }
           } else if (op == destroy_functor_tag) {
             // Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
-             functor_type* f = reinterpret_cast<functor_type*>(&out_buffer.data);
-             (void)f; // suppress warning about the value of f not being used (MSVC)
-             f->~Functor();
+            reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
           } else if (op == check_functor_type_tag) {
-            const detail::sp_typeinfo& check_type 
+            const BOOST_FUNCTION_STD_NS::type_info& check_type 
               = *out_buffer.type.type;
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
               out_buffer.obj_ptr = &in_buffer.data;
             else
               out_buffer.obj_ptr = 0;
           } else /* op == get_functor_type_tag */ {
-            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
+            out_buffer.type.type = &typeid(Functor);
             out_buffer.type.const_qualified = false;
             out_buffer.type.volatile_qualified = false;            
           }
@@ -373,10 +358,8 @@ namespace boost {
             // Clone the functor
             // GCC 2.95.3 gets the CV qualifiers wrong here, so we
             // can't do the static_cast that we should do.
-            // jewillco: Changing this to static_cast because GCC 2.95.3 is
-            // obsolete.
             const functor_type* f =
-              static_cast<const functor_type*>(in_buffer.obj_ptr);
+              (const functor_type*)(in_buffer.obj_ptr);
             functor_type* new_f = new functor_type(*f);
             out_buffer.obj_ptr = new_f;
           } else if (op == move_functor_tag) {
@@ -389,14 +372,14 @@ namespace boost {
             delete f;
             out_buffer.obj_ptr = 0;
           } else if (op == check_functor_type_tag) {
-            const detail::sp_typeinfo& check_type
+            const BOOST_FUNCTION_STD_NS::type_info& check_type
               = *out_buffer.type.type;
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
               out_buffer.obj_ptr = in_buffer.obj_ptr;
             else
               out_buffer.obj_ptr = 0;
           } else /* op == get_functor_type_tag */ {
-            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
+            out_buffer.type.type = &typeid(Functor);
             out_buffer.type.const_qualified = false;
             out_buffer.type.volatile_qualified = false;
           }
@@ -431,7 +414,7 @@ namespace boost {
           typedef typename get_function_tag<functor_type>::type tag_type;
           switch (op) {
           case get_functor_type_tag:
-            out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
+            out_buffer.type.type = &typeid(functor_type);
             out_buffer.type.const_qualified = false;
             out_buffer.type.volatile_qualified = false;
             return;
@@ -480,7 +463,7 @@ namespace boost {
             // GCC 2.95.3 gets the CV qualifiers wrong here, so we
             // can't do the static_cast that we should do.
             const functor_wrapper_type* f =
-              static_cast<const functor_wrapper_type*>(in_buffer.obj_ptr);
+              (const functor_wrapper_type*)(in_buffer.obj_ptr);
             wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
             wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
             wrapper_allocator.construct(copy, *f);
@@ -500,14 +483,14 @@ namespace boost {
             wrapper_allocator.deallocate(victim,1);
             out_buffer.obj_ptr = 0;
           } else if (op == check_functor_type_tag) {
-            const detail::sp_typeinfo& check_type 
+            const BOOST_FUNCTION_STD_NS::type_info& check_type 
               = *out_buffer.type.type;
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
               out_buffer.obj_ptr = in_buffer.obj_ptr;
             else
               out_buffer.obj_ptr = 0;
           } else /* op == get_functor_type_tag */ {
-            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
+            out_buffer.type.type = &typeid(Functor);
             out_buffer.type.const_qualified = false;
             out_buffer.type.volatile_qualified = false;
           }
@@ -534,7 +517,7 @@ namespace boost {
           typedef typename get_function_tag<functor_type>::type tag_type;
           switch (op) {
           case get_functor_type_tag:
-            out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
+            out_buffer.type.type = &typeid(functor_type);
             out_buffer.type.const_qualified = false;
             out_buffer.type.volatile_qualified = false;
             return;
@@ -635,14 +618,14 @@ public:
   /** Determine if the function is empty (i.e., has no target). */
   bool empty() const { return !vtable; }
 
-  /** Retrieve the type of the stored function object, or BOOST_SP_TYPEID(void)
+  /** Retrieve the type of the stored function object, or typeid(void)
       if this is empty. */
-  const detail::sp_typeinfo& target_type() const
+  const BOOST_FUNCTION_STD_NS::type_info& target_type() const
   {
-    if (!vtable) return BOOST_SP_TYPEID(void);
+    if (!vtable) return typeid(void);
 
     detail::function::function_buffer type;
-    get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
+    vtable->manager(functor, type, detail::function::get_functor_type_tag);
     return *type.type.type;
   }
 
@@ -652,10 +635,10 @@ public:
       if (!vtable) return 0;
 
       detail::function::function_buffer type_result;
-      type_result.type.type = &BOOST_SP_TYPEID(Functor);
+      type_result.type.type = &typeid(Functor);
       type_result.type.const_qualified = is_const<Functor>::value;
       type_result.type.volatile_qualified = is_volatile<Functor>::value;
-      get_vtable()->manager(functor, type_result, 
+      vtable->manager(functor, type_result, 
                       detail::function::check_functor_type_tag);
       return static_cast<Functor*>(type_result.obj_ptr);
     }
@@ -670,14 +653,14 @@ public:
       if (!vtable) return 0;
 
       detail::function::function_buffer type_result;
-      type_result.type.type = &BOOST_SP_TYPEID(Functor);
+      type_result.type.type = &typeid(Functor);
       type_result.type.const_qualified = true;
       type_result.type.volatile_qualified = is_volatile<Functor>::value;
-      get_vtable()->manager(functor, type_result, 
+      vtable->manager(functor, type_result, 
                       detail::function::check_functor_type_tag);
       // GCC 2.95.3 gets the CV qualifiers wrong here, so we
       // can't do the static_cast that we should do.
-      return static_cast<const Functor*>(type_result.obj_ptr);
+      return (const Functor*)(type_result.obj_ptr);
     }
 
   template<typename F>
@@ -719,15 +702,6 @@ public:
 #endif
 
 public: // should be protected, but GCC 2.95.3 will fail to allow access
-  detail::function::vtable_base* get_vtable() const {
-    return reinterpret_cast<detail::function::vtable_base*>(
-             reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
-  }
-
-  bool has_trivial_copy_and_destroy() const {
-    return reinterpret_cast<std::size_t>(vtable) & 0x01;
-  }
-
   detail::function::vtable_base* vtable;
   mutable detail::function::function_buffer functor;
 };
@@ -903,8 +877,4 @@ namespace detail {
 #undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
 #undef BOOST_FUNCTION_COMPARE_TYPE_ID
 
-#if defined(BOOST_MSVC)
-#   pragma warning( pop )
-#endif       
-
 #endif // BOOST_FUNCTION_BASE_HEADER

include/boost/function/function_fwd.hpp

@@ -21,7 +21,7 @@ namespace boost { namespace python { namespace objects {
 
 #if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                    \
  || defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
- || !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
+ || !(BOOST_STRICT_CONFIG || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
 #  define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
 #endif
 

include/boost/function/function_template.hpp

@@ -11,7 +11,6 @@
 // Note: this header is a header template and must NOT have multiple-inclusion
 // protection.
 #include <boost/function/detail/prologue.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
 
 #if defined(BOOST_MSVC)
 #   pragma warning( push )
@@ -514,7 +513,7 @@ namespace boost {
           if (f) {
             // should be a reinterpret cast, but some compilers insist
             // on giving cv-qualifiers to free functions
-            functor.func_ptr = reinterpret_cast<void (*)()>(f);
+            functor.func_ptr = (void (*)())(f);
             return true;
           } else {
             return false;
@@ -536,7 +535,7 @@ namespace boost {
           // objects, so we invoke through mem_fn() but we retain the
           // right target_type() values.
           if (f) {
-            this->assign_to(boost::mem_fn(f), functor);
+            this->assign_to(mem_fn(f), functor);
             return true;
           } else {
             return false;
@@ -549,7 +548,7 @@ namespace boost {
           // objects, so we invoke through mem_fn() but we retain the
           // right target_type() values.
           if (f) {
-            this->assign_to_a(boost::mem_fn(f), functor, a);
+            this->assign_to_a(mem_fn(f), functor, a);
             return true;
           } else {
             return false;
@@ -563,7 +562,7 @@ namespace boost {
         void 
         assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
         {
-          new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
+          new ((void*)&functor.data) FunctionObj(f);
         }
         template<typename FunctionObj,typename Allocator>
         void 
@@ -625,10 +624,14 @@ namespace boost {
         assign_to(const reference_wrapper<FunctionObj>& f, 
                   function_buffer& functor, function_obj_ref_tag)
         {
-          functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
-          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
-          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
-          return true;
+          if (!boost::detail::function::has_empty_target(f.get_pointer())) {
+            functor.obj_ref.obj_ptr = (void *)f.get_pointer();
+            functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+            functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+            return true;
+          } else {
+            return false;
+          }
         }
         template<typename FunctionObj,typename Allocator>
         bool 
@@ -675,11 +678,6 @@ namespace boost {
               R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
       vtable_type;
 
-    vtable_type* get_vtable() const {
-      return reinterpret_cast<vtable_type*>(
-               reinterpret_cast<std::size_t>(vtable) & ~static_cast<size_t>(0x01));
-    }
-
     struct clear_type {};
 
   public:
@@ -759,7 +757,7 @@ namespace boost {
       if (this->empty())
         boost::throw_exception(bad_function_call());
 
-      return get_vtable()->invoker
+      return static_cast<vtable_type*>(vtable)->invoker
                (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
     }
 #else
@@ -783,26 +781,24 @@ namespace boost {
     operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
     {
       this->clear();
-      BOOST_TRY  {
+      try {
         this->assign_to(f);
-      } BOOST_CATCH (...) {
+      } catch (...) {
         vtable = 0;
-        BOOST_RETHROW;
+        throw;
       }
-      BOOST_CATCH_END
       return *this;
     }
     template<typename Functor,typename Allocator>
     void assign(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a)
     {
       this->clear();
-      BOOST_TRY{
+      try {
         this->assign_to_a(f,a);
-      } BOOST_CATCH (...) {
+      } catch (...) {
         vtable = 0;
-        BOOST_RETHROW;
+        throw;
       }
-      BOOST_CATCH_END
     }
 
 #ifndef BOOST_NO_SFINAE
@@ -827,13 +823,12 @@ namespace boost {
         return *this;
 
       this->clear();
-      BOOST_TRY {
+      try {
         this->assign_to_own(f);
-      } BOOST_CATCH (...) {
+      } catch (...) {
         vtable = 0;
-        BOOST_RETHROW;
+        throw;
       }
-      BOOST_CATCH_END
       return *this;
     }
 
@@ -852,8 +847,7 @@ namespace boost {
     void clear()
     {
       if (vtable) {
-        if (!this->has_trivial_copy_and_destroy())
-          get_vtable()->clear(this->functor);
+        reinterpret_cast<vtable_type*>(vtable)->clear(this->functor);
         vtable = 0;
       }
     }
@@ -882,11 +876,8 @@ namespace boost {
     {
       if (!f.empty()) {
         this->vtable = f.vtable;
-        if (this->has_trivial_copy_and_destroy())
-          this->functor = f.functor;
-        else
-          get_vtable()->base.manager(f.functor, this->functor,
-                                     boost::detail::function::clone_functor_tag);
+        f.vtable->manager(f.functor, this->functor,
+                          boost::detail::function::clone_functor_tag);
       }
     }
 
@@ -912,15 +903,8 @@ namespace boost {
       static vtable_type stored_vtable = 
         { { &manager_type::manage }, &invoker_type::invoke };
 
-      if (stored_vtable.assign_to(f, functor)) {
-        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
-        if (boost::has_trivial_copy_constructor<Functor>::value &&
-            boost::has_trivial_destructor<Functor>::value &&
-            detail::function::function_allows_small_object_optimization<Functor>::value)
-          value |= static_cast<size_t>(0x01);
-        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
-      } else 
-        vtable = 0;
+      if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable.base;
+      else vtable = 0;
     }
 
     template<typename Functor,typename Allocator>
@@ -946,15 +930,8 @@ namespace boost {
       static vtable_type stored_vtable =
         { { &manager_type::manage }, &invoker_type::invoke };
 
-      if (stored_vtable.assign_to_a(f, functor, a)) { 
-        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
-        if (boost::has_trivial_copy_constructor<Functor>::value &&
-            boost::has_trivial_destructor<Functor>::value &&
-            detail::function::function_allows_small_object_optimization<Functor>::value)
-          value |= static_cast<std::size_t>(0x01);
-        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
-      } else 
-        vtable = 0;
+      if (stored_vtable.assign_to_a(f, functor, a)) vtable = &stored_vtable.base;
+      else vtable = 0;
     }
 
     // Moves the value from the specified argument to *this. If the argument 
@@ -965,23 +942,23 @@ namespace boost {
       if (&f == this)
         return;
 
-      BOOST_TRY {
+#if !defined(BOOST_NO_EXCEPTIONS)      
+      try {
+#endif
         if (!f.empty()) {
           this->vtable = f.vtable;
-          if (this->has_trivial_copy_and_destroy())
-            this->functor = f.functor;
-          else
-            get_vtable()->base.manager(f.functor, this->functor,
-                                     boost::detail::function::move_functor_tag);
-          f.vtable = 0;
+          f.vtable->manager(f.functor, this->functor,
+                            boost::detail::function::move_functor_tag);
+		  f.vtable = 0;
+#if !defined(BOOST_NO_EXCEPTIONS)      
         } else {
           clear();
         }
-      } BOOST_CATCH (...) {
+      } catch (...) {
         vtable = 0;
-        BOOST_RETHROW;
+        throw;
       }
-      BOOST_CATCH_END
+#endif
     }
   };
 
@@ -1002,14 +979,13 @@ namespace boost {
   template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
   typename BOOST_FUNCTION_FUNCTION<
       R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>::result_type
-  inline 
-  BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
+   BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
   ::operator()(BOOST_FUNCTION_PARMS) const
   {
     if (this->empty())
       boost::throw_exception(bad_function_call());
 
-    return get_vtable()->invoker
+    return reinterpret_cast<const vtable_type*>(vtable)->invoker
              (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
   }
 #endif

test/Jamfile.v2

@@ -8,7 +8,6 @@
 # For more information, see http://www.boost.org/
 
 project
-    : requirements <toolset>msvc:<asynch-exceptions>on
     : source-location $(BOOST_ROOT)
     ;
 

test/allocator_test.cpp

@@ -128,10 +128,6 @@ test_main(int, char*[])
   BOOST_CHECK(dealloc_count == 0);
   fv.assign( &do_nothing, std::allocator<int>() );
   fv.clear();
-  
-  function0<void> fv2;
-  fv.assign(&do_nothing, std::allocator<int>() );
-  fv2.assign(fv, std::allocator<int>() );
 
   return 0;
 }

test/function_test.cpp

@@ -13,8 +13,8 @@
 #include <string>
 #include <utility>
 
-using boost::function;
-using std::string;
+using namespace boost;
+using namespace std;
 
 int global_int;
 
@@ -525,7 +525,7 @@ test_zero_args()
 static void
 test_one_arg()
 {
-  std::negate<int> neg;
+  negate<int> neg;
 
   function<int (int)> f1(neg);
   BOOST_CHECK(f1(5) == -5);
@@ -607,12 +607,12 @@ struct add_with_throw_on_copy {
 
   add_with_throw_on_copy(const add_with_throw_on_copy&)
   {
-    throw std::runtime_error("But this CAN'T throw");
+    throw runtime_error("But this CAN'T throw");
   }
 
   add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
   {
-    throw std::runtime_error("But this CAN'T throw");
+    throw runtime_error("But this CAN'T throw");
   }
 };
 
@@ -621,38 +621,14 @@ test_ref()
 {
   add_with_throw_on_copy atc;
   try {
-    boost::function<int (int, int)> f(boost::ref(atc));
+    boost::function<int (int, int)> f(ref(atc));
     BOOST_CHECK(f(1, 3) == 4);
   }
-  catch(std::runtime_error e) {
+  catch(runtime_error e) {
     BOOST_ERROR("Nonthrowing constructor threw an exception");
   }
 }
 
-static void dummy() {}
-
-static void test_empty_ref()
-{
-  boost::function<void()> f1;
-  boost::function<void()> f2(boost::ref(f1));
-
-  try {
-    f2();
-    BOOST_ERROR("Exception didn't throw for reference to empty function.");
-  }
-  catch(std::runtime_error e) {}
-
-  f1 = dummy;
-
-  try {
-    f2();
-  }
-  catch(std::runtime_error e) {
-    BOOST_ERROR("Error calling referenced function.");
-  }
-}
-
-
 static void test_exception()
 {
   boost::function<int (int, int)> f;
@@ -698,7 +674,6 @@ int test_main(int, char* [])
   test_emptiness();
   test_member_functions();
   test_ref();
-  test_empty_ref();
   test_exception();
   test_implicit();
   test_call();

test/lambda_test.cpp

@@ -15,21 +15,21 @@
 #include <boost/lambda/bind.hpp>
 #include <boost/function.hpp>
 
+using namespace std;
+using namespace boost;
+using namespace boost::lambda;
+
 static unsigned
 func_impl(int arg1, bool arg2, double arg3)
 {
-  using namespace std;
   return abs (static_cast<int>((arg2 ? arg1 : 2 * arg1) * arg3));
 }
 
 int test_main(int, char*[])
 {
-  using boost::function;
-  using namespace boost::lambda;
-
   function <unsigned(bool, double)> f1 = bind(func_impl, 15, _1, _2);
-  function <unsigned(double)>       f2 = boost::lambda::bind(f1, false, _1);
-  function <unsigned()>             f3 = boost::lambda::bind(f2, 4.0);
+  function <unsigned(double)>       f2 = bind(f1, false, _1);
+  function <unsigned()>             f3 = bind(f2, 4.0);
 
   f3();