Stupid fix, from mainline

[SVN r19490]

example/bind1st.cpp

@@ -0,0 +1,38 @@
+// Boost.Function library examples
+
+// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
+
+// For more information, see http://www.boost.org
+
+#include <iostream>
+#include <boost/function.hpp>
+#include <functional>
+
+struct X {
+  X(int val) : value(val) {}
+
+  int foo(int x) { return x * value; }
+
+  int value;
+};
+
+
+int
+main()
+{
+  boost::function<int, int> f;
+  X x(7);
+  f = std::bind1st(std::mem_fun(&X::foo), &x);
+
+  std::cout << f(5) << std::endl; // Call x.foo(5)
+  return 0;
+}

example/int_div.cpp

@@ -0,0 +1,32 @@
+// Boost.Function library examples
+
+// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
+
+// For more information, see http://www.boost.org
+
+#include <iostream>
+#include <boost/function.hpp>
+
+struct int_div { 
+  float operator()(int x, int y) const { return ((float)x)/y; }; 
+};
+
+int
+main()
+{
+  boost::function<float, int, int> f;
+  f = int_div();
+
+  std::cout << f(5, 3) << std::endl; // 1.66667
+
+  return 0;
+}

example/sum_avg.cpp

@@ -0,0 +1,44 @@
+// Boost.Function library examples
+
+// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
+
+// For more information, see http://www.boost.org
+
+#include <iostream>
+#include <boost/function.hpp>
+
+void do_sum_avg(int values[], int n, int& sum, float& avg)
+{
+  sum = 0;
+  for (int i = 0; i < n; i++)
+    sum += values[i];
+  avg = (float)sum / n;
+}
+
+int
+main()
+{
+  // The second parameter should be int[], but some compilers (e.g., GCC)
+  // complain about this 
+  boost::function<void, int*, int, int&, float&> sum_avg;
+
+  sum_avg = &do_sum_avg;
+
+  int values[5] = { 1, 1, 2, 3, 5 };
+  int sum;
+  float avg;
+  sum_avg(values, 5, sum, avg);
+
+  std::cout << "sum = " << sum << std::endl;
+  std::cout << "avg = " << avg << std::endl;
+  return 0;
+}

include/boost/function.hpp

@@ -1,9 +1,15 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2001-2003. Use, modification and
-//  distribution is subject to 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)
+// Copyright (C) 2001, 2002 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
 
 // For more information, see http://www.boost.org/libs/function
 
@@ -22,7 +28,7 @@
 #include <boost/function/detail/prologue.hpp>
 
 // Visual Age C++ doesn't handle the file iteration well
-#if BOOST_WORKAROUND(__IBMCPP__, >= 500)
+#if BOOST_WORKAROUND(__IBMCPP__, <= 600)
 #  if BOOST_FUNCTION_MAX_ARGS >= 0
 #    include <boost/function/function0.hpp>
 #  endif

include/boost/function/detail/function_iterate.hpp

@@ -1,9 +1,15 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2003. Use, modification and
-//  distribution is subject to 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)
+// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
 
 // For more information, see http://www.boost.org
 #if !defined(BOOST_PP_IS_ITERATING)

include/boost/function/detail/gen_maybe_include.pl

@@ -2,7 +2,7 @@
 #
 # Boost.Function library
 #
-# Copyright (C) 2001-2003 Douglas Gregor (gregod@cs.rpi.edu)
+# Copyright (C) 2001-2003 Doug Gregor (gregod@cs.rpi.edu)
 #
 # Permission to copy, use, sell and distribute this software is granted
 # provided this copyright notice appears in all copies.

include/boost/function/detail/maybe_include.hpp

@@ -1,9 +1,15 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2003. Use, modification and
-//  distribution is subject to 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)
+// Copyright (C) 2003 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
 
 // For more information, see http://www.boost.org
 

include/boost/function/detail/prologue.hpp

@@ -1,9 +1,15 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
-//  distribution is subject to 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)
+// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
 
 // For more information, see http://www.boost.org
 
@@ -15,7 +21,7 @@
 #  include <boost/config.hpp>
 #  include <boost/function/function_base.hpp>
 #  include <boost/mem_fn.hpp>
-#  include <boost/type_traits/is_integral.hpp>
+#  include <boost/type_traits/is_same.hpp>
 #  include <boost/preprocessor/enum.hpp>
 #  include <boost/preprocessor/enum_params.hpp>
 #  include <boost/preprocessor/cat.hpp>

include/boost/function/function0.hpp

@@ -1,9 +1,15 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
-//  distribution is subject to 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)
+// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
 
 // For more information, see http://www.boost.org
 

include/boost/function/function1.hpp

@@ -1,9 +1,15 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
-//  distribution is subject to 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)
+// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
 
 // For more information, see http://www.boost.org
 

include/boost/function/function10.hpp

@@ -1,9 +1,15 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
-//  distribution is subject to 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)
+// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
 
 // For more information, see http://www.boost.org
 

include/boost/function/function2.hpp

@@ -1,9 +1,15 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
-//  distribution is subject to 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)
+// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
 
 // For more information, see http://www.boost.org
 

include/boost/function/function3.hpp

@@ -1,9 +1,15 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
-//  distribution is subject to 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)
+// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
 
 // For more information, see http://www.boost.org
 

include/boost/function/function4.hpp

@@ -1,9 +1,15 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
-//  distribution is subject to 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)
+// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
 
 // For more information, see http://www.boost.org
 

include/boost/function/function5.hpp

@@ -1,9 +1,15 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
-//  distribution is subject to 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)
+// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
 
 // For more information, see http://www.boost.org
 

include/boost/function/function6.hpp

@@ -1,9 +1,15 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
-//  distribution is subject to 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)
+// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
 
 // For more information, see http://www.boost.org
 

include/boost/function/function7.hpp

@@ -1,9 +1,15 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
-//  distribution is subject to 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)
+// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
 
 // For more information, see http://www.boost.org
 

include/boost/function/function8.hpp

@@ -1,9 +1,15 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
-//  distribution is subject to 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)
+// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
 
 // For more information, see http://www.boost.org
 

include/boost/function/function9.hpp

@@ -1,9 +1,15 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
-//  distribution is subject to 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)
+// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
 
 // For more information, see http://www.boost.org
 

include/boost/function/function_base.hpp

@@ -1,9 +1,15 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2001-2004. Use, modification and
-//  distribution is subject to 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)
+// Copyright (C) 2001-2003 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
 
 // For more information, see http://www.boost.org
 
@@ -14,33 +20,14 @@
 #include <string>
 #include <memory>
 #include <new>
-#include <typeinfo>
 #include <boost/config.hpp>
 #include <boost/assert.hpp>
-#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/arithmetic_traits.hpp>
 #include <boost/type_traits/composite_traits.hpp>
 #include <boost/type_traits/is_stateless.hpp>
 #include <boost/ref.hpp>
 #include <boost/pending/ct_if.hpp>
 #include <boost/detail/workaround.hpp>
-#ifndef BOOST_NO_SFINAE
-#  include "boost/utility/enable_if.hpp"
-#else
-#  include "boost/mpl/bool.hpp"
-#endif
-#include <boost/function_equal.hpp>
-
-// Borrowed from Boost.Python library: determines the cases where we
-// need to use std::type_info::name to compare instead of operator==.
-# if (defined(__GNUC__) && __GNUC__ >= 3) \
- || defined(_AIX) \
- || (   defined(__sgi) && defined(__host_mips))
-#  include <cstring>
-#  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) \
-     (std::strcmp((X).name(),(Y).name()) == 0)
-# else
-#  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
-#endif
 
 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
 #  define BOOST_FUNCTION_TARGET_FIX(x) x
@@ -57,27 +44,36 @@ namespace boost { namespace python { namespace objects {
 }}}
 #endif
 
-#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                    \
- || defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
- || !(BOOST_STRICT_CONFIG || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
-#  define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
+// GCC 2.95.3 (or earlier) doesn't support enable_if
+#if BOOST_WORKAROUND(__GNUC__, < 3)
+#  define BOOST_FUNCTION_NO_ENABLE_IF
 #endif
 
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
-#  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)              \
-      typename ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
-                            (::boost::is_integral<Functor>::value)>::value), \
-                           Type>::type
-#else
-// BCC doesn't recognize this depends on a template argument and complains
-// about the use of 'typename'
-#  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)     \
-      ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
-                   (::boost::is_integral<Functor>::value)>::value), \
-                       Type>::type
+// MIPSpro 7.3.1.3m doesn't support enable_if
+#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
+#  define BOOST_FUNCTION_NO_ENABLE_IF
 #endif
 
-#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
+// MSVC 7.0 doesn't support enable_if
+#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 && !defined(BOOST_STRICT_CONFIG)
+#  define BOOST_FUNCTION_NO_ENABLE_IF
+#endif
+
+// Borland C++ 5.6.0 doesn't support enable_if
+#if BOOST_WORKAROUND(__BORLANDC__, <= 0x564)
+#  define BOOST_FUNCTION_NO_ENABLE_IF
+#endif
+
+// Metrowerks 7.2 doesn't support enable_if
+#if BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
+#  define BOOST_FUNCTION_NO_ENABLE_IF
+#endif
+
+#if BOOST_WORKAROUND(__SUNPRO_CC, <= 0x540)
+#  define BOOST_FUNCTION_NO_ENABLE_IF
+#endif
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 namespace boost {
 
 #if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
@@ -168,8 +164,7 @@ namespace boost {
       // The operation type to perform on the given functor/function pointer
       enum functor_manager_operation_type {
         clone_functor_tag,
-        destroy_functor_tag,
-        check_functor_type_tag
+        destroy_functor_tag
       };
 
       // Tags used to decide between different types of functions
@@ -202,31 +197,14 @@ namespace boost {
 
       // The trivial manager does nothing but return the same pointer (if we
       // are cloning) or return the null pointer (if we are deleting).
-      template<typename F>
-      struct trivial_manager
+      inline any_pointer trivial_manager(any_pointer f,
+                                         functor_manager_operation_type op)
       {
-        static inline any_pointer
-        get(any_pointer f, functor_manager_operation_type op)
-        {
-          switch (op) {
-          case clone_functor_tag: return f;
-
-          case destroy_functor_tag:
-            return make_any_pointer(reinterpret_cast<void*>(0));
-
-          case check_functor_type_tag:
-            {
-              std::type_info* t = static_cast<std::type_info*>(f.obj_ptr);
-              return BOOST_FUNCTION_COMPARE_TYPE_ID(typeid(F), *t)?
-                f
-                : make_any_pointer(reinterpret_cast<void*>(0));
-            }
-          }
-
-          // Clears up a warning with GCC 3.2.3
+        if (op == clone_functor_tag)
+          return f;
+        else
           return make_any_pointer(reinterpret_cast<void*>(0));
-        }
-      };
+      }
 
       /**
        * The functor_manager class contains a static function "manage" which
@@ -311,81 +289,43 @@ namespace boost {
         static any_pointer
         manage(any_pointer functor_ptr, functor_manager_operation_type op)
         {
-          if (op == check_functor_type_tag) {
-            std::type_info* type =
-              static_cast<std::type_info*>(functor_ptr.obj_ptr);
-            return (BOOST_FUNCTION_COMPARE_TYPE_ID(typeid(Functor), *type)?
-                    functor_ptr
-                    : make_any_pointer(reinterpret_cast<void*>(0)));
-          }
-          else {
-            typedef typename get_function_tag<functor_type>::type tag_type;
-            return manager(functor_ptr, op, tag_type());
-          }
+          typedef typename get_function_tag<functor_type>::type tag_type;
+          return manager(functor_ptr, op, tag_type());
         }
       };
 
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    template<bool cond, typename T> struct enable_if;
+    template<typename T> struct enable_if<true, T>  { typedef T type; };
+    template<typename T> struct enable_if<false, T> {};
+
+    template<bool x>
+    struct enabled
+    {
+      template<typename T>
+      struct base
+      {
+        typedef T type;
+      };
+    };
+
+    template<>
+    struct enabled<false>
+    {
+      template<typename T>
+      struct base
+      {
+      };
+    };
+
+    template<bool Enabled, typename T>
+    struct enable_if : public enabled<Enabled>::template base<T>
+    {
+    };
+#endif
+
       // A type that is only used for comparisons against zero
       struct useless_clear_type {};
-
-#ifdef BOOST_NO_SFINAE
-      // These routines perform comparisons between a Boost.Function
-      // object and an arbitrary function object (when the last
-      // parameter is mpl::bool_<false>) or against zero (when the
-      // last parameter is mpl::bool_<true>). They are only necessary
-      // for compilers that don't support SFINAE.
-      template<typename Function, typename Functor>
-        bool
-        compare_equal(const Function& f, const Functor&, int, mpl::bool_<true>)
-        { return f.empty(); }
-
-      template<typename Function, typename Functor>
-        bool
-        compare_not_equal(const Function& f, const Functor&, int,
-                          mpl::bool_<true>)
-        { return !f.empty(); }
-
-      template<typename Function, typename Functor>
-        bool
-        compare_equal(const Function& f, const Functor& g, long,
-                      mpl::bool_<false>)
-        {
-          if (const Functor* fp = f.template target<Functor>())
-            return function_equal(*fp, g);
-          else return false;
-        }
-
-      template<typename Function, typename Functor>
-        bool
-        compare_equal(const Function& f, const reference_wrapper<Functor>& g,
-                      int, mpl::bool_<false>)
-        {
-          if (const Functor* fp = f.template target<Functor>())
-            return fp == g.get_pointer();
-          else return false;
-        }
-
-      template<typename Function, typename Functor>
-        bool
-        compare_not_equal(const Function& f, const Functor& g, long,
-                          mpl::bool_<false>)
-        {
-          if (const Functor* fp = f.template target<Functor>())
-            return !function_equal(*fp, g);
-          else return true;
-        }
-
-      template<typename Function, typename Functor>
-        bool
-        compare_not_equal(const Function& f,
-                          const reference_wrapper<Functor>& g, int,
-                          mpl::bool_<false>)
-        {
-          if (const Functor* fp = f.template target<Functor>())
-            return fp != g.get_pointer();
-          else return true;
-        }
-#endif // BOOST_NO_SFINAE
     } // end namespace function
   } // end namespace detail
 
@@ -406,122 +346,11 @@ public:
   // Is this function empty?
   bool empty() const { return !manager; }
 
-  template<typename Functor>
-    Functor* target()
-    {
-      if (!manager) return 0;
-
-      detail::function::any_pointer result =
-        manager(detail::function::make_any_pointer(&typeid(Functor)),
-                detail::function::check_functor_type_tag);
-      if (!result.obj_ptr) return 0;
-      else {
-        typedef typename detail::function::get_function_tag<Functor>::type tag;
-        return get_functor_pointer<Functor>(tag(), 0);
-      }
-    }
-
-  template<typename Functor>
-
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    const Functor* target( Functor * = 0 ) const
-#else
-    const Functor* target() const
-#endif
-    {
-      if (!manager) return 0;
-
-      detail::function::any_pointer result =
-        manager(detail::function::make_any_pointer(&typeid(Functor)),
-                detail::function::check_functor_type_tag);
-      if (!result.obj_ptr) return 0;
-      else {
-        typedef typename detail::function::get_function_tag<Functor>::type tag;
-
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-        return get_functor_pointer(tag(), 0, (Functor*)0);
-#else
-        return get_functor_pointer<Functor>(tag(), 0);
-#endif
-      }
-    }
-
-  template<typename F>
-    bool contains(const F& f) const
-    {
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-      if (const F* fp = this->target( (F*)0 )) {
-#else
-      if (const F* fp = this->template target<F>()) {
-#endif
-        return function_equal(*fp, f);
-      } else {
-        return false;
-      }
-    }
-
-#if defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3
-  // GCC 3.3 and newer cannot copy with the global operator==, due to
-  // problems with instantiation of function return types before it
-  // has been verified that the argument types match up.
-  template<typename Functor>
-    BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
-    operator==(Functor g) const
-    {
-      if (const Functor* fp = target<Functor>())
-        return function_equal(*fp, g);
-      else return false;
-    }
-
-  template<typename Functor>
-    BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
-    operator!=(Functor g) const
-    {
-      if (const Functor* fp = target<Functor>())
-        return !function_equal(*fp, g);
-      else return true;
-    }
-#endif
-
 public: // should be protected, but GCC 2.95.3 will fail to allow access
   detail::function::any_pointer (*manager)(
     detail::function::any_pointer,
     detail::function::functor_manager_operation_type);
   detail::function::any_pointer functor;
-
-private:
-  template<typename Functor>
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    Functor* get_functor_pointer(detail::function::function_ptr_tag, int, Functor * = 0)
-#else
-    Functor* get_functor_pointer(detail::function::function_ptr_tag, int)
-#endif
-    { return reinterpret_cast<Functor*>(&functor.func_ptr); }
-
-  template<typename Functor, typename Tag>
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    Functor* get_functor_pointer(Tag, long, Functor * = 0)
-#else
-    Functor* get_functor_pointer(Tag, long)
-#endif
-    { return static_cast<Functor*>(functor.obj_ptr); }
-
-  template<typename Functor>
-    const Functor*
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    get_functor_pointer(detail::function::function_ptr_tag, int, Functor * = 0) const
-#else
-    get_functor_pointer(detail::function::function_ptr_tag, int) const
-#endif
-    { return reinterpret_cast<const Functor*>(&functor.func_ptr); }
-
-  template<typename Functor, typename Tag>
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    const Functor* get_functor_pointer(Tag, long, Functor * = 0) const
-#else
-    const Functor* get_functor_pointer(Tag, long) const
-#endif
-    { return static_cast<const Functor*>(functor.const_obj_ptr); }
 };
 
 /**
@@ -534,7 +363,16 @@ public:
   bad_function_call() : std::runtime_error("call to empty boost::function") {}
 };
 
-#ifndef BOOST_NO_SFINAE
+/* Poison comparison between Boost.Function objects (because it is
+ * meaningless). The comparisons would otherwise be allowed because of the
+ * conversion required to allow syntax such as:
+ *   boost::function<int, int> f;
+ *   if (f) { f(5); }
+ */
+void operator==(const function_base&, const function_base&);
+void operator!=(const function_base&, const function_base&);
+
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
 inline bool operator==(const function_base& f,
                        detail::function::useless_clear_type*)
 {
@@ -560,116 +398,6 @@ inline bool operator!=(detail::function::useless_clear_type*,
 }
 #endif
 
-#ifdef BOOST_NO_SFINAE
-// Comparisons between boost::function objects and arbitrary function objects
-template<typename Functor>
-  inline bool operator==(const function_base& f, Functor g)
-  {
-    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
-    return detail::function::compare_equal(f, g, 0, integral());
-  }
-
-template<typename Functor>
-  inline bool operator==(Functor g, const function_base& f)
-  {
-    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
-    return detail::function::compare_equal(f, g, 0, integral());
-  }
-
-template<typename Functor>
-  inline bool operator!=(const function_base& f, Functor g)
-  {
-    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
-    return detail::function::compare_not_equal(f, g, 0, integral());
-  }
-
-template<typename Functor>
-  inline bool operator!=(Functor g, const function_base& f)
-  {
-    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
-    return detail::function::compare_not_equal(f, g, 0, integral());
-  }
-#else
-
-#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-// Comparisons between boost::function objects and arbitrary function
-// objects. GCC 3.3 and before has an obnoxious bug that prevents this
-// from working.
-template<typename Functor>
-  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
-  operator==(const function_base& f, Functor g)
-  {
-    if (const Functor* fp = f.template target<Functor>())
-      return function_equal(*fp, g);
-    else return false;
-  }
-
-template<typename Functor>
-  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
-  operator==(Functor g, const function_base& f)
-  {
-    if (const Functor* fp = f.template target<Functor>())
-      return function_equal(g, *fp);
-    else return false;
-  }
-
-template<typename Functor>
-  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
-  operator!=(const function_base& f, Functor g)
-  {
-    if (const Functor* fp = f.template target<Functor>())
-      return !function_equal(*fp, g);
-    else return true;
-  }
-
-template<typename Functor>
-  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
-  operator!=(Functor g, const function_base& f)
-  {
-    if (const Functor* fp = f.template target<Functor>())
-      return !function_equal(g, *fp);
-    else return true;
-  }
-#  endif
-
-template<typename Functor>
-  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
-  operator==(const function_base& f, reference_wrapper<Functor> g)
-  {
-    if (const Functor* fp = f.template target<Functor>())
-      return fp == g.get_pointer();
-    else return false;
-  }
-
-template<typename Functor>
-  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
-  operator==(reference_wrapper<Functor> g, const function_base& f)
-  {
-    if (const Functor* fp = f.template target<Functor>())
-      return g.get_pointer() == fp;
-    else return false;
-  }
-
-template<typename Functor>
-  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
-  operator!=(const function_base& f, reference_wrapper<Functor> g)
-  {
-    if (const Functor* fp = f.template target<Functor>())
-      return fp != g.get_pointer();
-    else return true;
-  }
-
-template<typename Functor>
-  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
-  operator!=(reference_wrapper<Functor> g, const function_base& f)
-  {
-    if (const Functor* fp = f.template target<Functor>())
-      return g.get_pointer() != fp;
-    else return true;
-  }
-
-#endif // Compiler supporting SFINAE
-
 namespace detail {
   namespace function {
     inline bool has_empty_target(const function_base* f)
@@ -677,22 +405,12 @@ namespace detail {
       return f->empty();
     }
 
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
-    inline bool has_empty_target(const void*)
-    {
-      return false;
-    }
-#else
     inline bool has_empty_target(...)
     {
       return false;
     }
-#endif
   } // end namespace function
 } // end namespace detail
 } // end namespace boost
 
-#undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
-#undef BOOST_FUNCTION_COMPARE_TYPE_ID
-
 #endif // BOOST_FUNCTION_BASE_HEADER

include/boost/function/function_template.hpp

@@ -1,9 +1,15 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2001-2003. Use, modification and
-//  distribution is subject to 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)
+// Copyright (C) 2001-2003 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
 
 // For more information, see http://www.boost.org
 
@@ -61,14 +67,6 @@
 #define BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER \
   BOOST_JOIN(get_stateless_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
 
-#ifndef BOOST_NO_VOID_RETURNS
-#  define BOOST_FUNCTION_VOID_RETURN_TYPE void
-#  define BOOST_FUNCTION_RETURN(X) X
-#else
-#  define BOOST_FUNCTION_VOID_RETURN_TYPE boost::detail::function::unusable
-#  define BOOST_FUNCTION_RETURN(X) X; return BOOST_FUNCTION_VOID_RETURN_TYPE ()
-#endif
-
 namespace boost {
   namespace detail {
     namespace function {
@@ -94,13 +92,13 @@ namespace boost {
         >
       struct BOOST_FUNCTION_VOID_FUNCTION_INVOKER
       {
-        static BOOST_FUNCTION_VOID_RETURN_TYPE
-        invoke(any_pointer function_ptr BOOST_FUNCTION_COMMA
-               BOOST_FUNCTION_PARMS)
+        static unusable invoke(any_pointer function_ptr BOOST_FUNCTION_COMMA
+                               BOOST_FUNCTION_PARMS)
 
         {
           FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
-          BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
+          f(BOOST_FUNCTION_ARGS);
+          return unusable();
         }
       };
 
@@ -127,13 +125,14 @@ namespace boost {
       >
       struct BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
       {
-        static BOOST_FUNCTION_VOID_RETURN_TYPE
-        invoke(any_pointer function_obj_ptr BOOST_FUNCTION_COMMA
-               BOOST_FUNCTION_PARMS)
+        static unusable invoke(any_pointer function_obj_ptr
+                               BOOST_FUNCTION_COMMA
+                               BOOST_FUNCTION_PARMS)
 
         {
           FunctionObj* f = (FunctionObj*)(function_obj_ptr.obj_ptr);
-          BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
+          (*f)(BOOST_FUNCTION_ARGS);
+          return unusable();
         }
       };
 
@@ -158,12 +157,13 @@ namespace boost {
       >
       struct BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER
       {
-        static BOOST_FUNCTION_VOID_RETURN_TYPE
-        invoke(any_pointer BOOST_FUNCTION_COMMA BOOST_FUNCTION_PARMS)
+        static unusable invoke(any_pointer BOOST_FUNCTION_COMMA
+                               BOOST_FUNCTION_PARMS)
 
         {
           FunctionObj f = FunctionObj();
-          BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
+          f(BOOST_FUNCTION_ARGS);
+          return unusable();
         }
       };
 
@@ -240,15 +240,9 @@ namespace boost {
   >
   class BOOST_FUNCTION_FUNCTION : public function_base
   {
-  public:
-#ifndef BOOST_NO_VOID_RETURNS
-    typedef R         result_type;
-#else
-    typedef  typename boost::detail::function::function_return_type<R>::type
-      result_type;
-#endif // BOOST_NO_VOID_RETURNS
+    typedef typename detail::function::function_return_type<R>::type
+      internal_result_type;
 
-  private:
     struct clear_type {};
 
   public:
@@ -258,7 +252,7 @@ namespace boost {
     template<typename Args>
     struct sig
     {
-      typedef result_type type;
+      typedef internal_result_type type;
     };
 
 #if BOOST_FUNCTION_NUM_ARGS == 1
@@ -271,6 +265,11 @@ namespace boost {
     BOOST_STATIC_CONSTANT(int, arity = BOOST_FUNCTION_NUM_ARGS);
     BOOST_FUNCTION_ARG_TYPES
 
+#ifndef BOOST_NO_VOID_RETURNS
+    typedef R         result_type;
+#else
+    typedef internal_result_type result_type;
+#endif // BOOST_NO_VOID_RETURNS
     typedef Allocator allocator_type;
     typedef BOOST_FUNCTION_FUNCTION self_type;
 
@@ -281,12 +280,12 @@ namespace boost {
     // one with a default parameter.
     template<typename Functor>
     BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f
-#ifndef BOOST_NO_SFINAE
-                            ,typename enable_if_c<
-                            (boost::type_traits::ice_not<
-                             (is_integral<Functor>::value)>::value),
+#ifndef BOOST_FUNCTION_NO_ENABLE_IF
+                            ,typename detail::function::enable_if<
+                            (::boost::type_traits::ice_not<
+                             (is_same<Functor, int>::value)>::value),
                                         int>::type = 0
-#endif // BOOST_NO_SFINAE
+#endif // BOOST_FUNCTION_NO_ENABLE_IF
                             ) :
       function_base(),
       invoker(0)
@@ -294,7 +293,7 @@ namespace boost {
       this->assign_to(f);
     }
 
-#ifndef BOOST_NO_SFINAE
+#ifndef BOOST_FUNCTION_NO_ENABLE_IF
     BOOST_FUNCTION_FUNCTION(clear_type*) : function_base(), invoker(0) {}
 #else
     BOOST_FUNCTION_FUNCTION(int zero) : function_base(), invoker(0)
@@ -312,19 +311,21 @@ namespace boost {
 
     ~BOOST_FUNCTION_FUNCTION() { clear(); }
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    // MSVC 6.0 and prior require all definitions to be inline, but
-    // these definitions can become very costly.
     result_type operator()(BOOST_FUNCTION_PARMS) const
     {
       if (this->empty())
         boost::throw_exception(bad_function_call());
 
-      return invoker(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
-    }
+      internal_result_type result = invoker(function_base::functor
+                                            BOOST_FUNCTION_COMMA
+                                            BOOST_FUNCTION_ARGS);
+
+#ifndef BOOST_NO_VOID_RETURNS
+      return static_cast<result_type>(result);
 #else
-    result_type operator()(BOOST_FUNCTION_PARMS) const;
-#endif
+      return result;
+#endif // BOOST_NO_VOID_RETURNS
+    }
 
     // The distinction between when to use BOOST_FUNCTION_FUNCTION and
     // when to use self_type is obnoxious. MSVC cannot handle self_type as
@@ -332,10 +333,10 @@ namespace boost {
     // handle BOOST_FUNCTION_FUNCTION as the type of the temporary to
     // construct.
     template<typename Functor>
-#ifndef BOOST_NO_SFINAE
-    typename enable_if_c<
-               (boost::type_traits::ice_not<
-                 (is_integral<Functor>::value)>::value),
+#ifndef BOOST_FUNCTION_NO_ENABLE_IF
+    typename detail::function::enable_if<
+               (::boost::type_traits::ice_not<
+                 (is_same<Functor, int>::value)>::value),
                BOOST_FUNCTION_FUNCTION&>::type
 #else
     BOOST_FUNCTION_FUNCTION&
@@ -346,7 +347,7 @@ namespace boost {
       return *this;
     }
 
-#ifndef BOOST_NO_SFINAE
+#ifndef BOOST_FUNCTION_NO_ENABLE_IF
     BOOST_FUNCTION_FUNCTION& operator=(clear_type*)
     {
       this->clear();
@@ -376,21 +377,21 @@ namespace boost {
       if (&other == this)
         return;
 
-      std::swap(this->manager, other.manager);
-      std::swap(this->functor, other.functor);
+      std::swap(function_base::manager, other.manager);
+      std::swap(function_base::functor, other.functor);
       std::swap(invoker, other.invoker);
     }
 
     // Clear out a target, if there is one
     void clear()
     {
-      if (this->manager) {
+      if (function_base::manager) {
         function_base::functor =
-          this->manager(this->functor, 
-                        boost::detail::function::destroy_functor_tag);
+          function_base::manager(function_base::functor,
+                                 detail::function::destroy_functor_tag);
       }
 
-      this->manager = 0;
+      function_base::manager = 0;
       invoker = 0;
     }
 
@@ -418,73 +419,73 @@ namespace boost {
     {
       if (!f.empty()) {
         invoker = f.invoker;
-        this->manager = f.manager;
-        this->functor =
-          f.manager(f.functor, boost::detail::function::clone_functor_tag);
+        function_base::manager = f.manager;
+        function_base::functor =
+          f.manager(f.functor, detail::function::clone_functor_tag);
       }
     }
 
     template<typename Functor>
     void assign_to(Functor f)
     {
-      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
       this->assign_to(f, tag());
     }
 
     template<typename FunctionPtr>
-    void assign_to(FunctionPtr f, boost::detail::function::function_ptr_tag)
+    void assign_to(FunctionPtr f, detail::function::function_ptr_tag)
     {
       clear();
 
       if (f) {
-        typedef typename boost::detail::function::BOOST_FUNCTION_GET_FUNCTION_INVOKER<
+        typedef typename detail::function::BOOST_FUNCTION_GET_FUNCTION_INVOKER<
                            FunctionPtr,
                            R BOOST_FUNCTION_COMMA
                            BOOST_FUNCTION_TEMPLATE_ARGS
                          >::type
-          actual_invoker_type;
+          invoker_type;
 
-        invoker = &actual_invoker_type::invoke;
-        this->manager =
-          &boost::detail::function::functor_manager<FunctionPtr, Allocator>::manage;
-        this->functor =
-          this->manager(boost::detail::function::make_any_pointer(
+        invoker = &invoker_type::invoke;
+        function_base::manager =
+          &detail::function::functor_manager<FunctionPtr, Allocator>::manage;
+        function_base::functor =
+          function_base::manager(detail::function::make_any_pointer(
                             // should be a reinterpret cast, but some compilers
                             // insist on giving cv-qualifiers to free functions
                             (void (*)())(f)
                           ),
-                          boost::detail::function::clone_functor_tag);
+                          detail::function::clone_functor_tag);
       }
     }
 
 #if BOOST_FUNCTION_NUM_ARGS > 0
     template<typename MemberPtr>
-    void assign_to(MemberPtr f, boost::detail::function::member_ptr_tag)
+    void assign_to(MemberPtr f, detail::function::member_ptr_tag)
     {
       this->assign_to(mem_fn(f));
     }
 #endif // BOOST_FUNCTION_NUM_ARGS > 0
 
     template<typename FunctionObj>
-    void assign_to(FunctionObj f, boost::detail::function::function_obj_tag)
+    void assign_to(FunctionObj f, detail::function::function_obj_tag)
     {
-      if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+      if (!detail::function::has_empty_target(addressof(f))) {
         typedef
-          typename boost::detail::function::BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
+          typename detail::function::BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
                                        FunctionObj,
                                        R BOOST_FUNCTION_COMMA
                                        BOOST_FUNCTION_TEMPLATE_ARGS
                                      >::type
-          actual_invoker_type;
+          invoker_type;
 
-        invoker = &actual_invoker_type::invoke;
-        this->manager = &boost::detail::function::functor_manager<
+        invoker = &invoker_type::invoke;
+        function_base::manager = &detail::function::functor_manager<
                                     FunctionObj, Allocator>::manage;
 #ifndef BOOST_NO_STD_ALLOCATOR
         typedef typename Allocator::template rebind<FunctionObj>::other
-          rebound_allocator_type;
-        typedef typename rebound_allocator_type::pointer pointer_type;
-        rebound_allocator_type allocator;
+          allocator_type;
+        typedef typename allocator_type::pointer pointer_type;
+        allocator_type allocator;
         pointer_type copy = allocator.allocate(1);
         allocator.construct(copy, f);
 
@@ -493,53 +494,53 @@ namespace boost {
 #else
         FunctionObj* new_f = new FunctionObj(f);
 #endif // BOOST_NO_STD_ALLOCATOR
-        this->functor =
-          boost::detail::function::make_any_pointer(static_cast<void*>(new_f));
+        function_base::functor =
+          detail::function::make_any_pointer(static_cast<void*>(new_f));
       }
     }
 
     template<typename FunctionObj>
     void assign_to(const reference_wrapper<FunctionObj>& f,
-                   boost::detail::function::function_obj_ref_tag)
+                   detail::function::function_obj_ref_tag)
     {
-      if (!boost::detail::function::has_empty_target(f.get_pointer())) {
+      if (!detail::function::has_empty_target(f.get_pointer())) {
         typedef
-          typename boost::detail::function::BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
+          typename detail::function::BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
                                        FunctionObj,
                                        R BOOST_FUNCTION_COMMA
                                        BOOST_FUNCTION_TEMPLATE_ARGS
                                      >::type
-          actual_invoker_type;
+          invoker_type;
 
-        invoker = &actual_invoker_type::invoke;
-        this->manager = &boost::detail::function::trivial_manager<FunctionObj>::get;
-        this->functor =
-          this->manager(
-            boost::detail::function::make_any_pointer(
+        invoker = &invoker_type::invoke;
+        function_base::manager = &detail::function::trivial_manager;
+        function_base::functor =
+          function_base::manager(
+            detail::function::make_any_pointer(
               const_cast<FunctionObj*>(f.get_pointer())),
-            boost::detail::function::clone_functor_tag);
+            detail::function::clone_functor_tag);
       }
     }
 
     template<typename FunctionObj>
-    void assign_to(FunctionObj, boost::detail::function::stateless_function_obj_tag)
+    void assign_to(FunctionObj, detail::function::stateless_function_obj_tag)
     {
       typedef
-          typename boost::detail::function::
+          typename detail::function::
                      BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER<
                        FunctionObj,
                        R BOOST_FUNCTION_COMMA
                        BOOST_FUNCTION_TEMPLATE_ARGS
                      >::type
-          actual_invoker_type;
-      invoker = &actual_invoker_type::invoke;
-      this->manager = &boost::detail::function::trivial_manager<FunctionObj>::get;
-      this->functor = boost::detail::function::make_any_pointer(this);
+          invoker_type;
+      invoker = &invoker_type::invoke;
+      function_base::manager = &detail::function::trivial_manager;
+      function_base::functor = detail::function::make_any_pointer(this);
     }
 
-    typedef result_type (*invoker_type)(boost::detail::function::any_pointer
-                                        BOOST_FUNCTION_COMMA
-                                        BOOST_FUNCTION_TEMPLATE_ARGS);
+    typedef internal_result_type (*invoker_type)(detail::function::any_pointer
+                                                 BOOST_FUNCTION_COMMA
+                                                 BOOST_FUNCTION_TEMPLATE_ARGS);
 
     invoker_type invoker;
   };
@@ -560,47 +561,9 @@ namespace boost {
     f1.swap(f2);
   }
 
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-  template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
-           typename Allocator>
-  typename BOOST_FUNCTION_FUNCTION<
-      R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS, 
-      Allocator>::result_type
-   BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS,
-
-                           Allocator>
-  ::operator()(BOOST_FUNCTION_PARMS) const
-  {
-    if (this->empty())
-      boost::throw_exception(bad_function_call());
-    
-    return invoker(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
-  }
-#endif
-
-// Poison comparisons between boost::function objects of the same type.
-template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
-         typename Allocator>
-  void operator==(const BOOST_FUNCTION_FUNCTION<
-                          R BOOST_FUNCTION_COMMA
-                          BOOST_FUNCTION_TEMPLATE_ARGS ,
-                          Allocator>&,
-                  const BOOST_FUNCTION_FUNCTION<
-                          R BOOST_FUNCTION_COMMA
-                          BOOST_FUNCTION_TEMPLATE_ARGS ,
-                  Allocator>&);
-template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
-         typename Allocator>
-  void operator!=(const BOOST_FUNCTION_FUNCTION<
-                          R BOOST_FUNCTION_COMMA
-                          BOOST_FUNCTION_TEMPLATE_ARGS ,
-                          Allocator>&,
-                  const BOOST_FUNCTION_FUNCTION<
-                          R BOOST_FUNCTION_COMMA
-                          BOOST_FUNCTION_TEMPLATE_ARGS ,
-                  Allocator>&);
-
-#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
+#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                         \
+ && !defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                              \
+ && (BOOST_STRICT_CONFIG || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
 
 #if BOOST_FUNCTION_NUM_ARGS == 0
 #define BOOST_FUNCTION_PARTIAL_SPEC R (void)
@@ -628,10 +591,10 @@ public:
 
   template<typename Functor>
   function(Functor f
-#ifndef BOOST_NO_SFINAE
-           ,typename enable_if_c<
-                            (boost::type_traits::ice_not<
-                          (is_integral<Functor>::value)>::value),
+#ifndef BOOST_FUNCTION_NO_ENABLE_IF
+           ,typename detail::function::enable_if<
+                            (::boost::type_traits::ice_not<
+                          (is_same<Functor, int>::value)>::value),
                        int>::type = 0
 #endif
            ) :
@@ -639,7 +602,7 @@ public:
   {
   }
 
-#ifndef BOOST_NO_SFINAE
+#ifndef BOOST_FUNCTION_NO_ENABLE_IF
   function(clear_type*) : base_type() {}
 #endif
 
@@ -654,10 +617,10 @@ public:
   }
 
   template<typename Functor>
-#ifndef BOOST_NO_SFINAE
-  typename enable_if_c<
-                            (boost::type_traits::ice_not<
-                         (is_integral<Functor>::value)>::value),
+#ifndef BOOST_FUNCTION_NO_ENABLE_IF
+  typename detail::function::enable_if<
+                            (::boost::type_traits::ice_not<
+                         (is_same<Functor, int>::value)>::value),
                       self_type&>::type
 #else
   self_type&
@@ -668,7 +631,7 @@ public:
     return *this;
   }
 
-#ifndef BOOST_NO_SFINAE
+#ifndef BOOST_FUNCTION_NO_ENABLE_IF
   self_type& operator=(clear_type*)
   {
     this->clear();
@@ -709,5 +672,3 @@ public:
 #undef BOOST_FUNCTION_ARGS
 #undef BOOST_FUNCTION_ARG_TYPE
 #undef BOOST_FUNCTION_ARG_TYPES
-#undef BOOST_FUNCTION_VOID_RETURN_TYPE
-#undef BOOST_FUNCTION_RETURN

include/boost/function/gen_function_N.pl

@@ -2,10 +2,16 @@
 #
 # Boost.Function library
 #
-# Copyright Douglas Gregor 2001-2003. Use, modification and
-# distribution is subject to 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)
+# Copyright (C) 2001-2003 Doug Gregor (gregod@cs.rpi.edu)
+#
+# Permission to copy, use, sell and distribute this software is granted
+# provided this copyright notice appears in all copies.
+# Permission to modify the code and to distribute modified code is granted
+# provided this copyright notice appears in all copies, and a notice
+# that the code was modified is included with the copyright notice.
+#
+# This software is provided "as is" without express or implied warranty,
+# and with no claim as to its suitability for any purpose.
 #
 # For more information, see http://www.boost.org
 use English;

include/boost/function_equal.hpp

@@ -1,28 +0,0 @@
-//  Copyright Douglas Gregor 2004.
-//  Copyright 2005 Peter Dimov
-
-//  Use, modification and distribution is subject to
-//  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)
-
-// For more information, see http://www.boost.org
-#ifndef BOOST_FUNCTION_EQUAL_HPP
-#define BOOST_FUNCTION_EQUAL_HPP
-
-namespace boost {
-
-template<typename F, typename G>
-  bool function_equal_impl(const F& f, const G& g, long)
-  { return f == g; }
-
-// function_equal_impl needs to be unqualified to pick
-// user overloads on two-phase compilers
-
-template<typename F, typename G>
-  bool function_equal(const F& f, const G& g)
-  { return function_equal_impl(f, g, 0); }
-
-} // end namespace boost
-
-#endif // BOOST_FUNCTION_EQUAL_HPP

index.html

@@ -0,0 +1,9 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0; URL=../../doc/html/function.html">
+</head>
+<body>
+Automatic redirection failed, please go to
+<a href="../../doc/html/function.html">../../doc/html/function.html</a>
+</body>
+</html>

test/Jamfile

@@ -0,0 +1,69 @@
+# Function library
+
+# Copyright (C) 2001-2003 Douglas Gregor
+
+# Permission to copy, use, sell and distribute this software is granted 
+# provided this copyright notice appears in all copies. Permission to modify 
+# the code and to distribute modified code is granted provided this copyright 
+# notice appears in all copies, and a notice that the code was modified is 
+# included with the copyright notice. This software is provided "as is" 
+# without express or implied warranty, and with no claim as to its suitability 
+# for any purpose. 
+
+# For more information, see http://www.boost.org/
+
+
+# Testing Jamfile autogenerated from XML source
+subproject libs/function/test ;
+
+# bring in rules for testing
+SEARCH on testing.jam = $(BOOST_BUILD_PATH) ;
+include testing.jam ;
+
+# Make tests run by default.
+DEPENDS all : test ;
+
+{
+  # look in BOOST_ROOT for sources first, just in this Jamfile
+  local SEARCH_SOURCE = $(BOOST_ROOT) $(SEARCH_SOURCE) ;
+
+  test-suite function
+    : 
+  [ run libs/function/test/function_test.cpp :  :  :  : lib_function_test ]
+
+  [ run libs/function/test/function_n_test.cpp :  :  :  :  ]
+
+  [ run libs/function/test/allocator_test.cpp <lib>../../../libs/test/build/boost_test_exec_monitor :  :  :  :  ]
+
+  [ run libs/function/test/stateless_test.cpp <lib>../../../libs/test/build/boost_test_exec_monitor :  :  :  :  ]
+
+  [ run libs/function/test/lambda_test.cpp <lib>../../../libs/test/build/boost_test_exec_monitor :  :  :  :  ]
+
+  [ compile-fail libs/function/test/function_test_fail1.cpp :  :  :  :  ]
+
+  [ compile-fail libs/function/test/function_test_fail2.cpp :  :  :  :  ]
+
+  [ compile libs/function/test/function_30.cpp :  :  :  :  ] 
+
+  [ run libs/function/test/function_arith_cxx98.cpp :  :  :  :  ]
+
+  [ run libs/function/test/function_arith_portable.cpp :  :  :  :  ]
+
+  [ run libs/function/test/sum_avg_cxx98.cpp :  :  :  :  ]
+
+  [ run libs/function/test/sum_avg_portable.cpp :  :  :  :  ]
+
+  [ run libs/function/test/mem_fun_cxx98.cpp :  :  :  :  ]
+
+  [ run libs/function/test/mem_fun_portable.cpp :  :  :  :  ]
+
+  [ run libs/function/test/std_bind_cxx98.cpp :  :  :  :  ]
+
+  [ run libs/function/test/std_bind_portable.cpp :  :  :  :  ]
+
+  [ run libs/function/test/function_ref_cxx98.cpp :  :  :  :  ]
+
+  [ run libs/function/test/function_ref_portable.cpp :  :  :  :  ]
+ ;
+}
+      

test/allocator_test.cpp

@@ -0,0 +1,88 @@
+// Boost.Function library
+
+// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
+
+// For more information, see http://www.boost.org
+
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+#include <cassert>
+#include <functional>
+#include <boost/function.hpp>
+
+using namespace std;
+using namespace boost;
+
+static int alloc_count = 0;
+static int dealloc_count = 0;
+
+template<typename T>
+struct counting_allocator : public std::allocator<T>
+{
+  template<typename U>
+  struct rebind
+  {
+    typedef counting_allocator<U> other;
+  };
+
+  
+  T* allocate(std::size_t n)
+  {
+    alloc_count++;
+    return std::allocator<T>::allocate(n);
+  }
+
+  void deallocate(T* p, std::size_t n)
+  {
+    dealloc_count++;
+    std::allocator<T>::deallocate(p, n);
+  }
+};
+
+static int do_minus(int x, int y) { return x-y; }
+
+struct DoNothing
+{
+  void operator()() const {}
+};
+
+static void do_nothing() {}
+
+int
+test_main(int, char*[])
+{
+  function2<int, int, int, counting_allocator<int> > f; 
+  f = plus<int>();
+  f.clear();
+  BOOST_TEST(alloc_count == 1);
+  BOOST_TEST(dealloc_count == 1);
+
+  alloc_count = 0;
+  dealloc_count = 0;
+  f = &do_minus;
+  f.clear();
+
+  function0<void, counting_allocator<int> > fv;
+  alloc_count = 0;
+  dealloc_count = 0;
+  fv = DoNothing();
+  fv.clear();
+  BOOST_TEST(alloc_count == 1);
+  BOOST_TEST(dealloc_count == 1);
+  
+  alloc_count = 0;
+  dealloc_count = 0;
+  fv = &do_nothing;
+  fv.clear();
+
+  return 0;
+}

test/function_30.cpp

@@ -0,0 +1,31 @@
+// Boost.Function library
+
+// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
+
+// For more information, see http://www.boost.org
+
+// Make sure we don't try to redefine function2
+#include <boost/function/function2.hpp>
+
+// Define all Boost.Function class templates up to 30 arguments
+#define BOOST_FUNCTION_MAX_ARGS 30
+#include <boost/function.hpp>
+
+int main()
+{
+  boost::function0<float> f0;
+
+  boost::function30<float, int, int, int, int, int, int, int, int, int, int,
+                    int, int, int, int, int, int, int, int, int, int,
+                    int, int, int, int, int, int, int, int, int, int> f30;
+  return 0;
+}

test/function_arith_cxx98.cpp

@@ -0,0 +1,38 @@
+// Function library
+
+// Copyright (C) 2001-2003 Douglas Gregor
+
+// Permission to copy, use, sell and distribute this software is granted 
+// provided this copyright notice appears in all copies. Permission to modify 
+// the code and to distribute modified code is granted provided this copyright 
+// notice appears in all copies, and a notice that the code was modified is 
+// included with the copyright notice. This software is provided "as is" 
+// without express or implied warranty, and with no claim as to its 
+// suitability for any purpose. 
+
+// For more information, see http://www.boost.org/
+
+    
+#include <boost/function.hpp>
+#include <iostream>
+
+
+float mul_ints(int x, int y) { return ((float)x) * y; }
+struct int_div { 
+  float operator()(int x, int y) const { return ((float)x)/y; }; 
+};
+
+int main()
+{
+    boost::function<float (int x, int y)> f;
+    f = int_div();
+    std::cout << f(5, 3) << std::endl;
+    if (f)
+  std::cout << f(5, 3) << std::endl;
+else
+  std::cout << "f has no target, so it is unsafe to call" << std::endl;
+    f = 0;
+    f = &mul_ints;
+  
+    return 0;
+}

test/function_arith_portable.cpp

@@ -0,0 +1,36 @@
+// Function library
+
+// Copyright (C) 2001-2003 Douglas Gregor
+
+// Permission to copy, use, sell and distribute this software is granted 
+// provided this copyright notice appears in all copies. Permission to modify 
+// the code and to distribute modified code is granted provided this copyright 
+// notice appears in all copies, and a notice that the code was modified is 
+// included with the copyright notice. This software is provided "as is" 
+// without express or implied warranty, and with no claim as to its 
+// suitability for any purpose. 
+
+// For more information, see http://www.boost.org/
+
+    
+#include <boost/function.hpp>
+#include <iostream>
+
+float mul_ints(int x, int y) { return ((float)x) * y; }
+struct int_div { 
+  float operator()(int x, int y) const { return ((float)x)/y; }; 
+};
+int main()
+{
+    boost::function2<float, int, int> f;
+    f = int_div();
+    std::cout << f(5, 3) << std::endl;
+    if (f)
+  std::cout << f(5, 3) << std::endl;
+else
+  std::cout << "f has no target, so it is unsafe to call" << std::endl;
+    f = 0;
+    f = &mul_ints;
+
+    return 0;
+}

test/function_n_test.cpp

@@ -0,0 +1,653 @@
+// Boost.Function library
+
+// Copyright (C) 2001, 2002 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
+
+// For more information, see http://www.boost.org
+
+#include <boost/test/minimal.hpp>
+#include <boost/function.hpp>
+#include <functional>
+#include <cassert>
+#include <string>
+
+using namespace boost;
+using std::string;
+using std::negate;
+
+int global_int;
+
+struct write_five_obj { void operator()() const { global_int = 5; } };
+struct write_three_obj { int operator()() const { global_int = 3; return 7; }};
+static void write_five() { global_int = 5; }
+static void write_three() { global_int = 3; }
+struct generate_five_obj { int operator()() const { return 5; } };
+struct generate_three_obj { int operator()() const { return 3; } };
+static int generate_five() { return 5; }
+static int generate_three() { return 3; }
+static string identity_str(const string& s) { return s; }
+static string string_cat(const string& s1, const string& s2) { return s1+s2; }
+static int sum_ints(int x, int y) { return x+y; }
+
+struct write_const_1_nonconst_2
+{
+  void operator()() { global_int = 2; }
+  void operator()() const { global_int = 1; }
+};
+
+struct add_to_obj
+{
+  add_to_obj(int v) : value(v) {}
+
+  int operator()(int x) const { return value + x; }
+
+  int value;
+};
+
+static void
+test_zero_args()
+{
+  typedef function0<void> func_void_type;
+
+  write_five_obj five;
+  write_three_obj three;
+
+  // Default construction
+  func_void_type v1;
+  BOOST_TEST(v1.empty());
+
+  // Assignment to an empty function
+  v1 = five;
+  BOOST_TEST(!v1.empty());
+
+  // Invocation of a function
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 5);
+
+  // clear() method
+  v1.clear();
+  BOOST_TEST(!v1);
+
+  // Assignment to an empty function
+  v1 = three;
+  BOOST_TEST(!v1.empty());
+
+  // Invocation and self-assignment
+  global_int = 0;
+  v1 = v1;
+  v1();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a non-empty function
+  v1 = five;
+
+  // Invocation and self-assignment
+  global_int = 0;
+  v1 = (v1);
+  v1();
+  BOOST_TEST(global_int == 5);
+
+  // clear
+  v1 = 0;
+  BOOST_TEST(v1.empty());
+
+  // Assignment to an empty function from a free function
+  v1 = &write_five;
+  BOOST_TEST(!v1.empty());
+
+  // Invocation
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v1 = &write_three;
+  BOOST_TEST(!v1.empty());
+
+  // Invocation
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment
+  v1 = five;
+  BOOST_TEST(!v1.empty());
+
+  // Invocation
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v1 = write_three;
+  BOOST_TEST(!v1.empty());
+
+  // Invocation
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 3);
+
+  // Construction from another function (that is empty)
+  v1.clear();
+  func_void_type v2(v1);
+  BOOST_TEST(!v2? true : false);
+
+  // Assignment to an empty function
+  v2 = three;
+  BOOST_TEST(!v2.empty());
+
+  // Invocation
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a non-empty function
+  v2 = (five);
+
+  // Invocation
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 5);
+
+  v2.clear();
+  BOOST_TEST(v2.empty());
+
+  // Assignment to an empty function from a free function
+  v2 = (&write_five);
+  BOOST_TEST(v2? true : false);
+
+  // Invocation
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v2 = &write_three;
+  BOOST_TEST(!v2.empty());
+
+  // Invocation
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 3);
+
+  // Swapping
+  v1 = five;
+  swap(v1, v2);
+  v2();
+  BOOST_TEST(global_int == 5);
+  v1();
+  BOOST_TEST(global_int == 3);
+  swap(v1, v2);
+  v1.clear();
+
+  // Assignment
+  v2 = five;
+  BOOST_TEST(!v2.empty());
+
+  // Invocation
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v2 = &write_three;
+  BOOST_TEST(!v2.empty());
+
+  // Invocation
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a function from an empty function
+  v2 = v1;
+  BOOST_TEST(v2.empty());
+
+  // Assignment to a function from a function with a functor
+  v1 = three;
+  v2 = v1;
+  BOOST_TEST(!v1.empty());
+  BOOST_TEST(!v2.empty());
+
+  // Invocation
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 3);
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 3);
+
+  // Assign to a function from a function with a function
+  v2 = &write_five;
+  v1 = v2;
+  BOOST_TEST(!v1.empty());
+  BOOST_TEST(!v2.empty());
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 5);
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 5);
+
+  // Construct a function given another function containing a function
+  func_void_type v3(v1);
+
+  // Invocation of a function
+  global_int = 0;
+  v3();
+  BOOST_TEST(global_int == 5);
+
+  // clear() method
+  v3.clear();
+  BOOST_TEST(!v3? true : false);
+
+  // Assignment to an empty function
+  v3 = three;
+  BOOST_TEST(!v3.empty());
+
+  // Invocation
+  global_int = 0;
+  v3();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a non-empty function
+  v3 = five;
+
+  // Invocation
+  global_int = 0;
+  v3();
+  BOOST_TEST(global_int == 5);
+
+  // clear()
+  v3.clear();
+  BOOST_TEST(v3.empty());
+
+  // Assignment to an empty function from a free function
+  v3 = &write_five;
+  BOOST_TEST(!v3.empty());
+
+  // Invocation
+  global_int = 0;
+  v3();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v3 = &write_three;
+  BOOST_TEST(!v3.empty());
+
+  // Invocation
+  global_int = 0;
+  v3();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment
+  v3 = five;
+  BOOST_TEST(!v3.empty());
+
+  // Invocation
+  global_int = 0;
+  v3();
+  BOOST_TEST(global_int == 5);
+
+  // Construction of a function from a function containing a functor
+  func_void_type v4(v3);
+
+  // Invocation of a function
+  global_int = 0;
+  v4();
+  BOOST_TEST(global_int == 5);
+
+  // clear() method
+  v4.clear();
+  BOOST_TEST(v4.empty());
+
+  // Assignment to an empty function
+  v4 = three;
+  BOOST_TEST(!v4.empty());
+
+  // Invocation
+  global_int = 0;
+  v4();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a non-empty function
+  v4 = five;
+
+  // Invocation
+  global_int = 0;
+  v4();
+  BOOST_TEST(global_int == 5);
+
+  // clear()
+  v4.clear();
+  BOOST_TEST(v4.empty());
+
+  // Assignment to an empty function from a free function
+  v4 = &write_five;
+  BOOST_TEST(!v4.empty());
+
+  // Invocation
+  global_int = 0;
+  v4();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v4 = &write_three;
+  BOOST_TEST(!v4.empty());
+
+  // Invocation
+  global_int = 0;
+  v4();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment
+  v4 = five;
+  BOOST_TEST(!v4.empty());
+
+  // Invocation
+  global_int = 0;
+  v4();
+  BOOST_TEST(global_int == 5);
+
+  // Construction of a function from a functor
+  func_void_type v5(five);
+
+  // Invocation of a function
+  global_int = 0;
+  v5();
+  BOOST_TEST(global_int == 5);
+
+  // clear() method
+  v5.clear();
+  BOOST_TEST(v5.empty());
+
+  // Assignment to an empty function
+  v5 = three;
+  BOOST_TEST(!v5.empty());
+
+  // Invocation
+  global_int = 0;
+  v5();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a non-empty function
+  v5 = five;
+
+  // Invocation
+  global_int = 0;
+  v5();
+  BOOST_TEST(global_int == 5);
+
+  // clear()
+  v5.clear();
+  BOOST_TEST(v5.empty());
+
+  // Assignment to an empty function from a free function
+  v5 = &write_five;
+  BOOST_TEST(!v5.empty());
+
+  // Invocation
+  global_int = 0;
+  v5();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v5 = &write_three;
+  BOOST_TEST(!v5.empty());
+
+  // Invocation
+  global_int = 0;
+  v5();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment
+  v5 = five;
+  BOOST_TEST(!v5.empty());
+
+  // Invocation
+  global_int = 0;
+  v5();
+  BOOST_TEST(global_int == 5);
+
+  // Construction of a function from a function
+  func_void_type v6(&write_five);
+
+  // Invocation of a function
+  global_int = 0;
+  v6();
+  BOOST_TEST(global_int == 5);
+
+  // clear() method
+  v6.clear();
+  BOOST_TEST(v6.empty());
+
+  // Assignment to an empty function
+  v6 = three;
+  BOOST_TEST(!v6.empty());
+
+  // Invocation
+  global_int = 0;
+  v6();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a non-empty function
+  v6 = five;
+
+  // Invocation
+  global_int = 0;
+  v6();
+  BOOST_TEST(global_int == 5);
+
+  // clear()
+  v6.clear();
+  BOOST_TEST(v6.empty());
+
+  // Assignment to an empty function from a free function
+  v6 = &write_five;
+  BOOST_TEST(!v6.empty());
+
+  // Invocation
+  global_int = 0;
+  v6();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v6 = &write_three;
+  BOOST_TEST(!v6.empty());
+
+  // Invocation
+  global_int = 0;
+  v6();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment
+  v6 = five;
+  BOOST_TEST(!v6.empty());
+
+  // Invocation
+  global_int = 0;
+  v6();
+  BOOST_TEST(global_int == 5);
+
+  // Const vs. non-const
+  write_const_1_nonconst_2 one_or_two;
+  const function0<void> v7(one_or_two);
+  function0<void> v8(one_or_two);
+
+  global_int = 0;
+  v7();
+  BOOST_TEST(global_int == 2);
+
+  global_int = 0;
+  v8();
+  BOOST_TEST(global_int == 2);
+
+  // Test construction from 0 and comparison to 0
+  func_void_type v9(0);
+  BOOST_TEST(v9 == 0);
+# if !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540 || defined(BOOST_STRICT_CONFIG)
+  BOOST_TEST(0 == v9);
+#else
+  BOOST_TEST(v9.empty());
+#endif
+
+  // Test return values
+  typedef function0<int> func_int_type;
+  generate_five_obj gen_five;
+  generate_three_obj gen_three;
+
+  func_int_type i0(gen_five);
+
+  BOOST_TEST(i0() == 5);
+  i0 = gen_three;
+  BOOST_TEST(i0() == 3);
+  i0 = &generate_five;
+  BOOST_TEST(i0() == 5);
+  i0 = &generate_three;
+  BOOST_TEST(i0() == 3);
+  BOOST_TEST(i0? true : false);
+  i0.clear();
+  BOOST_TEST(!i0? true : false);
+
+  // Test return values with compatible types
+  typedef function0<long> func_long_type;
+  func_long_type i1(gen_five);
+
+  BOOST_TEST(i1() == 5);
+  i1 = gen_three;
+  BOOST_TEST(i1() == 3);
+  i1 = &generate_five;
+  BOOST_TEST(i1() == 5);
+  i1 = &generate_three;
+  BOOST_TEST(i1() == 3);
+  BOOST_TEST(i1? true : false);
+  i1.clear();
+  BOOST_TEST(!i1? true : false);
+}
+
+static void
+test_one_arg()
+{
+  negate<int> neg;
+
+  function1<int, int> f1(neg);
+  BOOST_TEST(f1(5) == -5);
+
+  function1<string, string> id(&identity_str);
+  BOOST_TEST(id("str") == "str");
+
+  function1<std::string, const char*> id2(&identity_str);
+  BOOST_TEST(id2("foo") == "foo");
+
+  add_to_obj add_to(5);
+  function1<int, int> f2(add_to);
+  BOOST_TEST(f2(3) == 8);
+
+  const function1<int, int> cf2(add_to);
+  BOOST_TEST(cf2(3) == 8);
+}
+
+static void
+test_two_args()
+{
+  function2<string, const string&, const string&> cat(&string_cat);
+  BOOST_TEST(cat("str", "ing") == "string");
+
+  function2<int, short, short> sum(&sum_ints);
+  BOOST_TEST(sum(2, 3) == 5);
+}
+
+static void
+test_emptiness()
+{
+  function0<float> f1;
+  BOOST_TEST(f1.empty());
+
+  function0<float> f2;
+  f2 = f1;
+  BOOST_TEST(f2.empty());
+
+  function0<double> f3;
+  f3 = f2;
+  BOOST_TEST(f3.empty());
+}
+
+struct X {
+  X(int v) : value(v) {}
+
+  int twice() const { return 2*value; }
+  int plus(int v) { return value + v; }
+
+  int value;
+};
+
+static void
+test_member_functions()
+{
+
+  boost::function1<int, X*> f1(&X::twice);
+
+  X one(1);
+  X five(5);
+
+  BOOST_TEST(f1(&one) == 2);
+  BOOST_TEST(f1(&five) == 10);
+
+  boost::function1<int, X*> f1_2;
+  f1_2 = &X::twice;
+
+  BOOST_TEST(f1_2(&one) == 2);
+  BOOST_TEST(f1_2(&five) == 10);
+
+  boost::function2<int, X&, int> f2(&X::plus);
+  BOOST_TEST(f2(one, 3) == 4);
+  BOOST_TEST(f2(five, 4) == 9);
+}
+
+struct add_with_throw_on_copy {
+  int operator()(int x, int y) const { return x+y; }
+
+  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");
+  }
+
+  add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
+  {
+    throw std::runtime_error("But this CAN'T throw");
+  }
+};
+
+static void
+test_ref()
+{
+  add_with_throw_on_copy atc;
+  try {
+    boost::function2<int, int, int> f(ref(atc));
+    BOOST_TEST(f(1, 3) == 4);
+  }
+  catch(std::runtime_error e) {
+    BOOST_ERROR("Nonthrowing constructor threw an exception");
+  }
+}
+
+int test_main(int, char* [])
+{
+  test_zero_args();
+  test_one_arg();
+  test_two_args();
+  test_emptiness();
+  test_member_functions();
+  test_ref();
+  return 0;
+}

test/function_ref_cxx98.cpp

@@ -0,0 +1,31 @@
+// Function library
+
+// Copyright (C) 2001-2003 Douglas Gregor
+
+// Permission to copy, use, sell and distribute this software is granted 
+// provided this copyright notice appears in all copies. Permission to modify 
+// the code and to distribute modified code is granted provided this copyright 
+// notice appears in all copies, and a notice that the code was modified is 
+// included with the copyright notice. This software is provided "as is" 
+// without express or implied warranty, and with no claim as to its 
+// suitability for any purpose. 
+
+// For more information, see http://www.boost.org/
+
+
+#include <boost/function.hpp>
+#include <iostream>
+
+
+struct stateful_type { int operator()(int) const { return 0; } };
+
+int main()
+{
+    stateful_type a_function_object;
+  boost::function<int (int)> f;
+  f = boost::ref(a_function_object);
+
+  boost::function<int (int)> f2(f);
+
+    return 0;
+}

test/function_ref_portable.cpp

@@ -0,0 +1,31 @@
+// Function library
+
+// Copyright (C) 2001-2003 Douglas Gregor
+
+// Permission to copy, use, sell and distribute this software is granted 
+// provided this copyright notice appears in all copies. Permission to modify 
+// the code and to distribute modified code is granted provided this copyright 
+// notice appears in all copies, and a notice that the code was modified is 
+// included with the copyright notice. This software is provided "as is" 
+// without express or implied warranty, and with no claim as to its 
+// suitability for any purpose. 
+
+// For more information, see http://www.boost.org/
+
+
+#include <boost/function.hpp>
+#include <iostream>
+
+
+struct stateful_type { int operator()(int) const { return 0; } };
+
+int main()
+{
+    stateful_type a_function_object;
+  boost::function1<int, int> f;
+  f = boost::ref(a_function_object);
+
+  boost::function1<int, int> f2(f);
+
+    return 0;
+}

test/function_test.cpp

@@ -0,0 +1,754 @@
+// Boost.Function library
+
+// Copyright (C) 2001, 2002 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
+
+// For more information, see http://www.boost.org
+
+#include <boost/test/minimal.hpp>
+#include <boost/function.hpp>
+#include <functional>
+#include <cassert>
+#include <string>
+#include <utility>
+
+using namespace boost;
+using namespace std;
+
+int global_int;
+
+struct write_five_obj { void operator()() const { global_int = 5; } };
+struct write_three_obj { int operator()() const { global_int = 3; return 7; }};
+static void write_five() { global_int = 5; }
+static void write_three() { global_int = 3; }
+struct generate_five_obj { int operator()() const { return 5; } };
+struct generate_three_obj { int operator()() const { return 3; } };
+static int generate_five() { return 5; }
+static int generate_three() { return 3; }
+static string identity_str(const string& s) { return s; }
+static string string_cat(const string& s1, const string& s2) { return s1+s2; }
+static int sum_ints(int x, int y) { return x+y; }
+
+struct write_const_1_nonconst_2
+{
+  void operator()() { global_int = 2; }
+  void operator()() const { global_int = 1; }
+};
+
+struct add_to_obj
+{
+  add_to_obj(int v) : value(v) {}
+
+  int operator()(int x) const { return value + x; }
+
+  int value;
+};
+
+static void
+test_zero_args()
+{
+  typedef function<void ()> func_void_type;
+
+  write_five_obj five;
+  write_three_obj three;
+
+  // Default construction
+  func_void_type v1;
+  BOOST_TEST(v1.empty());
+
+  // Assignment to an empty function
+  v1 = five;
+  BOOST_TEST(v1 != 0);
+
+  // Invocation of a function
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 5);
+
+  // clear() method
+  v1.clear();
+  BOOST_TEST(v1 == 0);
+
+  // Assignment to an empty function
+  v1 = three;
+  BOOST_TEST(!v1.empty());
+
+  // Invocation and self-assignment
+  global_int = 0;
+  v1 = v1;
+  v1();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a non-empty function
+  v1 = five;
+
+  // Invocation and self-assignment
+  global_int = 0;
+  v1 = (v1);
+  v1();
+  BOOST_TEST(global_int == 5);
+
+  // clear
+  v1 = 0;
+  BOOST_TEST(0 == v1);
+
+  // Assignment to an empty function from a free function
+  v1 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
+  BOOST_TEST(0 != v1);
+
+  // Invocation
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v1 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
+  BOOST_TEST(!v1.empty());
+
+  // Invocation
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment
+  v1 = five;
+  BOOST_TEST(!v1.empty());
+
+  // Invocation
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v1 = &write_three;
+  BOOST_TEST(!v1.empty());
+
+  // Invocation
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 3);
+
+  // Construction from another function (that is empty)
+  v1.clear();
+  func_void_type v2(v1);
+  BOOST_TEST(!v2? true : false);
+
+  // Assignment to an empty function
+  v2 = three;
+  BOOST_TEST(!v2.empty());
+
+  // Invocation
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a non-empty function
+  v2 = (five);
+
+  // Invocation
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 5);
+
+  v2.clear();
+  BOOST_TEST(v2.empty());
+
+  // Assignment to an empty function from a free function
+  v2 = (BOOST_FUNCTION_TARGET_FIX(&) write_five);
+  BOOST_TEST(v2? true : false);
+
+  // Invocation
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v2 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
+  BOOST_TEST(!v2.empty());
+
+  // Invocation
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 3);
+
+  // Swapping
+  v1 = five;
+  swap(v1, v2);
+  v2();
+  BOOST_TEST(global_int == 5);
+  v1();
+  BOOST_TEST(global_int == 3);
+  swap(v1, v2);
+  v1.clear();
+
+  // Assignment
+  v2 = five;
+  BOOST_TEST(!v2.empty());
+
+  // Invocation
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v2 = &write_three;
+  BOOST_TEST(!v2.empty());
+
+  // Invocation
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a function from an empty function
+  v2 = v1;
+  BOOST_TEST(v2.empty());
+
+  // Assignment to a function from a function with a functor
+  v1 = three;
+  v2 = v1;
+  BOOST_TEST(!v1.empty());
+  BOOST_TEST(!v2.empty());
+
+  // Invocation
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 3);
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 3);
+
+  // Assign to a function from a function with a function
+  v2 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
+  v1 = v2;
+  BOOST_TEST(!v1.empty());
+  BOOST_TEST(!v2.empty());
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 5);
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 5);
+
+  // Construct a function given another function containing a function
+  func_void_type v3(v1);
+
+  // Invocation of a function
+  global_int = 0;
+  v3();
+  BOOST_TEST(global_int == 5);
+
+  // clear() method
+  v3.clear();
+  BOOST_TEST(!v3? true : false);
+
+  // Assignment to an empty function
+  v3 = three;
+  BOOST_TEST(!v3.empty());
+
+  // Invocation
+  global_int = 0;
+  v3();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a non-empty function
+  v3 = five;
+
+  // Invocation
+  global_int = 0;
+  v3();
+  BOOST_TEST(global_int == 5);
+
+  // clear()
+  v3.clear();
+  BOOST_TEST(v3.empty());
+
+  // Assignment to an empty function from a free function
+  v3 = &write_five;
+  BOOST_TEST(!v3.empty());
+
+  // Invocation
+  global_int = 0;
+  v3();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v3 = &write_three;
+  BOOST_TEST(!v3.empty());
+
+  // Invocation
+  global_int = 0;
+  v3();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment
+  v3 = five;
+  BOOST_TEST(!v3.empty());
+
+  // Invocation
+  global_int = 0;
+  v3();
+  BOOST_TEST(global_int == 5);
+
+  // Construction of a function from a function containing a functor
+  func_void_type v4(v3);
+
+  // Invocation of a function
+  global_int = 0;
+  v4();
+  BOOST_TEST(global_int == 5);
+
+  // clear() method
+  v4.clear();
+  BOOST_TEST(v4.empty());
+
+  // Assignment to an empty function
+  v4 = three;
+  BOOST_TEST(!v4.empty());
+
+  // Invocation
+  global_int = 0;
+  v4();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a non-empty function
+  v4 = five;
+
+  // Invocation
+  global_int = 0;
+  v4();
+  BOOST_TEST(global_int == 5);
+
+  // clear()
+  v4.clear();
+  BOOST_TEST(v4.empty());
+
+  // Assignment to an empty function from a free function
+  v4 = &write_five;
+  BOOST_TEST(!v4.empty());
+
+  // Invocation
+  global_int = 0;
+  v4();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v4 = &write_three;
+  BOOST_TEST(!v4.empty());
+
+  // Invocation
+  global_int = 0;
+  v4();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment
+  v4 = five;
+  BOOST_TEST(!v4.empty());
+
+  // Invocation
+  global_int = 0;
+  v4();
+  BOOST_TEST(global_int == 5);
+
+  // Construction of a function from a functor
+  func_void_type v5(five);
+
+  // Invocation of a function
+  global_int = 0;
+  v5();
+  BOOST_TEST(global_int == 5);
+
+  // clear() method
+  v5.clear();
+  BOOST_TEST(v5.empty());
+
+  // Assignment to an empty function
+  v5 = three;
+  BOOST_TEST(!v5.empty());
+
+  // Invocation
+  global_int = 0;
+  v5();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a non-empty function
+  v5 = five;
+
+  // Invocation
+  global_int = 0;
+  v5();
+  BOOST_TEST(global_int == 5);
+
+  // clear()
+  v5.clear();
+  BOOST_TEST(v5.empty());
+
+  // Assignment to an empty function from a free function
+  v5 = &write_five;
+  BOOST_TEST(!v5.empty());
+
+  // Invocation
+  global_int = 0;
+  v5();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v5 = &write_three;
+  BOOST_TEST(!v5.empty());
+
+  // Invocation
+  global_int = 0;
+  v5();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment
+  v5 = five;
+  BOOST_TEST(!v5.empty());
+
+  // Invocation
+  global_int = 0;
+  v5();
+  BOOST_TEST(global_int == 5);
+
+  // Construction of a function from a function
+  func_void_type v6(&write_five);
+
+  // Invocation of a function
+  global_int = 0;
+  v6();
+  BOOST_TEST(global_int == 5);
+
+  // clear() method
+  v6.clear();
+  BOOST_TEST(v6.empty());
+
+  // Assignment to an empty function
+  v6 = three;
+  BOOST_TEST(!v6.empty());
+
+  // Invocation
+  global_int = 0;
+  v6();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a non-empty function
+  v6 = five;
+
+  // Invocation
+  global_int = 0;
+  v6();
+  BOOST_TEST(global_int == 5);
+
+  // clear()
+  v6.clear();
+  BOOST_TEST(v6.empty());
+
+  // Assignment to an empty function from a free function
+  v6 = &write_five;
+  BOOST_TEST(!v6.empty());
+
+  // Invocation
+  global_int = 0;
+  v6();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v6 = &write_three;
+  BOOST_TEST(!v6.empty());
+
+  // Invocation
+  global_int = 0;
+  v6();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment
+  v6 = five;
+  BOOST_TEST(!v6.empty());
+
+  // Invocation
+  global_int = 0;
+  v6();
+  BOOST_TEST(global_int == 5);
+
+  // Const vs. non-const
+  write_const_1_nonconst_2 one_or_two;
+  const function<void ()> v7(one_or_two);
+  function<void ()> v8(one_or_two);
+
+  global_int = 0;
+  v7();
+  BOOST_TEST(global_int == 2);
+
+  global_int = 0;
+  v8();
+  BOOST_TEST(global_int == 2);
+
+  // Test construction from 0 and comparison to 0
+  func_void_type v9(0);
+  BOOST_TEST(v9 == 0);
+  BOOST_TEST(0 == v9);
+
+  // Test return values
+  typedef function<int ()> func_int_type;
+  generate_five_obj gen_five;
+  generate_three_obj gen_three;
+
+  func_int_type i0(gen_five);
+
+  BOOST_TEST(i0() == 5);
+  i0 = gen_three;
+  BOOST_TEST(i0() == 3);
+  i0 = &generate_five;
+  BOOST_TEST(i0() == 5);
+  i0 = &generate_three;
+  BOOST_TEST(i0() == 3);
+  BOOST_TEST(i0? true : false);
+  i0.clear();
+  BOOST_TEST(!i0? true : false);
+
+  // Test return values with compatible types
+  typedef function<long ()> func_long_type;
+  func_long_type i1(gen_five);
+
+  BOOST_TEST(i1() == 5);
+  i1 = gen_three;
+  BOOST_TEST(i1() == 3);
+  i1 = &generate_five;
+  BOOST_TEST(i1() == 5);
+  i1 = &generate_three;
+  BOOST_TEST(i1() == 3);
+  BOOST_TEST(i1? true : false);
+  i1.clear();
+  BOOST_TEST(!i1? true : false);
+}
+
+static void
+test_one_arg()
+{
+  negate<int> neg;
+
+  function<int (int)> f1(neg);
+  BOOST_TEST(f1(5) == -5);
+
+  function<string (string)> id(&identity_str);
+  BOOST_TEST(id("str") == "str");
+
+  function<string (const char*)> id2(&identity_str);
+  BOOST_TEST(id2("foo") == "foo");
+
+  add_to_obj add_to(5);
+  function<int (int)> f2(add_to);
+  BOOST_TEST(f2(3) == 8);
+
+  const function<int (int)> cf2(add_to);
+  BOOST_TEST(cf2(3) == 8);
+}
+
+static void
+test_two_args()
+{
+  function<string (const string&, const string&)> cat(&string_cat);
+  BOOST_TEST(cat("str", "ing") == "string");
+
+  function<int (short, short)> sum(&sum_ints);
+  BOOST_TEST(sum(2, 3) == 5);
+}
+
+static void
+test_emptiness()
+{
+  function<float ()> f1;
+  BOOST_TEST(f1.empty());
+
+  function<float ()> f2;
+  f2 = f1;
+  BOOST_TEST(f2.empty());
+
+  function<double ()> f3;
+  f3 = f2;
+  BOOST_TEST(f3.empty());
+}
+
+struct X {
+  X(int v) : value(v) {}
+
+  int twice() const { return 2*value; }
+  int plus(int v) { return value + v; }
+
+  int value;
+};
+
+static void
+test_member_functions()
+{
+  boost::function<int (X*)> f1(&X::twice);
+
+  X one(1);
+  X five(5);
+
+  BOOST_TEST(f1(&one) == 2);
+  BOOST_TEST(f1(&five) == 10);
+
+  boost::function<int (X*)> f1_2;
+  f1_2 = &X::twice;
+
+  BOOST_TEST(f1_2(&one) == 2);
+  BOOST_TEST(f1_2(&five) == 10);
+
+  boost::function<int (X&, int)> f2(&X::plus);
+  BOOST_TEST(f2(one, 3) == 4);
+  BOOST_TEST(f2(five, 4) == 9);
+}
+
+struct add_with_throw_on_copy {
+  int operator()(int x, int y) const { return x+y; }
+
+  add_with_throw_on_copy() {}
+
+  add_with_throw_on_copy(const add_with_throw_on_copy&)
+  {
+    throw runtime_error("But this CAN'T throw");
+  }
+
+  add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
+  {
+    throw runtime_error("But this CAN'T throw");
+  }
+};
+
+static void
+test_ref()
+{
+  add_with_throw_on_copy atc;
+  try {
+    boost::function<int (int, int)> f(ref(atc));
+    BOOST_TEST(f(1, 3) == 4);
+  }
+  catch(runtime_error e) {
+    BOOST_ERROR("Nonthrowing constructor threw an exception");
+  }
+}
+
+static int alloc_count = 0;
+static int dealloc_count = 0;
+
+template<typename T>
+struct counting_allocator : public allocator<T>
+{
+  template<typename U>
+  struct rebind
+  {
+    typedef counting_allocator<U> other;
+  };
+
+
+  T* allocate(size_t n)
+  {
+    alloc_count++;
+    return allocator<T>::allocate(n);
+  }
+
+  void deallocate(T* p, size_t n)
+  {
+    dealloc_count++;
+    allocator<T>::deallocate(p, n);
+  }
+};
+
+static int do_minus(int x, int y) { return x-y; }
+
+struct DoNothing
+{
+  void operator()() const {}
+};
+
+static void do_nothing() {}
+
+static void test_allocator()
+{
+#ifndef BOOST_NO_STD_ALLOCATOR
+  boost::function<int (int, int), counting_allocator<int> > f;
+  f = plus<int>();
+  f.clear();
+  BOOST_TEST(alloc_count == 1);
+  BOOST_TEST(dealloc_count == 1);
+
+  alloc_count = 0;
+  dealloc_count = 0;
+  f = &do_minus;
+  f.clear();
+
+  boost::function<void (), counting_allocator<int> > fv;
+  alloc_count = 0;
+  dealloc_count = 0;
+  fv = DoNothing();
+  fv.clear();
+  BOOST_TEST(alloc_count == 1);
+  BOOST_TEST(dealloc_count == 1);
+
+  alloc_count = 0;
+  dealloc_count = 0;
+  fv = &do_nothing;
+  fv.clear();
+#endif // ndef BOOST_NO_STD_ALLOCATOR
+}
+
+static void test_exception()
+{
+  boost::function<int (int, int)> f;
+  try {
+    f(5, 4);
+    BOOST_TEST(false);
+  }
+  catch(boost::bad_function_call) {
+    // okay
+  }
+}
+
+typedef boost::function< void * (void * reader) > reader_type;
+typedef std::pair<int, reader_type> mapped_type;
+
+static void test_implicit()
+{
+  mapped_type m;
+  m = mapped_type();
+}
+
+static void test_call_obj(boost::function<int (int, int)> f)
+{
+  assert(!f.empty());
+}
+
+static void test_call_cref(const boost::function<int (int, int)>& f)
+{
+  assert(!f.empty());
+}
+
+static void test_call()
+{
+  test_call_obj(std::plus<int>());
+  test_call_cref(std::plus<int>());
+}
+
+int test_main(int, char* [])
+{
+  test_zero_args();
+  test_one_arg();
+  test_two_args();
+  test_emptiness();
+  test_member_functions();
+  test_ref();
+  test_allocator();
+  test_exception();
+  test_implicit();
+  test_call();
+
+  return 0;
+}

test/function_test_fail1.cpp

@@ -0,0 +1,35 @@
+// Boost.Function library
+
+// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
+
+// For more information, see http://www.boost.org
+
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+#include <boost/function.hpp>
+
+using namespace std;
+using namespace boost;
+
+int
+test_main(int, char*[])
+{
+  function0<int> f1;
+  function0<int> f2;
+
+  if (f1 == f2) {
+  }
+
+  BOOST_CRITICAL_ERROR("This should not have compiled.");
+
+  return 0;
+}

test/function_test_fail2.cpp

@@ -0,0 +1,34 @@
+// Boost.Function library
+
+// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
+
+// For more information, see http://www.boost.org
+
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+#include <boost/function.hpp>
+
+using namespace std;
+using namespace boost;
+
+static int bad_fn(float f) { return static_cast<int>(f); }
+
+int
+test_main(int, char*[])
+{
+  function0<int> f1;
+  f1 = bad_fn;
+
+  BOOST_CRITICAL_ERROR("This should not have compiled.");
+
+  return 0;
+}

test/lambda_test.cpp

@@ -0,0 +1,44 @@
+// Boost.Function library
+
+// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
+
+// For more information, see http://www.boost.org
+
+#include <iostream>
+#include <cstdlib>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/lambda/lambda.hpp>
+#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)
+{
+  return abs (static_cast<int>((arg2 ? arg1 : 2 * arg1) * arg3));
+}
+
+int test_main(int, char*[])
+{
+  function <unsigned(bool, double)> f1 = bind(func_impl, 15, _1, _2);
+  function <unsigned(double)>       f2 = bind(f1, false, _1);
+  function <unsigned()>             f3 = bind(f2, 4.0);
+
+  f3();
+
+  return 0;
+}
+

test/mem_fun_cxx98.cpp

@@ -0,0 +1,35 @@
+// Function library
+
+// Copyright (C) 2001-2003 Douglas Gregor
+
+// Permission to copy, use, sell and distribute this software is granted 
+// provided this copyright notice appears in all copies. Permission to modify 
+// the code and to distribute modified code is granted provided this copyright 
+// notice appears in all copies, and a notice that the code was modified is 
+// included with the copyright notice. This software is provided "as is" 
+// without express or implied warranty, and with no claim as to its 
+// suitability for any purpose. 
+
+// For more information, see http://www.boost.org/
+
+    
+#include <boost/function.hpp>
+#include <iostream>
+#include <functional>
+
+struct X {
+  int foo(int);
+};
+int X::foo(int x) { return -x; }
+
+int main()
+{
+    boost::function<int (X*, int)> f;
+
+f = &X::foo;
+  
+X x;
+f(&x, 5);
+
+    return 0;
+}

test/mem_fun_portable.cpp

@@ -0,0 +1,35 @@
+// Function library
+
+// Copyright (C) 2001-2003 Douglas Gregor
+
+// Permission to copy, use, sell and distribute this software is granted 
+// provided this copyright notice appears in all copies. Permission to modify 
+// the code and to distribute modified code is granted provided this copyright 
+// notice appears in all copies, and a notice that the code was modified is 
+// included with the copyright notice. This software is provided "as is" 
+// without express or implied warranty, and with no claim as to its 
+// suitability for any purpose. 
+
+// For more information, see http://www.boost.org/
+
+    
+#include <boost/function.hpp>
+#include <iostream>
+#include <functional>
+
+struct X {
+  int foo(int);
+};
+int X::foo(int x) { return -x; }
+
+int main()
+{
+    boost::function2<int, X*, int> f;
+
+f = &X::foo;
+  
+X x;
+f(&x, 5);
+
+    return 0;
+}

test/regression.cfg

@@ -0,0 +1,14 @@
+// Boost.Function regression test configuration file
+
+// From the boost/status directory, run
+// ./regression --tests ../libs/function/test/regression.cfg -o function.html
+
+
+run libs/function/test/allocator_test.cpp
+run libs/function/test/function_n_test.cpp
+run libs/function/test/function_test.cpp
+compile-fail libs/function/test/function_test_fail1.cpp
+compile-fail libs/function/test/function_test_fail2.cpp
+run libs/function/test/mixin_test.cpp
+run libs/function/test/policy_test.cpp
+run libs/function/test/stateless_test.cpp

test/stateless_test.cpp

@@ -0,0 +1,48 @@
+// Boost.Function library
+
+// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
+
+// For more information, see http://www.boost.org
+
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+#include <boost/function.hpp>
+#include <stdexcept>
+
+struct stateless_integer_add {
+  int operator()(int x, int y) const { return x+y; }
+
+  void* operator new(std::size_t, stateless_integer_add*)
+  {
+    throw std::runtime_error("Cannot allocate a stateless_integer_add");
+    return 0; // suppress warnings
+  }
+
+  void operator delete(void*, stateless_integer_add*) throw()
+  {
+  }
+};
+
+namespace boost {
+  template<>
+  struct is_stateless<stateless_integer_add> {
+    BOOST_STATIC_CONSTANT(bool, value = true);
+  };
+}
+
+int test_main(int, char*[])
+{
+  boost::function2<int, int, int> f;
+  f = stateless_integer_add();
+
+  return 0;
+}

test/std_bind_cxx98.cpp

@@ -0,0 +1,34 @@
+// Function library
+
+// Copyright (C) 2001-2003 Douglas Gregor
+
+// Permission to copy, use, sell and distribute this software is granted 
+// provided this copyright notice appears in all copies. Permission to modify 
+// the code and to distribute modified code is granted provided this copyright 
+// notice appears in all copies, and a notice that the code was modified is 
+// included with the copyright notice. This software is provided "as is" 
+// without express or implied warranty, and with no claim as to its 
+// suitability for any purpose. 
+
+// For more information, see http://www.boost.org/
+
+    
+#include <boost/function.hpp>
+#include <iostream>
+#include <functional>
+
+struct X {
+  int foo(int);
+};
+int X::foo(int x) { return -x; }
+
+int main()
+{
+      boost::function<int (int)> f;
+  X x;
+  f = std::bind1st(
+        std::mem_fun(&X::foo), &x);
+  f(5); // Call x.foo(5)
+
+    return 0;
+}

test/std_bind_portable.cpp

@@ -0,0 +1,34 @@
+// Function library
+
+// Copyright (C) 2001-2003 Douglas Gregor
+
+// Permission to copy, use, sell and distribute this software is granted 
+// provided this copyright notice appears in all copies. Permission to modify 
+// the code and to distribute modified code is granted provided this copyright 
+// notice appears in all copies, and a notice that the code was modified is 
+// included with the copyright notice. This software is provided "as is" 
+// without express or implied warranty, and with no claim as to its 
+// suitability for any purpose. 
+
+// For more information, see http://www.boost.org/
+
+    
+#include <boost/function.hpp>
+#include <iostream>
+#include <functional>
+
+struct X {
+  int foo(int);
+};
+int X::foo(int x) { return -x; }
+
+int main()
+{
+      boost::function1<int, int> f;
+  X x;
+  f = std::bind1st(
+        std::mem_fun(&X::foo), &x);
+  f(5); // Call x.foo(5)
+
+    return 0;
+}

test/sum_avg_cxx98.cpp

@@ -0,0 +1,32 @@
+// Function library
+
+// Copyright (C) 2001-2003 Douglas Gregor
+
+// Permission to copy, use, sell and distribute this software is granted 
+// provided this copyright notice appears in all copies. Permission to modify 
+// the code and to distribute modified code is granted provided this copyright 
+// notice appears in all copies, and a notice that the code was modified is 
+// included with the copyright notice. This software is provided "as is" 
+// without express or implied warranty, and with no claim as to its 
+// suitability for any purpose. 
+
+// For more information, see http://www.boost.org/
+
+    
+#include <boost/function.hpp>
+#include <iostream>
+
+void do_sum_avg(int values[], int n, int& sum, float& avg)
+{
+  sum = 0;
+  for (int i = 0; i < n; i++)
+    sum += values[i];
+  avg = (float)sum / n;
+}
+int main()
+{
+    boost::function<void (int values[], int n, int& sum, float& avg)> sum_avg;
+    sum_avg = &do_sum_avg;
+
+    return 0;
+}

test/sum_avg_portable.cpp

@@ -0,0 +1,32 @@
+// Function library
+
+// Copyright (C) 2001-2003 Douglas Gregor
+
+// Permission to copy, use, sell and distribute this software is granted 
+// provided this copyright notice appears in all copies. Permission to modify 
+// the code and to distribute modified code is granted provided this copyright 
+// notice appears in all copies, and a notice that the code was modified is 
+// included with the copyright notice. This software is provided "as is" 
+// without express or implied warranty, and with no claim as to its 
+// suitability for any purpose. 
+
+// For more information, see http://www.boost.org/
+
+    
+#include <boost/function.hpp>
+#include <iostream>
+
+void do_sum_avg(int values[], int n, int& sum, float& avg)
+{
+  sum = 0;
+  for (int i = 0; i < n; i++)
+    sum += values[i];
+  avg = (float)sum / n;
+}
+int main()
+{
+    boost::function4<void, int[], int, int&, float&> sum_avg;
+    sum_avg = &do_sum_avg;
+
+    return 0;
+}