More regression fixes

[SVN r11762]

bind_test.cpp

@@ -174,7 +174,7 @@ struct Y
     short operator()(short & r) const { return ++r; }
     int operator()(int a, int b) const { return a + 10 * b; }
     long operator() (long a, long b, long c) const { return a + 10 * b + 100 * c; }
-    void operator() (long a, long b, long c, const char*) const { global_result = a + 10 * b + 100 * c; }
+    void operator() (long a, long b, long c, long d) const { global_result = a + 10 * b + 100 * c + 1000 * d; }
 };
 
 void function_object_test()
@@ -189,9 +189,9 @@ void function_object_test()
     BOOST_TEST( bind<short>(Y(), ref(i))() == 8 );
     BOOST_TEST( bind<int>(Y(), i, _1)(k) == 38 );
     BOOST_TEST( bind<long>(Y(), i, _1, 9)(k) == 938 );
-#if !defined(__MWERKS__) || __MWERKS__ > 0x2406     // Fails for this version of the compiler.
+
-    BOOST_TEST( (bind<void>(Y(), i, _1, 9, "nothing")(k), (global_result == 938)) );
+    bind<void>(Y(), i, _1, 9, 4)(k);
-#endif
+    BOOST_TEST( global_result == 4938 );
 }
 
 //

include/boost/bind.hpp

@@ -1,7 +1,7 @@
 #ifndef BOOST_BIND_HPP_INCLUDED
 #define BOOST_BIND_HPP_INCLUDED
 
-#if _MSC_VER+0 >= 1020
+#if _MSC_VER >= 1020
 #pragma once
 #endif
 
@@ -78,6 +78,8 @@ template<class T> class type {};
 
 // listN
 
+#ifdef BOOST_NO_VOID_RETURNS
+
 template <class R> struct evaluator0;
 template <class R> struct evaluator1;
 template <class R> struct evaluator2;
@@ -89,6 +91,8 @@ template <class R> struct evaluator7;
 template <class R> struct evaluator8;
 template <class R> struct evaluator9;
 
+#endif
+
 class list0
 {
 public:
@@ -105,16 +109,24 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template <class R>
+    template<class R, class F, class A> R operator()(type<R>, F f, A &) const
-    struct evaluator
     {
-        typedef evaluator0<R> type;
+        return f();
-    };
+    }
 
     template<class V> void accept(V &) const
     {
     }
 
+#ifdef BOOST_NO_VOID_RETURNS
+
+	template<class R> struct evaluator
+	{
+        typedef evaluator0<R> type;
+	};
+
+#endif
+
 private:
 
     list0 & operator= (list0 const &);
@@ -138,17 +150,29 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template <class R>
+    template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
-    struct evaluator
     {
-        typedef evaluator1<R> type;
+        return f(a[a1_]);
-    };
+    }
 
     template<class V> void accept(V & v) const
     {
         v(a1_);
     }
 
+#ifdef BOOST_NO_VOID_RETURNS
+
+	template<class R> struct evaluator
+	{
+        typedef evaluator1<R> type;
+	};
+
+#else
+
+private:
+
+#endif
+
     A1 a1_;
 
 private:
@@ -175,11 +199,10 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template <class R>
+    template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
-    struct evaluator
     {
-        typedef evaluator2<R> type;
+        return f(a[a1_], a[a2_]);
-    };
+    }
 
     template<class V> void accept(V & v) const
     {
@@ -187,6 +210,19 @@ public:
         v(a2_);
     }
 
+#ifdef BOOST_NO_VOID_RETURNS
+
+	template<class R> struct evaluator
+	{
+        typedef evaluator2<R> type;
+	};
+
+#else
+
+private:
+
+#endif
+
     A1 a1_;
     A2 a2_;
 
@@ -215,11 +251,10 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template <class R>
+    template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
-    struct evaluator
     {
-        typedef evaluator3<R> type;
+        return f(a[a1_], a[a2_], a[a3_]);
-    };
+    }
 
     template<class V> void accept(V & v) const
     {
@@ -228,6 +263,19 @@ public:
         v(a3_);
     }
 
+#ifdef BOOST_NO_VOID_RETURNS
+
+	template<class R> struct evaluator
+	{
+        typedef evaluator3<R> type;
+	};
+
+#else
+
+private:
+
+#endif
+
     A1 a1_;
     A2 a2_;
     A3 a3_;
@@ -258,11 +306,10 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template <class R>
+    template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
-    struct evaluator
     {
-        typedef evaluator4<R> type;
+        return f(a[a1_], a[a2_], a[a3_], a[a4_]);
-    };
+    }
 
     template<class V> void accept(V & v) const
     {
@@ -272,6 +319,19 @@ public:
         v(a4_);
     }
 
+#ifdef BOOST_NO_VOID_RETURNS
+
+	template<class R> struct evaluator
+	{
+        typedef evaluator4<R> type;
+	};
+
+#else
+
+private:
+
+#endif
+
     A1 a1_;
     A2 a2_;
     A3 a3_;
@@ -304,11 +364,10 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template <class R>
+    template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
-    struct evaluator
     {
-        typedef evaluator5<R> type;
+        return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
-    };
+    }
 
     template<class V> void accept(V & v) const
     {
@@ -319,6 +378,19 @@ public:
         v(a5_);
     }
 
+#ifdef BOOST_NO_VOID_RETURNS
+
+	template<class R> struct evaluator
+	{
+        typedef evaluator5<R> type;
+	};
+
+#else
+
+private:
+
+#endif
+
     A1 a1_;
     A2 a2_;
     A3 a3_;
@@ -353,11 +425,10 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template <class R>
+    template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
-    struct evaluator
     {
-        typedef evaluator6<R> type;
+        return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
-    };
+    }
 
     template<class V> void accept(V & v) const
     {
@@ -369,6 +440,19 @@ public:
         v(a6_);
     }
 
+#ifdef BOOST_NO_VOID_RETURNS
+
+	template<class R> struct evaluator
+	{
+        typedef evaluator6<R> type;
+	};
+
+#else
+
+private:
+
+#endif
+
     A1 a1_;
     A2 a2_;
     A3 a3_;
@@ -405,11 +489,10 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template <class R>
+    template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
-    struct evaluator
     {
-        typedef evaluator7<R> type;
+        return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
-    };
+    }
 
     template<class V> void accept(V & v) const
     {
@@ -422,6 +505,19 @@ public:
         v(a7_);
     }
 
+#ifdef BOOST_NO_VOID_RETURNS
+
+	template<class R> struct evaluator
+	{
+        typedef evaluator7<R> type;
+	};
+
+#else
+
+private:
+
+#endif
+
     A1 a1_;
     A2 a2_;
     A3 a3_;
@@ -460,11 +556,10 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template <class R>
+    template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
-    struct evaluator
     {
-        typedef evaluator8<R> type;
+        return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
-    };
+    }
 
     template<class V> void accept(V & v) const
     {
@@ -478,6 +573,19 @@ public:
         v(a8_);
     }
 
+#ifdef BOOST_NO_VOID_RETURNS
+
+	template<class R> struct evaluator
+	{
+        typedef evaluator8<R> type;
+	};
+
+#else
+
+private:
+
+#endif
+
     A1 a1_;
     A2 a2_;
     A3 a3_;
@@ -518,11 +626,10 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template <class R>
+    template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
-    struct evaluator
     {
-        typedef evaluator9<R> type;
+        return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
-    };
+    }
 
     template<class V> void accept(V & v) const
     {
@@ -537,6 +644,19 @@ public:
         v(a9_);
     }
 
+#ifdef BOOST_NO_VOID_RETURNS
+
+	template<class R> struct evaluator
+	{
+        typedef evaluator9<R> type;
+	};
+
+#else
+
+private:
+
+#endif
+
     A1 a1_;
     A2 a2_;
     A3 a3_;
@@ -552,7 +672,7 @@ private:
     list9 & operator= (list9 const &);
 };
 
-// bind_t
+#ifdef BOOST_NO_VOID_RETURNS
 
 template <class R> struct evaluator0
 {
@@ -734,358 +854,67 @@ template <> struct evaluator9<void>
     }
 };
 
-template <class R>
+#endif
-struct bind_t_generator
-{
-  template<class F, class L>
-  struct implementation
-  {
-    typedef typename result_traits<R, F>::type result_type;
 
-    implementation(F f, L const & l): f_(f), l_(l) {}
+// bind_t
 
-    result_type operator()()
+#ifndef BOOST_NO_VOID_RETURNS
-    {
-        list0 a;
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
 
-    result_type operator()() const
+template<class R, class F, class L> class bind_t
 {
-        list0 a;
+public:
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
 
-    template<class A1> result_type operator()(A1 & a1)
+    bind_t(F f, L const & l): f_(f), l_(l) {}
-    {
-        list1<A1 &> a(a1);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
 
-    template<class A1> result_type operator()(A1 & a1) const
+#define BOOST_BIND_EVALUATE return l_(type<result_type>(), f_, a)
-    {
+#include <boost/bind/bind_template.hpp>
-        list1<A1 &> a(a1);
+#undef BOOST_BIND_EVALUATE
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
-
-    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
-    {
-        list2<A1 &, A2 &> a(a1, a2);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
-
-    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
-    {
-        list2<A1 &, A2 &> a(a1, a2);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
-
-    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
-    {
-        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
-
-    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
-    {
-        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
-
-    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
-    {
-        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
-
-    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
-    {
-        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
-
-    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
-    {
-        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
-
-    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
-    {
-        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
-
-    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
-    {
-        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
-
-    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
-    {
-        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
-
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
-    {
-        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
-    {
-        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
-    {
-        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
-    {
-        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
-    {
-        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
-    {
-        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A> result_type eval(A & a)
-    {
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
-
-    template<class A> result_type eval(A & a) const
-    {
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        return evaluator::eval(l_, f_, a);
-    }
-
-    template<class V> void accept(V & v) const
-    {
-        v(f_);
-        l_.accept(v);
-    }
 
 private:
 
-    F f_;
+    bind_t & operator= (bind_t const &);
-    L l_;
-
-    implementation & operator= (implementation const &);
-  };
 };
 
-template <>
+#else
-struct bind_t_generator<void>
+
+template <class R> struct bind_t_generator
 {
-  template<class F, class L>
+
-  struct implementation
+template<class F, class L> class implementation
 {
-    typedef typename result_traits<void, F>::type result_type;
+public:
 
     implementation(F f, L const & l): f_(f), l_(l) {}
 
-    result_type operator()()
+#define BOOST_BIND_EVALUATE return L::BOOST_NESTED_TEMPLATE evaluator<result_type>::type::eval(l_, f_, a);
-    {
+#include <boost/bind/bind_template.hpp>
-        list0 a;
+#undef BOOST_BIND_EVALUATE
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-      
-    result_type operator()() const
-    {
-        list0 a;
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1> result_type operator()(A1 & a1)
-    {
-        list1<A1 &> a(a1);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1> result_type operator()(A1 & a1) const
-    {
-        list1<A1 &> a(a1);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
-    {
-        list2<A1 &, A2 &> a(a1, a2);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
-    {
-        list2<A1 &, A2 &> a(a1, a2);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
-    {
-        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
-    {
-        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
-    {
-        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
-    {
-        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
-    {
-        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
-    {
-        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
-    {
-        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
-    {
-        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
-    {
-        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
-    {
-        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
-    {
-        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
-    {
-        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
-    {
-        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
-    {
-        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-      
-    template<class A> result_type eval(A & a)
-    {
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-
-    template<class A> result_type eval(A & a) const
-    {
-        typedef typename L::template evaluator<result_type>::type evaluator;
-        evaluator::eval(l_, f_, a);
-    }
-
-    template<class V> void accept(V & v) const
-    {
-        v(f_);
-        l_.accept(v);
-    }
 
 private:
 
-    F f_;
+    implementation & operator= (implementation const &);
-    L l_;
+};
+
+};
+
+template<> struct bind_t_generator<void>
+{
+
+template<class F, class L> class implementation
+{
+public:
+
+    implementation(F f, L const & l): f_(f), l_(l) {}
+
+#define BOOST_BIND_EVALUATE L::BOOST_NESTED_TEMPLATE evaluator<result_type>::type::eval(l_, f_, a);
+#include <boost/bind/bind_template.hpp>
+#undef BOOST_BIND_EVALUATE
+
+private:
 
     implementation & operator= (implementation const &);
 };
+
 };
 
 #if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
@@ -1093,13 +922,18 @@ private:
 #pragma warning(disable: 4097) // typedef name 'base' used as a synonym for class
 #endif
 
-template<class R, class F, class L> class bind_t
+template<class R, class F, class L> class bind_t: public bind_t_generator<R>::BOOST_NESTED_TEMPLATE implementation<F, L>
-  : public bind_t_generator<R>::template implementation<F, L>
 {
-    typedef typename bind_t_generator<R>::template implementation<F, L> base;
- public:
-    bind_t(F f, L const & l): base(f, l) {}
 private:
+
+    typedef typename bind_t_generator<R>::template implementation<F, L> base;
+
+public:
+
+    bind_t(F f, L const & l): base(f, l) {}
+
+private:
+
     bind_t & operator= (bind_t const &);
 };
 
@@ -1107,9 +941,11 @@ template<class R, class F, class L> class bind_t
 #pragma warning(pop)
 #endif
 
+#endif
+
 // add_value
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || (__SUNPRO_CC+0 >= 0x530)
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || (__SUNPRO_CC >= 0x530)
 
 template<class T> struct add_value
 {

include/boost/bind/bind_template.hpp

@@ -0,0 +1,157 @@
+//
+//  bind/bind_template.hpp
+//
+//	Do not include this header directly.
+//
+//  Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
+//
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+//  See http://www.boost.org/libs/bind/bind.html for documentation.
+//
+
+    typedef typename result_traits<R, F>::type result_type;
+
+    result_type operator()()
+    {
+        list0 a;
+        BOOST_BIND_EVALUATE;
+    }
+
+    result_type operator()() const
+    {
+        list0 a;
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class A1> result_type operator()(A1 & a1)
+    {
+        list1<A1 &> a(a1);
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class A1> result_type operator()(A1 & a1) const
+    {
+        list1<A1 &> a(a1);
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
+    {
+        list2<A1 &, A2 &> a(a1, a2);
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
+    {
+        list2<A1 &, A2 &> a(a1, a2);
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
+    {
+        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
+    {
+        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
+    {
+        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
+    {
+        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
+    {
+        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
+    {
+        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
+    {
+        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
+    {
+        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
+    {
+        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
+    {
+        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
+    {
+        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
+    {
+        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
+    {
+        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
+    {
+        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class A> result_type eval(A & a)
+    {
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class A> result_type eval(A & a) const
+    {
+        BOOST_BIND_EVALUATE;
+    }
+
+    template<class V> void accept(V & v) const
+    {
+        v(f_);
+        l_.accept(v);
+    }
+
+private:
+
+    F f_;
+    L l_;