This commit was manufactured by cvs2svn to create tag

'Version_1_32_0'. [SVN r26264]
This commit was manufactured by cvs2svn to create branch 'RC_1_32_0'.
2026-04-13 13:15:50 +02:00 · 2004-11-19 19:19:18 +00:00 · 2004-10-20 08:26:43 +00:00 · 2004-10-05 15:45:52 +00:00 · 2004-09-13 17:43:08 +00:00 · 2004-07-26 00:32:12 +00:00
36 changed files with 2270 additions and 1093 deletions
--- a/bind.html
+++ b/bind.html
@@ -7,7 +7,7 @@
 	<body style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%" bgColor="white">
 		<table width="100%" border="0">
 			<tr>
-				<td width="277"><IMG height="86" alt="c++boost.gif (8819 bytes)" src="../../c++boost.gif" width="277">
+				<td width="277"><IMG height="86" alt="boost.png (6897 bytes)" src="../../boost.png" width="277">
 				</td>
 				<td align="middle">
 					<h1>bind.hpp</h1>
@@ -356,8 +356,8 @@ template&lt;class T&gt; void f(T const &amp; t);
 			(b) does not actually work for const arguments, both l- and r-values, since the 
 			two templates produce the exact same signature and cannot be partially ordered.
 		</p>
-		<p>[Note: this is a dark corner of the language, and the <a href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/cwg_active.html#214">
-				corresponding issue</a> has not been resolved yet.]
+		<p>[Note: this is a dark corner of the language, and the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#214">
+				corresponding issue</a> has only recently been resolved.]
 		</p>
 		<h2><a name="FAQ">Frequently Asked Questions</a></h2>
 		<h3><a name="Q_doesnt_compile">Why doesn't this compile?</a></h3>
@@ -833,7 +833,7 @@ namespace
 					STL</a> by Petter Urkedal.</li></ul>
 		<p>Doug Gregor suggested that a visitor mechanism would allow <b>bind</b> to 
 			interoperate with a signal/slot library.</p>
-		<p>John Maddock fixed a MSVC-specific conflict between <b>bind</b> and the <A href="../type_traits/index.htm">
+		<p>John Maddock fixed a MSVC-specific conflict between <b>bind</b> and the <A href="../type_traits/index.html">
 				type traits library</A>.</p>
 		<p>Numerous improvements were suggested during the formal review period by Ross 
 			Smith, Richard Crossley, Jens Maurer, Ed Brey, and others. Review manager was 
--- a/bind_as_compose.cpp
+++ b/bind_as_compose.cpp
@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion
@@ -12,10 +14,9 @@
 //
 //  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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //

 #include <boost/bind.hpp>
--- a/bind_visitor.cpp
+++ b/bind_visitor.cpp
@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion
@@ -10,10 +12,9 @@
 //
 //  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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //

 #include <boost/bind.hpp>
--- a/doc/ref.xml
+++ b/doc/ref.xml
@@ -0,0 +1,242 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
+  "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
+<library name="Ref" dirname="ref" id="ref" last-revision="$Date$">
+  <libraryinfo>
+    <author>
+      <firstname>Jaakko</firstname>
+      <surname>J&auml;rvi</surname>
+    </author>
+    <author>
+      <firstname>Peter</firstname>
+      <surname>Dimov</surname>
+    </author>
+    <author>
+      <firstname>Douglas</firstname>
+      <surname>Gregor</surname>
+    </author>
+    <author>
+      <firstname>Dave</firstname>
+      <surname>Abrahams</surname>
+    </author>
+
+    <copyright>
+      <year>1999</year>
+      <year>2000</year>
+      <holder>Jaakko J&auml;rvi</holder>
+    </copyright>
+
+    <copyright>
+      <year>2001</year>
+      <year>2002</year>
+      <holder>Peter Dimov</holder>
+    </copyright>
+    
+    <copyright>
+      <year>2002</year>
+      <holder>David Abrahams</holder>
+    </copyright>
+
+    <legalnotice>
+      <para>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.
+      </para>
+    </legalnotice>
+
+    <librarypurpose>A utility library for passing references to generic functions</librarypurpose>
+    <librarycategory name="category:higher-order"/>
+  </libraryinfo>
+
+<title>Boost.Ref</title>
+
+<section id="ref.intro">
+  <title>Introduction</title> 
+
+  <using-namespace name="boost"/>
+
+  <para>The Ref library is a small library that is useful for passing
+  references to function templates (algorithms) that would usually
+  take copies of their arguments. It defines the class template
+  <code><classname>boost::reference_wrapper&lt;T&gt;</classname></code>,
+  the two functions
+  <code><functionname>boost::ref</functionname></code> and
+  <code><functionname>boost::cref</functionname></code> that return
+  instances of <code>boost::reference_wrapper&lt;T&gt;</code>, and the
+  two traits classes
+  <code><classname>boost::is_reference_wrapper&lt;T&gt;</classname></code>
+  and
+  <code><classname>boost::unwrap_reference&lt;T&gt;</classname></code>.</para>
+
+  <para>The purpose of
+  <code>boost::reference_wrapper&lt;T&gt;</code> is to
+  contain a reference to an object of type T. It is primarily used to
+  "feed" references to function templates (algorithms) that take their
+  parameter by value.</para>
+
+  <para>To support this usage,
+  <code>boost::reference_wrapper&lt;T&gt;</code> provides an implicit
+  conversion to <code>T&amp;</code>. This usually allows the function
+  templates to work on references unmodified.</para>
+
+  <para><code>boost::reference_wrapper&lt;T&gt;</code> is
+  both CopyConstructible and Assignable (ordinary references are not
+  Assignable).</para>
+
+  <para>The expression <code>boost::ref(x)</code>
+  returns a
+  <code>boost::reference_wrapper&lt;X&gt;(x)</code> where X
+  is the type of x. Similarly,
+  <code>boost::cref(x)</code> returns a
+  <code>boost::reference_wrapper&lt;X const&gt;(x)</code>.</para>
+
+  <para>The expression
+  <code>boost::is_reference_wrapper&lt;T&gt;::value</code>
+  is true if T is a <code>reference_wrapper</code>, and
+  false otherwise.</para>
+
+  <para>The type-expression
+  <code>boost::unwrap_reference&lt;T&gt;::type</code> is T::type if T
+  is a <code>reference_wrapper</code>, T otherwise.</para>
+</section>
+
+<library-reference>
+<header name="boost/ref.hpp">
+  <namespace name="boost">
+    <class name="reference_wrapper">
+      <template>
+        <template-type-parameter name="T"/>
+      </template>
+      <purpose>
+        Contains a reference to an object of type
+        <computeroutput>T</computeroutput>. 
+      </purpose>
+
+      <description>
+        <para><computeroutput><classname>reference_wrapper</classname></computeroutput>
+        is primarily used to "feed" references to function templates
+        (algorithms) that take their parameter by value.  It provides
+        an implicit conversion to
+        <computeroutput>T&amp;</computeroutput>, which usually allows
+        the function templates to work on references
+        unmodified.</para>
+      </description>
+
+      <typedef name="type"><type>T</type></typedef>
+
+      <constructor specifiers="explicit">
+        <parameter name="t">
+          <paramtype>T&amp;</paramtype>
+        </parameter>
+
+        <effects><simpara>Constructs a
+        <computeroutput><classname>reference_wrapper</classname></computeroutput>
+        object that stores a reference to
+        <computeroutput>t</computeroutput>.</simpara></effects>
+
+        <throws><simpara>Does not throw.</simpara></throws>
+      </constructor>    
+
+      <method-group name="access">
+        <method name="conversion-operator" cv="const">
+          <type>T&amp;</type>
+          <returns><simpara>The stored reference.</simpara></returns>
+          <throws><simpara>Does not throw.</simpara></throws>
+        </method>
+
+        <method name="get" cv="const">
+          <type>T&amp;</type>
+          <returns><simpara>The stored reference.</simpara></returns>
+          <throws><simpara>Does not throw.</simpara></throws>
+        </method>
+
+        <method name="get_pointer" cv="const">
+          <type>T*</type>
+          <returns><simpara>A pointer to the object referenced by the stored reference.</simpara></returns>
+          <throws><simpara>Does not throw.</simpara></throws>
+        </method>
+      </method-group>
+
+      <free-function-group name="constructors">
+        <function name="ref">
+          <type>reference_wrapper&lt;T&gt;</type>
+          <parameter name="t">
+            <paramtype>T&amp;</paramtype>
+          </parameter>
+
+          <returns><simpara><computeroutput><classname>reference_wrapper</classname>&lt;T&gt;(t)</computeroutput></simpara></returns>
+
+          <throws><simpara>Does not throw.</simpara></throws>
+        </function>
+
+        <function name="cref">
+          <type>reference_wrapper&lt;T const&gt;</type>
+          <parameter name="t">
+            <paramtype>T const&amp;</paramtype>
+          </parameter>
+
+          <returns><simpara><computeroutput><classname>reference_wrapper</classname>&lt;T const&gt;(t)</computeroutput></simpara></returns>
+
+          <throws><simpara>Does not throw.</simpara></throws>
+        </function>
+      </free-function-group>
+    </class>
+
+    <class name="is_reference_wrapper">
+      <template>
+        <template-type-parameter name="T"/>
+      </template>
+
+      <purpose>Determine if a type <computeroutput>T</computeroutput> is an instantiation of <computeroutput><classname>reference_wrapper</classname></computeroutput>.</purpose>
+
+      <description>
+        <para>The <computeroutput>value</computeroutput> static
+        constant will be <computeroutput>true</computeroutput> iff the
+        type <computeroutput>T</computeroutput> is a specialization of
+        <computeroutput><classname>reference_wrapper</classname></computeroutput>.</para>
+      </description>
+
+      <static-constant name="value">
+        <type>bool</type>
+        <default><emphasis>unspecified</emphasis></default>
+      </static-constant>
+    </class>
+
+    <class name="unwrap_reference">
+      <template>
+        <template-type-parameter name="T"/>
+      </template>
+  
+      <purpose>Find the type in a <computeroutput><classname>reference_wrapper</classname></computeroutput>.</purpose>
+
+      <description>
+        <para>The typedef <computeroutput>type</computeroutput> is
+        <computeroutput>T::type</computeroutput> if
+        <computeroutput>T</computeroutput> is a
+        <computeroutput><classname>reference_wrapper</classname></computeroutput>,
+        <computeroutput>T</computeroutput> otherwise.</para>
+      </description>
+
+      <typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef>
+    </class>
+  </namespace>
+</header>
+</library-reference>
+
+<section id="ref.ack">
+  <title>Acknowledgements</title>
+
+  <using-namespace name="boost"/> 
+
+  <para><functionname>ref</functionname> and <functionname>cref</functionname>
+  were originally part of the <libraryname>Tuple</libraryname> library
+  by Jaakko J&auml;rvi. They were "promoted to boost:: status" by
+  Peter Dimov because they are generally useful.  Douglas Gregor and
+  Dave Abrahams contributed
+  <classname>is_reference_wrapper</classname> and
+  <classname>unwrap_reference</classname>.</para>
+</section>
+
+</library>
--- a/include/boost/bind.hpp
+++ b/include/boost/bind.hpp
@@ -1,20 +1,21 @@
 #ifndef BOOST_BIND_HPP_INCLUDED
 #define BOOST_BIND_HPP_INCLUDED

-#if _MSC_VER >= 1020
-#pragma once
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif

 //
 //  bind.hpp - binds function objects to arguments
 //
-//  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.
 //  Copyright (c) 2001 David Abrahams
 //
-//  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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //
 //  See http://www.boost.org/libs/bind/bind.html for documentation.
 //
@@ -24,6 +25,7 @@
 #include <boost/mem_fn.hpp>
 #include <boost/type.hpp>
 #include <boost/bind/arg.hpp>
+#include <boost/detail/workaround.hpp>

 // Borland-specific bug, visit_each() silently fails to produce code

@@ -67,6 +69,18 @@ template<class F> struct result_traits< unspecified, reference_wrapper<F> >

 #endif

+// ref_compare
+
+template<class T> bool ref_compare(T const & a, T const & b, long)
+{
+    return a == b;
+}
+
+template<class T> bool ref_compare(reference_wrapper<T> const & a, reference_wrapper<T> const & b, int)
+{
+    return a.get_pointer() == b.get_pointer();
+}
+
 // bind_t forward declaration for listN

 template<class R, class F, class L> class bind_t;
@@ -82,6 +96,11 @@ public:
    T & get() { return t_; }
    T const & get() const { return t_; }

+    bool operator==(value const & rhs) const
+    {
+        return t_ == rhs.t_;
+    }
+
 private:

    T t_;
@@ -93,38 +112,41 @@ template<class T> class type {};

 // unwrap

-template<class F> inline F & unwrap(F & f, long)
+template<class F> inline F & unwrap(F * f, long)
 {
-    return f;
+    return *f;
 }

-template<class F> inline F & unwrap(reference_wrapper<F> & f, int)
+template<class F> inline F & unwrap(reference_wrapper<F> * f, int)
 {
-    return f;
+    return f->get();
 }

-template<class F> inline F & unwrap(reference_wrapper<F> const & f, int)
+template<class F> inline F & unwrap(reference_wrapper<F> const * f, int)
 {
-    return f;
+    return f->get();
 }

-// listN
+#if !( defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, <= 0x3003) )

-#ifdef BOOST_NO_VOID_RETURNS
+template<class R, class T> inline _mfi::dm<R, T> unwrap(R T::* * pm, int)
+{
+    return _mfi::dm<R, T>(*pm);
+}
+
+#if !BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
+// IBM/VisualAge 6.0 is not able to handle this overload.
+template<class R, class T> inline _mfi::dm<R, T> unwrap(R T::* const * pm, int)
+{
+    return _mfi::dm<R, T>(*pm);
+}
+#endif

-template <class R> struct evaluator0;
-template <class R> struct evaluator1;
-template <class R> struct evaluator2;
-template <class R> struct evaluator3;
-template <class R> struct evaluator4;
-template <class R> struct evaluator5;
-template <class R> struct evaluator6;
-template <class R> struct evaluator7;
-template <class R> struct evaluator8;
-template <class R> struct evaluator9;

 #endif

+// listN
+
 class list0
 {
 public:
@@ -141,24 +163,34 @@ 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, class F, class A> R operator()(type<R>, F f, A &) const
+    template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)
    {
-        return unwrap(f, 0)();
+        return unwrap(&f, 0)();
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const
+    {
+        return unwrap(&f, 0)();
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A &, int)
+    {
+        unwrap(&f, 0)();
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A &, int) const
+    {
+        unwrap(&f, 0)();
    }

    template<class V> void accept(V &) const
    {
    }

-#ifdef BOOST_NO_VOID_RETURNS
-
-    template<class R> struct evaluator
+    bool operator==(list0 const &) const
    {
-        typedef evaluator0<R> type;
-    };
-
-#endif
-
+        return true;
+    }
 };

 template<class A1> class list1
@@ -181,9 +213,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, class F, class A> R operator()(type<R>, F f, A & a) const
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
-        return unwrap(f, 0)(a[a1_]);
+        return unwrap(&f, 0)(a[a1_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrap(&f, 0)(a[a1_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrap(&f, 0)(a[a1_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrap(&f, 0)(a[a1_]);
    }

    template<class V> void accept(V & v) const
@@ -191,19 +238,13 @@ public:
        BOOST_BIND_VISIT_EACH(v, a1_, 0);
    }

-#ifdef BOOST_NO_VOID_RETURNS
-
-    template<class R> struct evaluator
+    bool operator==(list1 const & rhs) const
    {
-        typedef evaluator1<R> type;
-    };
-
-#else
+        return ref_compare(a1_, rhs.a1_, 0);
+    }

 private:

-#endif
-
    A1 a1_;
 };

@@ -229,9 +270,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, class F, class A> R operator()(type<R>, F f, A & a) const
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
-        return unwrap(f, 0)(a[a1_], a[a2_]);
+        return unwrap(&f, 0)(a[a1_], a[a2_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrap(&f, 0)(a[a1_], a[a2_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrap(&f, 0)(a[a1_], a[a2_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrap(&f, 0)(a[a1_], a[a2_]);
    }

    template<class V> void accept(V & v) const
@@ -240,19 +296,13 @@ public:
        BOOST_BIND_VISIT_EACH(v, a2_, 0);
    }

-#ifdef BOOST_NO_VOID_RETURNS
-
-    template<class R> struct evaluator
+    bool operator==(list2 const & rhs) const
    {
-        typedef evaluator2<R> type;
-    };
-
-#else
+        return ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0);
+    }

 private:

-#endif
-
    A1 a1_;
    A2 a2_;
 };
@@ -281,9 +331,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, class F, class A> R operator()(type<R>, F f, A & a) const
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
-        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_]);
+        return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrap(&f, 0)(a[a1_], a[a2_], a[a3_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrap(&f, 0)(a[a1_], a[a2_], a[a3_]);
    }

    template<class V> void accept(V & v) const
@@ -293,19 +358,13 @@ public:
        BOOST_BIND_VISIT_EACH(v, a3_, 0);
    }

-#ifdef BOOST_NO_VOID_RETURNS
-
-    template<class R> struct evaluator
+    bool operator==(list3 const & rhs) const
    {
-        typedef evaluator3<R> type;
-    };
-
-#else
+        return ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0);
+    }

 private:

-#endif
-
    A1 a1_;
    A2 a2_;
    A3 a3_;
@@ -337,9 +396,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, class F, class A> R operator()(type<R>, F f, A & a) const
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
-        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
+        return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
    }

    template<class V> void accept(V & v) const
@@ -350,19 +424,15 @@ public:
        BOOST_BIND_VISIT_EACH(v, a4_, 0);
    }

-#ifdef BOOST_NO_VOID_RETURNS
-
-    template<class R> struct evaluator
+    bool operator==(list4 const & rhs) const
    {
-        typedef evaluator4<R> type;
-    };
-
-#else
+        return
+            ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) &&
+            ref_compare(a4_, rhs.a4_, 0);
+    }

 private:

-#endif
-
    A1 a1_;
    A2 a2_;
    A3 a3_;
@@ -397,9 +467,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, class F, class A> R operator()(type<R>, F f, A & a) const
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
-        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
+        return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
    }

    template<class V> void accept(V & v) const
@@ -411,19 +496,15 @@ public:
        BOOST_BIND_VISIT_EACH(v, a5_, 0);
    }

-#ifdef BOOST_NO_VOID_RETURNS
-
-    template<class R> struct evaluator
+    bool operator==(list5 const & rhs) const
    {
-        typedef evaluator5<R> type;
-    };
-
-#else
+        return
+            ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) &&
+            ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0);
+    }

 private:

-#endif
-
    A1 a1_;
    A2 a2_;
    A3 a3_;
@@ -461,9 +542,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, class F, class A> R operator()(type<R>, F f, A & a) const
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
-        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
+        return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
    }

    template<class V> void accept(V & v) const
@@ -476,19 +572,15 @@ public:
        BOOST_BIND_VISIT_EACH(v, a6_, 0);
    }

-#ifdef BOOST_NO_VOID_RETURNS
-
-    template<class R> struct evaluator
+    bool operator==(list6 const & rhs) const
    {
-        typedef evaluator6<R> type;
-    };
-
-#else
+        return
+            ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) &&
+            ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0) && ref_compare(a6_, rhs.a6_, 0);
+    }

 private:

-#endif
-
    A1 a1_;
    A2 a2_;
    A3 a3_;
@@ -529,9 +621,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, class F, class A> R operator()(type<R>, F f, A & a) const
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
-        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
+        return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
    }

    template<class V> void accept(V & v) const
@@ -545,19 +652,16 @@ public:
        BOOST_BIND_VISIT_EACH(v, a7_, 0);
    }

-#ifdef BOOST_NO_VOID_RETURNS
-
-    template<class R> struct evaluator
+    bool operator==(list7 const & rhs) const
    {
-        typedef evaluator7<R> type;
-    };
-
-#else
+        return
+            ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) &&
+            ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0) && ref_compare(a6_, rhs.a6_, 0) &&
+            ref_compare(a7_, rhs.a7_, 0);
+    }

 private:

-#endif
-
    A1 a1_;
    A2 a2_;
    A3 a3_;
@@ -601,9 +705,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, class F, class A> R operator()(type<R>, F f, A & a) const
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
-        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
+        return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
    }

    template<class V> void accept(V & v) const
@@ -618,19 +737,16 @@ public:
        BOOST_BIND_VISIT_EACH(v, a8_, 0);
    }

-#ifdef BOOST_NO_VOID_RETURNS
-
-    template<class R> struct evaluator
+    bool operator==(list8 const & rhs) const
    {
-        typedef evaluator8<R> type;
-    };
-
-#else
+        return
+            ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) &&
+            ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0) && ref_compare(a6_, rhs.a6_, 0) &&
+            ref_compare(a7_, rhs.a7_, 0) && ref_compare(a8_, rhs.a8_, 0);
+    }

 private:

-#endif
-
    A1 a1_;
    A2 a2_;
    A3 a3_;
@@ -677,9 +793,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, class F, class A> R operator()(type<R>, F f, A & a) const
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
-        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
+        return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrap(&f, 0)(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
@@ -695,19 +826,16 @@ public:
        BOOST_BIND_VISIT_EACH(v, a9_, 0);
    }

-#ifdef BOOST_NO_VOID_RETURNS
-
-    template<class R> struct evaluator
+    bool operator==(list9 const & rhs) const
    {
-        typedef evaluator9<R> type;
-    };
-
-#else
+        return
+            ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) &&
+            ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0) && ref_compare(a6_, rhs.a6_, 0) &&
+            ref_compare(a7_, rhs.a7_, 0) && ref_compare(a8_, rhs.a8_, 0) && ref_compare(a9_, rhs.a9_, 0);
+    }

 private:

-#endif
-
    A1 a1_;
    A2 a2_;
    A3 a3_;
@@ -719,190 +847,6 @@ private:
    A9 a9_;
 };

-#ifdef BOOST_NO_VOID_RETURNS
-
-template <class R> struct evaluator0
-{
-    template<class L, class F, class A>
-    static R eval(L const&, F f, A &)
-    {
-        return unwrap(f, 0)();
-    }
-};
-
-template <> struct evaluator0<void>
-{
-    template<class L, class F, class A>
-    static void eval(L const&, F f, A &)
-    {
-        unwrap(f, 0)();
-    }
-};
-
-template <class R> struct evaluator1
-{
-    template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
-    {
-        return unwrap(f, 0)(a[l.a1_]);
-    }
-};
-
-template <> struct evaluator1<void>
-{
-    template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
-    {
-        unwrap(f, 0)(a[l.a1_]);
-    }
-};
-
-template <class R> struct evaluator2
-{
-    template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
-    {
-        return unwrap(f, 0)(a[l.a1_], a[l.a2_]);
-    }
-};
-
-template <> struct evaluator2<void>
-{
-    template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
-    {
-        unwrap(f, 0)(a[l.a1_], a[l.a2_]);
-    }
-};
-
-template <class R> struct evaluator3
-{
-    template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
-    {
-        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_]);
-    }
-};
-
-template <> struct evaluator3<void>
-{
-    template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
-    {
-        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_]);
-    }
-};
-
-template <class R> struct evaluator4
-{
-    template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
-    {
-        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
-    }
-};
-
-template <> struct evaluator4<void>
-{
-    template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
-    {
-        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
-    }
-};
-
-template <class R> struct evaluator5
-{
-    template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
-    {
-        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
-    }
-};
-
-template <> struct evaluator5<void>
-{
-    template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
-    {
-        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
-    }
-};
-
-template <class R> struct evaluator6
-{
-    template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
-    {
-        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
-    }
-};
-
-template <> struct evaluator6<void>
-{
-    template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
-    {
-        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
-    }
-};
-
-template <class R> struct evaluator7
-{
-    template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
-    {
-        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
-    }
-};
-
-template <> struct evaluator7<void>
-{
-    template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
-    {
-        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
-    }
-};
-
-template <class R> struct evaluator8
-{
-    template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
-    {
-        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_]);
-    }
-};
-
-template <> struct evaluator8<void>
-{
-    template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
-    {
-        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_]);
-    }
-};
-
-template <class R> struct evaluator9
-{
-    template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
-    {
-        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_], a[l.a9_]);
-    }
-};
-
-template <> struct evaluator9<void>
-{
-    template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
-    {
-        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_], a[l.a9_]);
-    }
-};
-
-#endif
-
 // bind_t

 #ifndef BOOST_NO_VOID_RETURNS
@@ -911,11 +855,13 @@ template<class R, class F, class L> class bind_t
 {
 public:

+    typedef bind_t this_type;
+
    bind_t(F f, L const & l): f_(f), l_(l) {}

-#define BOOST_BIND_EVALUATE return l_(type<result_type>(), f_, a)
+#define BOOST_BIND_RETURN return
 #include <boost/bind/bind_template.hpp>
-#undef BOOST_BIND_EVALUATE
+#undef BOOST_BIND_RETURN

 };

@@ -928,11 +874,13 @@ template<class F, class L> class implementation
 {
 public:

+    typedef implementation this_type;
+
    implementation(F f, L const & l): f_(f), l_(l) {}

-#define BOOST_BIND_EVALUATE return L::BOOST_NESTED_TEMPLATE evaluator<result_type>::type::eval(l_, f_, a);
+#define BOOST_BIND_RETURN return
 #include <boost/bind/bind_template.hpp>
-#undef BOOST_BIND_EVALUATE
+#undef BOOST_BIND_RETURN

 };

@@ -949,11 +897,13 @@ private:

 public:

+    typedef implementation this_type;
+
    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);
+#define BOOST_BIND_RETURN
 #include <boost/bind/bind_template.hpp>
-#undef BOOST_BIND_EVALUATE
+#undef BOOST_BIND_RETURN

 };

@@ -969,6 +919,18 @@ public:

 #endif

+// bind_t::operator==
+
+template<class R, class F, class L> bool operator==(bind_t<R, F, L> const & a, bind_t<R, F, L> const & b)
+{
+    return a.compare(b);
+}
+
+template<class R, class F, class L> bool operator!=(bind_t<R, F, L> const & a, bind_t<R, F, L> const & b)
+{
+    return !a.compare(b);
+}
+
 // add_value

 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || (__SUNPRO_CC >= 0x530)
@@ -1134,18 +1096,6 @@ template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, c
    typedef list9<B1, B2, B3, B4, B5, B6, B7, B8, B9> type;
 };

-// g++ 2.95 specific helper; used by the data member overload
-
-template<class T> struct add_cref
-{
-    typedef T const & type;
-};
-
-template<> struct add_cref<void>
-{
-    typedef void type;
-};
-
 } // namespace _bi

 // visit_each
@@ -1498,8 +1448,30 @@ template<class F, class A1, class A2, class A3, class A4, class A5, class A6, cl

 // data member pointers

+/*
+
 #if defined(__GNUC__) && (__GNUC__ == 2)

+namespace _bi
+{
+
+template<class T> struct add_cref
+{
+    typedef T const & type;
+};
+
+template<class T> struct add_cref< T & >
+{
+    typedef T const & type;
+};
+
+template<> struct add_cref<void>
+{
+    typedef void type;
+};
+
+} // namespace _bi
+
 template<class R, class T, class A1>
 _bi::bind_t< typename _bi::add_cref<R>::type, _mfi::dm<R, T>, typename _bi::list_av_1<A1>::type >
    BOOST_BIND(R T::*f, A1 a1)
@@ -1522,6 +1494,17 @@ _bi::bind_t< R const &, _mfi::dm<R, T>, typename _bi::list_av_1<A1>::type >

 #endif

+*/
+
+template<class R, class T, class A1>
+_bi::bind_t< R, _mfi::dm<R, T>, typename _bi::list_av_1<A1>::type >
+    BOOST_BIND(R T::*f, A1 a1)
+{
+    typedef _mfi::dm<R, T> F;
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<R, F, list_type>( F(f), list_type(a1) );
+}
+
 } // namespace boost

 #ifndef BOOST_BIND_NO_PLACEHOLDERS
--- a/include/boost/bind/apply.hpp
+++ b/include/boost/bind/apply.hpp
@@ -4,12 +4,11 @@
 //
 //  apply.hpp
 //
-//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2002, 2003 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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //

 namespace boost
@@ -19,52 +18,52 @@ template<class R> struct apply
 {
    typedef R result_type;

-    template<class F> result_type operator()(F f) const
+    template<class F> result_type operator()(F & f) const
    {
        return f();
    }

-    template<class F, class A1> result_type operator()(F f, A1 & a1) const
+    template<class F, class A1> result_type operator()(F & f, A1 & a1) const
    {
        return f(a1);
    }

-    template<class F, class A1, class A2> result_type operator()(F f, A1 & a1, A2 & a2) const
+    template<class F, class A1, class A2> result_type operator()(F & f, A1 & a1, A2 & a2) const
    {
        return f(a1, a2);
    }

-    template<class F, class A1, class A2, class A3> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3) const
+    template<class F, class A1, class A2, class A3> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3) const
    {
        return f(a1, a2, a3);
    }

-    template<class F, class A1, class A2, class A3, class A4> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
+    template<class F, class A1, class A2, class A3, class A4> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
    {
        return f(a1, a2, a3, a4);
    }

-    template<class F, class A1, class A2, class A3, class A4, class A5> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
+    template<class F, class A1, class A2, class A3, class A4, class A5> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
    {
        return f(a1, a2, a3, a4, a5);
    }

-    template<class F, class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
+    template<class F, class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
    {
        return f(a1, a2, a3, a4, a5, a6);
    }

-    template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
+    template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
    {
        return f(a1, a2, a3, a4, a5, a6, a7);
    }

-    template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
+    template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
    {
        return f(a1, a2, a3, a4, a5, a6, a7, a8);
    }

-    template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
+    template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
    {
        return f(a1, a2, a3, a4, a5, a6, a7, a8, a9);
    }
--- a/include/boost/bind/arg.hpp
+++ b/include/boost/bind/arg.hpp
@@ -1,8 +1,10 @@
 #ifndef BOOST_BIND_ARG_HPP_INCLUDED
 #define BOOST_BIND_ARG_HPP_INCLUDED

-#if _MSC_VER >= 1020
-#pragma once
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif

 //
@@ -10,10 +12,9 @@
 //
 //  Copyright (c) 2002 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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //
 //  See http://www.boost.org/libs/bind/bind.html for documentation.
 //
@@ -25,6 +26,11 @@ template<int I> class arg
 {
 };

+template<int I> bool operator==(arg<I> const &, arg<I> const &)
+{
+    return true;
+}
+
 } // namespace boost

 #endif // #ifndef BOOST_BIND_ARG_HPP_INCLUDED
--- a/include/boost/bind/bind_cc.hpp
+++ b/include/boost/bind/bind_cc.hpp
@@ -5,10 +5,9 @@
 //
 //  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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //
 //  See http://www.boost.org/libs/bind/bind.html for documentation.
 //
--- a/include/boost/bind/bind_mf_cc.hpp
+++ b/include/boost/bind/bind_mf_cc.hpp
@@ -5,10 +5,9 @@
 //
 //  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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //
 //  See http://www.boost.org/libs/bind/bind.html for documentation.
 //
--- a/include/boost/bind/bind_template.hpp
+++ b/include/boost/bind/bind_template.hpp
@@ -3,12 +3,11 @@
 //
 //  Do not include this header directly.
 //
-//  Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2001-2004 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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //
 //  See http://www.boost.org/libs/bind/bind.html for documentation.
 //
@@ -18,131 +17,131 @@
    result_type operator()()
    {
        list0 a;
-        BOOST_BIND_EVALUATE;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    result_type operator()() const
    {
        list0 a;
-        BOOST_BIND_EVALUATE;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    template<class A1> result_type operator()(A1 & a1)
    {
        list1<A1 &> a(a1);
-        BOOST_BIND_EVALUATE;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    template<class A1> result_type operator()(A1 & a1) const
    {
        list1<A1 &> a(a1);
-        BOOST_BIND_EVALUATE;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
    {
        list2<A1 &, A2 &> a(a1, a2);
-        BOOST_BIND_EVALUATE;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
    {
        list2<A1 &, A2 &> a(a1, a2);
-        BOOST_BIND_EVALUATE;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    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;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    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;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    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;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    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;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    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;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    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;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    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;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    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;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    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;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    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;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    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;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    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;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    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;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    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;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    template<class A> result_type eval(A & a)
    {
-        BOOST_BIND_EVALUATE;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    template<class A> result_type eval(A & a) const
    {
-        BOOST_BIND_EVALUATE;
+        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
    }

    template<class V> void accept(V & v) const
@@ -151,6 +150,11 @@
        l_.accept(v);
    }

+    bool compare(this_type const & rhs) const
+    {
+        return ref_compare(f_, rhs.f_, 0) && l_ == rhs.l_;
+    }
+
 private:

    F f_;
--- a/include/boost/bind/make_adaptable.hpp
+++ b/include/boost/bind/make_adaptable.hpp
@@ -6,10 +6,9 @@
 //
 //  Copyright (c) 2002 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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //

 namespace boost
@@ -18,10 +17,6 @@ namespace boost
 namespace _bi
 {

-template<class F> void instantiate(F)
-{
-}
-
 template<class R, class F> class af0
 {
 public:
@@ -37,6 +32,11 @@ public:
        return f_();
    }

+    result_type operator()() const
+    {
+        return f_();
+    }
+
 private:

    F f_;
@@ -59,6 +59,11 @@ public:
        return f_(a1);
    }

+    result_type operator()(A1 a1) const
+    {
+        return f_(a1);
+    }
+
 private:

    F f_;
@@ -83,6 +88,11 @@ public:
        return f_(a1, a2);
    }

+    result_type operator()(A1 a1, A2 a2) const
+    {
+        return f_(a1, a2);
+    }
+
 private:

    F f_;
@@ -106,6 +116,11 @@ public:
        return f_(a1, a2, a3);
    }

+    result_type operator()(A1 a1, A2 a2, A3 a3) const
+    {
+        return f_(a1, a2, a3);
+    }
+
 private:

    F f_;
@@ -130,6 +145,11 @@ public:
        return f_(a1, a2, a3, a4);
    }

+    result_type operator()(A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        return f_(a1, a2, a3, a4);
+    }
+
 private:

    F f_;
@@ -139,31 +159,26 @@ private:

 template<class R, class F> _bi::af0<R, F> make_adaptable(F f)
 {
-    _bi::instantiate( &_bi::af0<R, F>::operator() ); // for early error detection
    return _bi::af0<R, F>(f);
 }

 template<class R, class A1, class F> _bi::af1<R, A1, F> make_adaptable(F f)
 {
-    instantiate( &_bi::af1<R, A1, F>::operator() );
    return _bi::af1<R, A1, F>(f);
 }

 template<class R, class A1, class A2, class F> _bi::af2<R, A1, A2, F> make_adaptable(F f)
 {
-    instantiate( &_bi::af2<R, A1, A2, F>::operator() );
    return _bi::af2<R, A1, A2, F>(f);
 }

 template<class R, class A1, class A2, class A3, class F> _bi::af3<R, A1, A2, A3, F> make_adaptable(F f)
 {
-    instantiate( &_bi::af3<R, A1, A2, A3, F>::operator() );
    return _bi::af3<R, A1, A2, A3, F>(f);
 }

 template<class R, class A1, class A2, class A3, class A4, class F> _bi::af4<R, A1, A2, A3, A4, F> make_adaptable(F f)
 {
-    instantiate( &_bi::af4<R, A1, A2, A3, A4, F>::operator() );
    return _bi::af4<R, A1, A2, A3, A4, F>(f);
 }

--- a/include/boost/bind/mem_fn_cc.hpp
+++ b/include/boost/bind/mem_fn_cc.hpp
@@ -5,10 +5,9 @@
 //
 //  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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //
 //  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
 //
--- a/include/boost/bind/mem_fn_template.hpp
+++ b/include/boost/bind/mem_fn_template.hpp
@@ -5,10 +5,9 @@
 //
 //  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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //
 //  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
 //
@@ -55,6 +54,16 @@ public:
    {
        BOOST_MEM_FN_RETURN (t.*f_)();
    }
+
+    bool operator==(BOOST_MEM_FN_NAME(mf0) const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(BOOST_MEM_FN_NAME(mf0) const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
 };

 // cmf0
@@ -94,6 +103,16 @@ public:
    {
        BOOST_MEM_FN_RETURN (t.*f_)();
    }
+
+    bool operator==(BOOST_MEM_FN_NAME(cmf0) const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(BOOST_MEM_FN_NAME(cmf0) const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
 };

 // mf1
@@ -139,6 +158,16 @@ public:
    {
        BOOST_MEM_FN_RETURN (t.*f_)(a1);
    }
+
+    bool operator==(BOOST_MEM_FN_NAME(mf1) const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(BOOST_MEM_FN_NAME(mf1) const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
 };

 // cmf1
@@ -179,6 +208,16 @@ public:
    {
        BOOST_MEM_FN_RETURN (t.*f_)(a1);
    }
+
+    bool operator==(BOOST_MEM_FN_NAME(cmf1) const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(BOOST_MEM_FN_NAME(cmf1) const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
 };

 // mf2
@@ -222,6 +261,16 @@ public:
    {
        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
    }
+
+    bool operator==(BOOST_MEM_FN_NAME(mf2) const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(BOOST_MEM_FN_NAME(mf2) const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
 };

 // cmf2
@@ -260,6 +309,16 @@ public:
    {
        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
    }
+
+    bool operator==(BOOST_MEM_FN_NAME(cmf2) const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(BOOST_MEM_FN_NAME(cmf2) const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
 };

 // mf3
@@ -303,6 +362,16 @@ public:
    {
        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
    }
+
+    bool operator==(BOOST_MEM_FN_NAME(mf3) const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(BOOST_MEM_FN_NAME(mf3) const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
 };

 // cmf3
@@ -341,6 +410,16 @@ public:
    {
        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
    }
+
+    bool operator==(BOOST_MEM_FN_NAME(cmf3) const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(BOOST_MEM_FN_NAME(cmf3) const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
 };

 // mf4
@@ -384,6 +463,16 @@ public:
    {
        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
    }
+
+    bool operator==(BOOST_MEM_FN_NAME(mf4) const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(BOOST_MEM_FN_NAME(mf4) const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
 };

 // cmf4
@@ -422,6 +511,16 @@ public:
    {
        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
    }
+
+    bool operator==(BOOST_MEM_FN_NAME(cmf4) const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(BOOST_MEM_FN_NAME(cmf4) const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
 };

 // mf5
@@ -465,6 +564,16 @@ public:
    {
        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
    }
+
+    bool operator==(BOOST_MEM_FN_NAME(mf5) const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(BOOST_MEM_FN_NAME(mf5) const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
 };

 // cmf5
@@ -503,6 +612,16 @@ public:
    {
        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
    }
+
+    bool operator==(BOOST_MEM_FN_NAME(cmf5) const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(BOOST_MEM_FN_NAME(cmf5) const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
 };

 // mf6
@@ -546,6 +665,16 @@ public:
    {
        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
    }
+
+    bool operator==(BOOST_MEM_FN_NAME(mf6) const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(BOOST_MEM_FN_NAME(mf6) const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
 };

 // cmf6
@@ -584,6 +713,16 @@ public:
    {
        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
    }
+
+    bool operator==(BOOST_MEM_FN_NAME(cmf6) const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(BOOST_MEM_FN_NAME(cmf6) const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
 };

 // mf7
@@ -627,6 +766,16 @@ public:
    {
        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
    }
+
+    bool operator==(BOOST_MEM_FN_NAME(mf7) const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(BOOST_MEM_FN_NAME(mf7) const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
 };

 // cmf7
@@ -665,6 +814,16 @@ public:
    {
        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
    }
+
+    bool operator==(BOOST_MEM_FN_NAME(cmf7) const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(BOOST_MEM_FN_NAME(cmf7) const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
 };

 // mf8
@@ -708,6 +867,16 @@ public:
    {
        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }
+
+    bool operator==(BOOST_MEM_FN_NAME(mf8) const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(BOOST_MEM_FN_NAME(mf8) const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
 };

 // cmf8
@@ -751,5 +920,15 @@ public:
    {
        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }
+
+    bool operator==(BOOST_MEM_FN_NAME(cmf8) const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(BOOST_MEM_FN_NAME(cmf8) const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
 };

--- a/include/boost/bind/mem_fn_vw.hpp
+++ b/include/boost/bind/mem_fn_vw.hpp
@@ -5,10 +5,9 @@
 //
 //  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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //
 //  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
 //
--- a/include/boost/bind/placeholders.hpp
+++ b/include/boost/bind/placeholders.hpp
@@ -1,8 +1,10 @@
 #ifndef BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED
 #define BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED

-#if _MSC_VER >= 1020
-#pragma once
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif

 //
@@ -10,10 +12,9 @@
 //
 //  Copyright (c) 2002 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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //
 //  See http://www.boost.org/libs/bind/bind.html for documentation.
 //
@@ -36,7 +37,7 @@ static inline boost::arg<7> _7() { return boost::arg<7>(); }
 static inline boost::arg<8> _8() { return boost::arg<8>(); }
 static inline boost::arg<9> _9() { return boost::arg<9>(); }

-#elif (defined(BOOST_MSVC) && BOOST_MSVC <= 1300) || (defined(__DECCXX_VER) && __DECCXX_VER <= 60590031) || defined(__MWERKS__)
+#elif defined(BOOST_MSVC) || (defined(__DECCXX_VER) && __DECCXX_VER <= 60590031) || defined(__MWERKS__)

 static boost::arg<1> _1;
 static boost::arg<2> _2;
--- a/include/boost/bind/protect.hpp
+++ b/include/boost/bind/protect.hpp
@@ -6,10 +6,9 @@
 //
 //  Copyright (c) 2002 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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //

 namespace boost
--- a/include/boost/mem_fn.hpp
+++ b/include/boost/mem_fn.hpp
@@ -1,8 +1,10 @@
 #ifndef BOOST_MEM_FN_HPP_INCLUDED
 #define BOOST_MEM_FN_HPP_INCLUDED

-#if _MSC_VER+0 >= 1020
-#pragma once
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif

 //
@@ -11,16 +13,16 @@
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //  Copyright (c) 2001 David Abrahams
 //
-//  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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //
 //  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
 //

 #include <boost/config.hpp>
 #include <boost/get_pointer.hpp>
+#include <boost/detail/workaround.hpp>

 namespace boost
 {
@@ -292,7 +294,7 @@ public:
        return call(u, &u);
    }

-#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1300)
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) && !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))

    R & operator()(T & t) const
    {
@@ -305,6 +307,16 @@ public:
    {
        return (t.*f_);
    }
+
+    bool operator==(dm const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(dm const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
 };

 } // namespace _mfi
--- a/mem_fn.html
+++ b/mem_fn.html
@@ -1,399 +1,9 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
 <html>
-	<head>
-		<title>Boost: mem_fn.hpp documentation</title>
-		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-	</head>
-	<body bgcolor="white" style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%">
-		<table border="0" width="100%">
-			<tr>
-				<td width="277">
-					<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86">
-				</td>
-				<td align="middle">
-					<h1>mem_fn.hpp</h1>
-				</td>
-			</tr>
-			<tr>
-				<td colspan="2" height="64">&nbsp;</td>
-			</tr>
-		</table>
-		<h2>Contents</h2>
-		<h3 style="MARGIN-LEFT: 20pt"><a href="#Purpose">Purpose</a></h3>
-		<h3 style="MARGIN-LEFT: 20pt"><a href="#FAQ">Frequently Asked Questions</a></h3>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#Q1">Can <b>mem_fn</b> be used instead of the 
-				standard <b>std::mem_fun[_ref]</b> adaptors?</a></h4>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#Q2">Should I replace every occurence of <b>std::mem_fun[_ref]</b>
-				with <b>mem_fn</b> in my existing code?</a></h4>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#Q3">Does <b>mem_fn</b> work with COM methods?</a></h4>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#Q4">Why isn't BOOST_MEM_FN_ENABLE_STDCALL 
-				defined automatically?</a></h4>
-		<h3 style="MARGIN-LEFT: 20pt"><a href="#Interface">Interface</a></h3>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#Synopsis">Synopsis</a></h4>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#CommonRequirements">Common requirements</a></h4>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#get_pointer">get_pointer</a></h4>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#mem_fn">mem_fn</a></h4>
-		<h3 style="MARGIN-LEFT: 20pt"><a href="#Implementation">Implementation</a></h3>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#Files">Files</a></h4>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#Dependencies">Dependencies</a></h4>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#NumberOfArguments">Number of Arguments</a></h4>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#stdcall">"__stdcall" and 
-				"__fastcall"&nbsp;Support</a></h4>
-		<h3 style="MARGIN-LEFT: 20pt"><a href="#Acknowledgements">Acknowledgements</a></h3>
-		<h2><a name="Purpose">Purpose</a></h2>
-		<p>
-			<b>boost::mem_fn</b> is a generalization of the standard functions <b>std::mem_fun</b>
-			and <b>std::mem_fun_ref</b>. It supports member function pointers with more 
-			than one argument, and the returned function object can take a pointer, a 
-			reference, or a smart pointer to an object instance as its first argument. <STRONG>mem_fn</STRONG>
-			also supports pointers to data members by treating them as functions taking no 
-			arguments and returning a (const) reference to the member.
-		</p>
-		<p>
-			The purpose of <b>mem_fn</b> is twofold. First, it allows users to invoke a 
-			member function on a container with the familiar
-		</p>
-		<pre>
-    std::for_each(v.begin(), v.end(), boost::mem_fn(&amp;Shape::draw));
-</pre>
-		<p>
-			syntax, even when the container stores smart pointers.
-		</p>
-		<p>
-			Second, it can be used as a building block by library developers that want to 
-			treat a pointer to member function as a function object. A library might define 
-			an enhanced <b>for_each</b> algorithm with an overload of the form:
-		</p>
-		<pre>
-template&lt;class It, class R, class T&gt; void for_each(It first, It last, R (T::*pmf) ())
-{
-    std::for_each(first, last, boost::mem_fn(pmf));
-}
-</pre>
-		<p>
-			that will allow the convenient syntax:
-		</p>
-		<pre>
-    for_each(v.begin(), v.end(), &amp;Shape::draw);
-</pre>
-		<p>
-			When documenting the feature, the library author will simply state:
-		</p>
-		<h4 style="MARGIN-LEFT: 20pt">template&lt;class It, class R, class T&gt; void 
-			for_each(It first, It last, R (T::*pmf) ());</h4>
-		<p style="MARGIN-LEFT: 20pt">
-			<b>Effects:</b> equivalent to std::for_each(first, last, boost::mem_fn(pmf));
-		</p>
-		<p>
-			where <b>boost::mem_fn</b> can be a link to this page. See <a href="bind.html">the 
-				documentation of <b>bind</b></a> for an example.
-		</p>
-		<p>
-			<b>mem_fn</b> takes one argument, a pointer to a member, and returns a function 
-			object suitable for use with standard or user-defined algorithms:
-		</p>
-		<pre>
-struct X
-{
-    void f();
-};
-
-void g(std::vector&lt;X&gt; &amp; v)
-{
-    std::for_each(v.begin(), v.end(), boost::mem_fn(&amp;X::f));
-};
-
-void h(std::vector&lt;X *&gt; const &amp; v)
-{
-    std::for_each(v.begin(), v.end(), boost::mem_fn(&amp;X::f));
-};
-
-void k(std::vector&lt;boost::shared_ptr&lt;X&gt; &gt; const &amp; v)
-{
-    std::for_each(v.begin(), v.end(), boost::mem_fn(&amp;X::f));
-};
-</pre>
-		<p>
-			The returned function object takes the same arguments as the input member 
-			function plus a "flexible" first argument that represents the object instance.
-		</p>
-		<p>
-			When the function object is invoked with a first argument <b>x</b> that is 
-			neither a pointer nor a reference to the appropriate class (<b>X</b> in the 
-			example above), it uses <tt>get_pointer(x)</tt> to obtain a pointer from <b>x</b>. 
-			Library authors can "register" their smart pointer classes by supplying an 
-			appropriate <b>get_pointer</b> overload, allowing <b>mem_fn</b> to recognize 
-			and support them.
-		</p>
-		<p>
-			[Note: <b>get_pointer</b> is not restricted to return a pointer. Any object 
-			that can be used in a member function call expression <tt>(x-&gt;*pmf)(...)</tt>
-			will work.]
-		</p>
-		<p>
-			[Note: the library uses an unqualified call to <b>get_pointer</b>. Therefore, 
-			it will find, through argument-dependent lookup, <b>get_pointer</b> overloads 
-			that are defined in the same namespace as the corresponding smart pointer 
-			class, in addition to any <b>boost::get_pointer</b> overloads.]
-		</p>
-		<p>
-			All function objects returned by <b>mem_fn</b> expose a <b>result_type</b> typedef 
-			that represents the return type of the member function. For data members, <STRONG>result_type</STRONG>
-			is defined as a const reference to the type of the member.
-		</p>
-		<h2><a name="FAQ">Frequently Asked Questions</a></h2>
-		<h3><a name="Q1">Can <b>mem_fn</b> be used instead of the standard <b>std::mem_fun[_ref]</b>
-				adaptors?</a></h3>
-		<p>
-			Yes. For simple uses, <b>mem_fn</b> provides additional functionality that the 
-			standard adaptors do not. Complicated expressions that use <b>std::bind1st</b>, <b>std::bind2nd</b>
-			or <a href="../compose/index.htm"><b>Boost.Compose</b></a> along with the 
-			standard adaptors can be rewritten using <a href="bind.html"><b>boost::bind</b></a>
-			that automatically takes advantage of <b>mem_fn</b>.
-		</p>
-		<h3><a name="Q2">Should I replace every occurence of <b>std::mem_fun[_ref]</b> with <b>mem_fn</b>
-				in my existing code?</a></h3>
-		<p>
-			No, unless you have good reasons to do so. <b>mem_fn</b> is not 100% compatible 
-			with the standard adaptors, although it comes pretty close. In particular, <b>mem_fn</b>
-			does not return objects of type <b>std::[const_]mem_fun[1][_ref]_t</b>, as the 
-			standard adaptors do, and it is not possible to fully describe the type of the 
-			first argument using the standard <b>argument_type</b> and <b>first_argument_type</b>
-			nested typedefs. Libraries that need adaptable function objects in order to 
-			function might not like <b>mem_fn</b>.
-		</p>
-		<h3><a name="Q3">Does <b>mem_fn</b> work with COM methods?</a></h3>
-		<p>
-			Yes, if you <a href="#stdcall">#define BOOST_MEM_FN_ENABLE_STDCALL</a>.
-		</p>
-		<h3><a name="Q4">Why isn't BOOST_MEM_FN_ENABLE_STDCALL defined automatically?</a></h3>
-		<p>
-			Non-portable extensions, in general, should default to off to prevent vendor 
-			lock-in. Had BOOST_MEM_FN_ENABLE_STDCALL been defined automatically, you could 
-			have accidentally taken advantage of it without realizing that your code is, 
-			perhaps, no longer portable.
-		</p>
-		<h2><a name="Interface">Interface</a></h2>
-		<h3><a name="Synopsis">Synopsis</a></h3>
-		<pre>
-namespace boost
-{
-
-template&lt;class T&gt; T * <a href="#get_pointer_1">get_pointer</a>(T * p);
-
-template&lt;class R, class T&gt; <i>unspecified-1</i> <a href="#mem_fn_1">mem_fn</a>(R (T::*pmf) ());
-
-template&lt;class R, class T&gt; <i>unspecified-2</i> <a href="#mem_fn_2">mem_fn</a>(R (T::*pmf) () const);
-
-template&lt;class R, class T&gt; <i>unspecified-2-1</i> <a href="#mem_fn_2_1">mem_fn</a>(R T::*pm);
-
-template&lt;class R, class T, class A1&gt; <i>unspecified-3</i> <a href="#mem_fn_3">mem_fn</a>(R (T::*pmf) (A1));
-
-template&lt;class R, class T, class A1&gt; <i>unspecified-4</i> <a href="#mem_fn_4">mem_fn</a>(R (T::*pmf) (A1) const);
-
-template&lt;class R, class T, class A1, class A2&gt; <i>unspecified-5</i> <a href="#mem_fn_5">mem_fn</a>(R (T::*pmf) (A1, A2));
-
-template&lt;class R, class T, class A1, class A2&gt; <i>unspecified-6</i> <a href="#mem_fn_6">mem_fn</a>(R (T::*pmf) (A1, A2) const);
-
-// implementation defined number of additional overloads for more arguments
-
-}
-</pre>
-		<h3><a name="CommonRequirements">Common requirements</a></h3>
-		<p>
-			All <tt><i>unspecified-N</i></tt> types mentioned in the Synopsis are <b>CopyConstructible</b>
-			and <b>Assignable</b>. Their copy constructors and assignment operators do not 
-			throw exceptions. <tt><i>unspecified-N</i>::result_type</tt> is defined as the 
-			return type of the member function pointer passed as an argument to <b>mem_fn</b>
-			(<b>R</b> in the Synopsis.) <tt><i>unspecified-2-1</i>::result_type</tt> is 
-			defined as <tt>R const &amp;</tt>.
-		</p>
-		<h3><a name="get_pointer">get_pointer</a></h3>
-		<h4><a name="get_pointer_1">template&lt;class T&gt; T * get_pointer(T * p)</a></h4>
-		<blockquote>
-			<p>
-				<b>Returns:</b> <tt>p</tt>.
-			</p>
-			<p>
-				<b>Throws:</b> Nothing.
-			</p>
-		</blockquote>
-		<h3><a name="mem_fn">mem_fn</a></h3>
-		<h4><a name="mem_fn_1">template&lt;class R, class T&gt; <i>unspecified-1</i> mem_fn(R 
-				(T::*pmf) ())</a></h4>
-		<blockquote>
-			<p>
-				<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t)</i></tt>
-				is equivalent to <tt>(t.*pmf)()</tt> when <i>t</i> is an l-value of type <STRONG>T </STRONG>
-				or derived, <tt>(get_pointer(t)-&gt;*pmf)()</tt> otherwise.
-			</p>
-			<p>
-				<b>Throws:</b> Nothing.
-			</p>
-		</blockquote>
-		<h4><a name="mem_fn_2">template&lt;class R, class T&gt; <i>unspecified-2</i> mem_fn(R 
-				(T::*pmf) () const)</a></h4>
-		<blockquote>
-			<p>
-				<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t)</i></tt>
-				is equivalent to <tt>(t.*pmf)()</tt> when <i>t</i> is of type <STRONG>T</STRONG>
-				<EM>[const]<STRONG> </STRONG></EM>or derived, <tt>(get_pointer(t)-&gt;*pmf)()</tt>
-				otherwise.
-			</p>
-			<p>
-				<b>Throws:</b> Nothing.
-			</p>
-		</blockquote>
-		<h4><a name="mem_fn_2_1">template&lt;class R, class T&gt; <i>unspecified-2-1</i> mem_fn(R 
-				T::*pm)</a></h4>
-		<blockquote>
-			<p>
-				<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t)</i></tt>
-				is equivalent to <tt>t.*pm</tt> when <i>t</i> is of type <STRONG>T</STRONG> <EM>[const]<STRONG>
-					</STRONG></EM>or derived, <tt>get_pointer(t)-&gt;*pm</tt> otherwise.
-			</p>
-			<p>
-				<b>Throws:</b> Nothing.
-			</p>
-		</blockquote>
-		<h4><a name="mem_fn_3">template&lt;class R, class T, class A1&gt; <i>unspecified-3</i> mem_fn(R 
-				(T::*pmf) (A1))</a></h4>
-		<blockquote>
-			<p>
-				<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t, a1)</i></tt>
-				is equivalent to <tt>(t.*pmf)(a1)</tt> when <i>t</i> is an l-value of type <STRONG>T
-				</STRONG>or derived, <tt>(get_pointer(t)-&gt;*pmf)(a1)</tt> otherwise.
-			</p>
-			<p>
-				<b>Throws:</b> Nothing.
-			</p>
-		</blockquote>
-		<h4><a name="mem_fn_4">template&lt;class R, class T, class A1&gt; <i>unspecified-4</i> mem_fn(R 
-				(T::*pmf) (A1) const)</a></h4>
-		<blockquote>
-			<p>
-				<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t, a1)</i></tt>
-				is equivalent to <tt>(t.*pmf)(a1)</tt> when <i>t</i> is of type <STRONG>T</STRONG>
-				<EM>[const]<STRONG> </STRONG></EM>or derived, <tt>(get_pointer(t)-&gt;*pmf)(a1)</tt>
-				otherwise.
-			</p>
-			<p>
-				<b>Throws:</b> Nothing.
-			</p>
-		</blockquote>
-		<h4><a name="mem_fn_5">template&lt;class R, class T, class A1, class A2&gt; <i>unspecified-5</i>
-				mem_fn(R (T::*pmf) (A1, A2))</a></h4>
-		<blockquote>
-			<p>
-				<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t, a1, a2)</i></tt>
-				is equivalent to <tt>(t.*pmf)(a1, a2)</tt> when <i>t</i> is an l-value of type <STRONG>
-					T</STRONG> or derived, <tt>(get_pointer(t)-&gt;*pmf)(a1, a2)</tt> otherwise.
-			</p>
-			<p>
-				<b>Throws:</b> Nothing.
-			</p>
-		</blockquote>
-		<h4><a name="mem_fn_6">template&lt;class R, class T, class A1, class A2&gt; <i>unspecified-6</i>
-				mem_fn(R (T::*pmf) (A1, A2) const)</a></h4>
-		<blockquote>
-			<p>
-				<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t, a1, a2)</i></tt>
-				is equivalent to <tt>(t.*pmf)(a1, a2)</tt> when <i>t</i> is of type <STRONG>T</STRONG>
-				<EM>[const]</EM> or derived, <tt>(get_pointer(t)-&gt;*pmf)(a1, a2)</tt> otherwise.
-			</p>
-			<p>
-				<b>Throws:</b> Nothing.
-			</p>
-		</blockquote>
-		<h2><a name="Implementation">Implementation</a></h2>
-		<h3><a name="Files">Files</a></h3>
-		<ul>
-			<li>
-				<a href="../../boost/mem_fn.hpp">boost/mem_fn.hpp</a>
-			(main header)
-			<li>
-				<a href="../../boost/bind/mem_fn_cc.hpp">boost/bind/mem_fn_cc.hpp</a>
-			(used by mem_fn.hpp, do not include directly)
-			<li>
-				<a href="../../boost/bind/mem_fn_vw.hpp">boost/bind/mem_fn_vw.hpp</a>
-			(used by mem_fn.hpp, do not include directly)
-			<li>
-				<a href="../../boost/bind/mem_fn_template.hpp">boost/bind/mem_fn_template.hpp</a>
-			(used by mem_fn.hpp, do not include directly)
-			<li>
-				<a href="test/mem_fn_test.cpp">libs/bind/test/mem_fn_test.cpp</a>
-			(test)
-			<li>
-				<a href="test/mem_fn_derived_test.cpp">libs/bind/test/mem_fn_derived_test.cpp</a>
-			(test with derived objects)
-			<li>
-				<a href="test/mem_fn_fastcall_test.cpp">libs/bind/test/mem_fn_fastcall_test.cpp</a>
-			(test for __fastcall)
-			<li>
-				<a href="test/mem_fn_stdcall_test.cpp">libs/bind/test/mem_fn_stdcall_test.cpp</a>
-			(test for __stdcall)
-			<li>
-				<a href="test/mem_fn_void_test.cpp">libs/bind/test/mem_fn_void_test.cpp</a> (test for 
-				void returns)</li>
-		</ul>
-		<h3><a name="Dependencies">Dependencies</a></h3>
-		<ul>
-			<li>
-				<a href="../config/config.htm">Boost.Config</a></li>
-		</ul>
-		<h3><a name="NumberOfArguments">Number of Arguments</a></h3>
-		<p>
-			This implementation supports member functions with up to eight arguments. This 
-			is not an inherent limitation of the design, but an implementation detail.
-		</p>
-		<h3><a name="stdcall">"__stdcall" and "__fastcall" Support</a></h3>
-		<p>
-			Some platforms allow several types of member functions that differ by their <b>calling 
-				convention</b> (the rules by which the function is invoked: how are 
-			arguments passed, how is the return value handled, and who cleans up the stack 
-			- if any.)
-		</p>
-		<p>
-			For example, Windows API functions and COM interface member functions use a 
-			calling convention known as <b>__stdcall</b>. Borland VCL components use <STRONG>__fastcall</STRONG>.
-		</p>
-		<p>
-			To use <b>mem_fn</b> with <b>__stdcall</b> member functions, <b>#define</b> the 
-			macro <b>BOOST_MEM_FN_ENABLE_STDCALL</b> before including, directly or 
-			indirectly, <b>&lt;boost/mem_fn.hpp&gt;</b>.
-		</p>
-		<P>To use <B>mem_fn</B> with <B>__fastcall</B> member functions, <B>#define</B> the 
-			macro <B>BOOST_MEM_FN_ENABLE_FASTCALL</B> before including, directly or 
-			indirectly, <B>&lt;boost/mem_fn.hpp&gt;</B>.
-		</P>
-		<P>[Note: this is a non-portable extension. It is not part of the interface.]
-		</P>
-		<p>
-			[Note: Some compilers provide only minimal support for the <b>__stdcall</b> keyword.]
-		</p>
-		<h2><a name="Acknowledgements">Acknowledgements</a></h2>
-		<p>
-			Rene Jager's initial suggestion of using traits classes to make <b>mem_fn</b> adapt 
-			to user-defined smart pointers inspired the <b>get_pointer</b>-based design.
-		</p>
-		<p>
-			Numerous improvements were suggested during the formal review period by Richard 
-			Crossley, Jens Maurer, Ed Brey, and others. Review manager was Darin Adler.
-		</p>
-		<p>
-			Steve Anichini pointed out that COM interfaces use <b>__stdcall</b>.
-		</p>
-		<p>
-			Dave Abrahams modified <b>bind</b> and <b>mem_fn</b> to support void returns on 
-			deficient compilers.
-		</p>
-		<p><br>
-			<br>
-			<br>
-			<small>Copyright © 2001, 2002&nbsp;by Peter Dimov and Multi Media Ltd. Permission 
-				to copy, use, modify, sell and distribute this document is granted provided 
-				this copyright notice appears in all copies. This document is provided "as is" 
-				without express or implied warranty, and with no claim as to its suitability 
-				for any purpose.</small></p>
-	</body>
+<head>
+<meta http-equiv="refresh" content="0; URL=../bind/mem_fn.html">
+</head>
+<body>
+Automatic redirection failed, please go to
+<a href="../bind/mem_fn.html">../bind/mem_fn.html</a>.
+</body>
 </html>
--- a/ref.html
+++ b/ref.html
@@ -1,195 +1,9 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
 <html>
-	<head>
-		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-		<title>Boost: ref.hpp documentation</title>
-	</head>
-	<body bgcolor="White">
-		<table border="0" width="100%">
-			<tr>
-				<td width="277">
-					<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86">
-				</td>
-				<td align="center">
-					<table border="0">
-						<tr>
-							<td nowrap><h1>ref.hpp</h1>
-							</td>
-						</tr>
-						<tr>
-							<td align="right" nowrap><small>&nbsp;1.00.0004 (2002-01-27)</small></td>
-						</tr>
-					</table>
-				</td>
-			</tr>
-			<tr>
-				<td colspan="2" height="64">&nbsp;</td>
-			</tr>
-		</table>
-		<h2>Files</h2>
-		<ul>
-			<li>
-				<a href="../../boost/ref.hpp">ref.hpp</a>
-		</ul>
-		<h2>Purpose</h2>
-		<p>
-			The header <a href="../../boost/ref.hpp">boost/ref.hpp</a> defines the class 
-			template <b>boost::reference_wrapper&lt;T&gt;</b>, the two functions <b>boost::ref</b>
-			and <b>boost::cref</b> that return instances of <b>boost::reference_wrapper&lt;T&gt;</b>, 
-			and the two traits classes <b>boost::is_reference_wrapper&lt;T&gt;</b> and <b>boost::unwrap_reference&lt;T&gt;</b>.
-		</p>
-		<p>
-			The purpose of <b>boost::reference_wrapper&lt;T&gt;</b> is to contain a 
-			reference to an object of type <b>T</b>. It is primarily used to "feed" 
-			references to function templates (algorithms) that take their parameter by 
-			value.
-		</p>
-		<p>
-			To support this usage, <b>boost::reference_wrapper&lt;T&gt;</b> provides an 
-			implicit conversion to <b>T &amp;</b>. This usually allows the function 
-			templates to work on references unmodified.
-		</p>
-		<p>
-			<b>boost::reference_wrapper&lt;T&gt;</b> is both <b>CopyConstructible</b> and <b>Assignable</b>
-			(ordinary references are not <b>Assignable</b>).
-		</p>
-		<p>
-			The expression <b>boost::ref(x)</b> returns a <b>boost::reference_wrapper&lt;X&gt;(x)</b>
-			where <b>X</b> is the type of <b>x</b>. Similarly, <b>boost::cref(x)</b> returns 
-			a <b>boost::reference_wrapper&lt;X const&gt;(x)</b>.
-		</p>
-		<p>
-			The expression <b>boost::is_reference_wrapper&lt;T&gt;::value</b> is <b>true</b> 
-			if <b>T</b> is a <b>reference_wrapper</b>, and <b>false</b>
-			otherwise.
-		</p>
-		<p>
-			The type-expression <b>boost::unwrap_reference&lt;T&gt;::type</b> is <b>T::type</b>
-			if <b>T</b> is a <b>reference_wrapper</b>, <b>T</b> otherwise.
-		</p>
-			<h2>Interface</h2>
-			<h3>Synopsis</h3>
-			<pre>
-namespace boost
-{
-    template&lt;class T&gt; class <a href="#reference_wrapper">reference_wrapper</a>;
-    template&lt;class T&gt; reference_wrapper&lt;T&gt; <a href="#ref">ref</a>(T &amp; t);
-    template&lt;class T&gt; reference_wrapper&lt;T const&gt; <a href="#cref">cref</a>(T const &amp; t);
-    template&lt;class T&gt; class is_reference_wrapper&lt;T const&gt;;
-    template&lt;class T&gt; class unwrap_reference&lt;T const&gt;;
-}
-</pre>
-			<h3><a name="reference_wrapper">reference_wrapper</a></h3>
-			<pre>
-template&lt;class T&gt; class reference_wrapper
-{
-public:
-    typedef T type;
-
-    explicit <a href="#rt_construct">reference_wrapper</a>(T &amp; t);
-
-    <a href="#rt_operator">operator T &amp;</a> () const;
-
-    T &amp; <a href="#rt_get">get</a>() const;
-    T* <a href="#rt_get_pointer">get_pointer</a>() const;
-};
-</pre>
-			<h4><a name="rt_construct">explicit reference_wrapper(T &amp; t)</a></h4>
-			<blockquote>
-				<p>
-					<b>Effects:</b> Constructs a <b>reference_wrapper</b> object that stores a 
-					reference to <b>t</b>.
-				</p>
-				<p>
-					<b>Throws:</b> Nothing.
-				</p>
-			</blockquote>
-			<h4><a name="rt_operator">operator T &amp; () const</a></h4>
-			<blockquote>
-				<p>
-					<b>Returns:</b> the stored reference.
-				</p>
-				<p>
-					<b>Throws:</b> Nothing.
-				</p>
-			</blockquote>
-			<h4><a name="rt_get">T &amp; get() const</a></h4>
-			<blockquote>
-				<p>
-					<b>Returns:</b> the stored reference.
-				</p>
-				<p>
-					<b>Throws:</b> Nothing.
-				</p>
-			</blockquote>
-<h4><a name="rt_get_pointer">T* get_pointer() const</a></h4>
-			<blockquote>
-				<p>
-					<b>Returns:</b> a pointer to the stored object.
-				</p>
-				<p>
-					<b>Throws:</b> Nothing.
-				</p>
-			</blockquote>
-			<h3><a name="ref">ref</a></h3>
-			<pre>
-template&lt;class T&gt; reference_wrapper&lt;T&gt; ref(T &amp; t);
-</pre>
-			<blockquote>
-				<p>
-					<b>Returns:</b> <tt>reference_wrapper&lt;T&gt;(t)</tt>.
-				</p>
-				<p>
-					<b>Throws:</b> Nothing.
-				</p>
-			</blockquote>
-			<h3><a name="cref">cref</a></h3>
-			<pre>
-template&lt;class T&gt; reference_wrapper&lt;T const&gt; cref(T const &amp; t);
-</pre>
-			<blockquote>
-				<p>
-					<b>Returns:</b> <tt>reference_wrapper&lt;T const&gt;(t)</tt>.
-				</p>
-				<p>
-					<b>Throws:</b> Nothing.
-				</p>
-			</blockquote>
-			<h3><a name="is_reference_wrapper">is_reference_wrapper</a></h3>
-			<pre>
-template&lt;class T&gt; class is_reference_wrapper&lt;T const&gt;
-{
- public:
-    static bool value = <i>unspecified</i>;
-};
-</pre>
-			Value is <b>true</b> iff <tt>T</tt> is a specialization of <tt>reference_wrapper</tt>.
-			<h3><a name="unwrap_reference">unwrap_reference</a></h3>
-			<pre>
-template&lt;class T&gt; class unwrap_reference&lt;T const&gt;
-{
- public:
-    typedef <i>unspecified</i> type;
-};
-</pre>
-			<tt>type</tt> is equivalent to <tt>T::type</tt> if <tt>T</tt> is a 
-			specialization of <tt>reference_wrapper</tt>. Otherwise <tt>type</tt> is 
-			equivalent to <tt>T</tt>.
-			<h2>Acknowledgements</h2>
-		<p>
-			<b>ref</b> and <b>cref</b> were originally part of the Boost.Tuple library by <a href="../../people/jaakko_jarvi.htm">
-				Jaakko J&auml;rvi</a>. They were "promoted to <b>boost::</b> status" by <a href="../../people/peter_dimov.htm">
-				Peter Dimov</a> because they are generally useful. <a href="../../people/doug_gregor.html">
-				Douglas Gregor</a> and <a href="../../people/dave_abrahams.htm">Dave Abrahams</a>
-			contributed <tt>is_reference_wrapper</tt> and <tt>unwrap_reference</tt>.
-		</p>
-		<p><br>
-			<br>
-			<br>
-			<small>Copyright &copy; 2001 by Peter Dimov and Multi Media Ltd. Permission to 
-				copy, use, modify, sell and distribute this document is granted provided this 
-				copyright notice appears in all copies. This document is provided &quot;as 
-				is&quot; without express or implied warranty, and with no claim as to its 
-				suitability for any purpose.</small></p>
-	</body>
+<head>
+<meta http-equiv="refresh" content="0; URL=../../doc/html/ref.html">
+</head>
+<body>
+Automatic redirection failed, please go to
+<a href="../../doc/html/ref.html">../../doc/html/ref.html</a>
+</body>
 </html>
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -1,6 +1,6 @@
 #  Boost.Bind Library test Jamfile
 #
-#  Copyright (c) 2003 Peter Dimov
+#  Copyright (c) 2003, 2004 Peter Dimov
 #
 #  Permission to copy, use, modify, sell and distribute this software
 #  is granted provided this copyright notice appears in all copies.
@@ -10,8 +10,7 @@
 subproject libs/bind/test ;

 # bring in rules for testing
-SEARCH on testing.jam = $(BOOST_BUILD_PATH) ;
-include testing.jam ;
+import testing ;

 # Make tests run by default.
 DEPENDS all : bind ;
@@ -19,8 +18,13 @@ DEPENDS all : bind ;
 {
    test-suite "bind"
        : [ run bind_test.cpp ]
+          [ run bind_eq_test.cpp ]
+          [ run bind_const_test.cpp ]
+          [ run bind_cv_test.cpp ]
+          [ run bind_stateful_test.cpp ]
          [ run mem_fn_test.cpp ]
          [ run mem_fn_void_test.cpp ]
          [ run mem_fn_derived_test.cpp ]
+          [ run mem_fn_eq_test.cpp ]
        ;
 }
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -0,0 +1,24 @@
+#  Boost.Bind Library test Jamfile
+#
+#  Copyright (c) 2003, 2004 Peter Dimov
+#
+#  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.
+
+# bring in rules for testing
+import testing ;
+
+test-suite "bind"
+    : [ run bind_test.cpp ]
+      [ run bind_eq_test.cpp ]
+      [ run bind_const_test.cpp ]
+      [ run bind_cv_test.cpp ]
+      [ run bind_stateful_test.cpp ]
+      [ run mem_fn_test.cpp ]
+      [ run mem_fn_void_test.cpp ]
+      [ run mem_fn_derived_test.cpp ]
+      [ run mem_fn_eq_test.cpp ]
+    ;
+
--- a/test/bind_const_test.cpp
+++ b/test/bind_const_test.cpp
@@ -0,0 +1,184 @@
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
+#pragma warning(disable: 4786)  // identifier truncated in debug info
+#pragma warning(disable: 4710)  // function not inlined
+#pragma warning(disable: 4711)  // function selected for automatic inline expansion
+#pragma warning(disable: 4514)  // unreferenced inline removed
+#endif
+
+//
+//  bind_const_test.cpp - test const bind objects
+//
+//  Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2001 David Abrahams
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/bind.hpp>
+#include <boost/ref.hpp>
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+#pragma warning(push, 3)
+#endif
+
+#include <iostream>
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+#pragma warning(pop)
+#endif
+
+#include <boost/detail/lightweight_test.hpp>
+
+//
+
+long f_0()
+{
+    return 17041L;
+}
+
+long f_1(long a)
+{
+    return a;
+}
+
+long f_2(long a, long b)
+{
+    return a + 10 * b;
+}
+
+long f_3(long a, long b, long c)
+{
+    return a + 10 * b + 100 * c;
+}
+
+long f_4(long a, long b, long c, long d)
+{
+    return a + 10 * b + 100 * c + 1000 * d;
+}
+
+long f_5(long a, long b, long c, long d, long e)
+{
+    return a + 10 * b + 100 * c + 1000 * d + 10000 * e;
+}
+
+long f_6(long a, long b, long c, long d, long e, long f)
+{
+    return a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f;
+}
+
+long f_7(long a, long b, long c, long d, long e, long f, long g)
+{
+    return a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g;
+}
+
+long f_8(long a, long b, long c, long d, long e, long f, long g, long h)
+{
+    return a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g + 10000000 * h;
+}
+
+long f_9(long a, long b, long c, long d, long e, long f, long g, long h, long i)
+{
+    return a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g + 10000000 * h + 100000000 * i;
+}
+
+long global_result;
+
+void fv_0()
+{
+    global_result = 17041L;
+}
+
+void fv_1(long a)
+{
+    global_result = a;
+}
+
+void fv_2(long a, long b)
+{
+    global_result = a + 10 * b;
+}
+
+void fv_3(long a, long b, long c)
+{
+    global_result = a + 10 * b + 100 * c;
+}
+
+void fv_4(long a, long b, long c, long d)
+{
+    global_result = a + 10 * b + 100 * c + 1000 * d;
+}
+
+void fv_5(long a, long b, long c, long d, long e)
+{
+    global_result = a + 10 * b + 100 * c + 1000 * d + 10000 * e;
+}
+
+void fv_6(long a, long b, long c, long d, long e, long f)
+{
+    global_result = a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f;
+}
+
+void fv_7(long a, long b, long c, long d, long e, long f, long g)
+{
+    global_result = a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g;
+}
+
+void fv_8(long a, long b, long c, long d, long e, long f, long g, long h)
+{
+    global_result = a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g + 10000000 * h;
+}
+
+void fv_9(long a, long b, long c, long d, long e, long f, long g, long h, long i)
+{
+    global_result = a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g + 10000000 * h + 100000000 * i;
+}
+
+template<class F, class A> long test(F const & f, A const & a)
+{
+    return f(a);
+}
+
+template<class F, class A> long testv(F const & f, A const & a)
+{
+    f(a);
+    return global_result;
+}
+
+void function_test()
+{
+    using namespace boost;
+
+    int const i = 1;
+
+    BOOST_TEST( test( bind(f_0), i ) == 17041L );
+    BOOST_TEST( test( bind(f_1, _1), i ) == 1L );
+    BOOST_TEST( test( bind(f_2, _1, 2), i ) == 21L );
+    BOOST_TEST( test( bind(f_3, _1, 2, 3), i ) == 321L );
+    BOOST_TEST( test( bind(f_4, _1, 2, 3, 4), i ) == 4321L );
+    BOOST_TEST( test( bind(f_5, _1, 2, 3, 4, 5), i ) == 54321L );
+    BOOST_TEST( test( bind(f_6, _1, 2, 3, 4, 5, 6), i ) == 654321L );
+    BOOST_TEST( test( bind(f_7, _1, 2, 3, 4, 5, 6, 7), i ) == 7654321L );
+    BOOST_TEST( test( bind(f_8, _1, 2, 3, 4, 5, 6, 7, 8), i ) == 87654321L );
+    BOOST_TEST( test( bind(f_9, _1, 2, 3, 4, 5, 6, 7, 8, 9), i ) == 987654321L );
+
+    BOOST_TEST( testv( bind(fv_0), i ) == 17041L );
+    BOOST_TEST( testv( bind(fv_1, _1), i ) == 1L );
+    BOOST_TEST( testv( bind(fv_2, _1, 2), i ) == 21L );
+    BOOST_TEST( testv( bind(fv_3, _1, 2, 3), i ) == 321L );
+    BOOST_TEST( testv( bind(fv_4, _1, 2, 3, 4), i ) == 4321L );
+    BOOST_TEST( testv( bind(fv_5, _1, 2, 3, 4, 5), i ) == 54321L );
+    BOOST_TEST( testv( bind(fv_6, _1, 2, 3, 4, 5, 6), i ) == 654321L );
+    BOOST_TEST( testv( bind(fv_7, _1, 2, 3, 4, 5, 6, 7), i ) == 7654321L );
+    BOOST_TEST( testv( bind(fv_8, _1, 2, 3, 4, 5, 6, 7, 8), i ) == 87654321L );
+    BOOST_TEST( testv( bind(fv_9, _1, 2, 3, 4, 5, 6, 7, 8, 9), i ) == 987654321L );
+}
+
+int main()
+{
+    function_test();
+    return boost::report_errors();
+}
--- a/test/bind_cv_test.cpp
+++ b/test/bind_cv_test.cpp
@@ -0,0 +1,158 @@
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
+#pragma warning(disable: 4786)  // identifier truncated in debug info
+#pragma warning(disable: 4710)  // function not inlined
+#pragma warning(disable: 4711)  // function selected for automatic inline expansion
+#pragma warning(disable: 4514)  // unreferenced inline removed
+#endif
+
+//
+//  bind_cv_test.cpp
+//
+//  Copyright (c) 2004 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/bind.hpp>
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+#pragma warning(push, 3)
+#endif
+
+#include <iostream>
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+#pragma warning(pop)
+#endif
+
+#include <boost/detail/lightweight_test.hpp>
+
+struct X
+{
+    int operator()()
+    {
+        return 17041;
+    }
+
+    int operator()() const
+    {
+        return -17041;
+    }
+
+    int operator()(int x1)
+    {
+        return x1;
+    }
+
+    int operator()(int x1) const
+    {
+        return -x1;
+    }
+
+    int operator()(int x1, int x2)
+    {
+        return x1+x2;
+    }
+
+    int operator()(int x1, int x2) const
+    {
+        return -(x1+x2);
+    }
+
+    int operator()(int x1, int x2, int x3)
+    {
+        return x1+x2+x3;
+    }
+
+    int operator()(int x1, int x2, int x3) const
+    {
+        return -(x1+x2+x3);
+    }
+
+    int operator()(int x1, int x2, int x3, int x4)
+    {
+        return x1+x2+x3+x4;
+    }
+
+    int operator()(int x1, int x2, int x3, int x4) const
+    {
+        return -(x1+x2+x3+x4);
+    }
+
+    int operator()(int x1, int x2, int x3, int x4, int x5)
+    {
+        return x1+x2+x3+x4+x5;
+    }
+
+    int operator()(int x1, int x2, int x3, int x4, int x5) const
+    {
+        return -(x1+x2+x3+x4+x5);
+    }
+
+    int operator()(int x1, int x2, int x3, int x4, int x5, int x6)
+    {
+        return x1+x2+x3+x4+x5+x6;
+    }
+
+    int operator()(int x1, int x2, int x3, int x4, int x5, int x6) const
+    {
+        return -(x1+x2+x3+x4+x5+x6);
+    }
+
+    int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7)
+    {
+        return x1+x2+x3+x4+x5+x6+x7;
+    }
+
+    int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7) const
+    {
+        return -(x1+x2+x3+x4+x5+x6+x7);
+    }
+
+    int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8)
+    {
+        return x1+x2+x3+x4+x5+x6+x7+x8;
+    }
+
+    int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8) const
+    {
+        return -(x1+x2+x3+x4+x5+x6+x7+x8);
+    }
+
+    int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8, int x9)
+    {
+        return x1+x2+x3+x4+x5+x6+x7+x8+x9;
+    }
+
+    int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8, int x9) const
+    {
+        return -(x1+x2+x3+x4+x5+x6+x7+x8+x9);
+    }
+};
+
+template<class F> void test(F f, int r)
+{
+    F const & cf = f;
+    BOOST_TEST( cf() == -r );
+    BOOST_TEST( f() == r );
+}
+
+int main()
+{
+    test( boost::bind<int>( X() ), 17041 );
+    test( boost::bind<int>( X(), 1 ), 1 );
+    test( boost::bind<int>( X(), 1, 2 ), 1+2 );
+    test( boost::bind<int>( X(), 1, 2, 3 ), 1+2+3 );
+    test( boost::bind<int>( X(), 1, 2, 3, 4 ), 1+2+3+4 );
+    test( boost::bind<int>( X(), 1, 2, 3, 4, 5 ), 1+2+3+4+5 );
+    test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6 ), 1+2+3+4+5+6 );
+    test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7 ), 1+2+3+4+5+6+7 );
+    test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7, 8 ), 1+2+3+4+5+6+7+8 );
+    test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7, 8, 9 ), 1+2+3+4+5+6+7+8+9 );
+
+    return boost::report_errors();
+}
--- a/test/bind_eq_test.cpp
+++ b/test/bind_eq_test.cpp
@@ -0,0 +1,413 @@
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
+#pragma warning(disable: 4786)  // identifier truncated in debug info
+#pragma warning(disable: 4710)  // function not inlined
+#pragma warning(disable: 4711)  // function selected for automatic inline expansion
+#pragma warning(disable: 4514)  // unreferenced inline removed
+#endif
+
+//
+//  bind_eq_test.cpp - boost::bind equality operator
+//
+//  Copyright (c) 2004 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/bind.hpp>
+#include <boost/ref.hpp>
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+#pragma warning(push, 3)
+#endif
+
+#include <iostream>
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+#pragma warning(pop)
+#endif
+
+#include <boost/detail/lightweight_test.hpp>
+
+struct X
+{
+    int i_;
+
+    explicit X(int i): i_(i)
+    {
+    }
+
+    bool operator==(X const & rhs) const
+    {
+        return i_ == rhs.i_;
+    }
+};
+
+// f_*
+
+int f_0()
+{
+    return 0;
+}
+
+int f_1(X)
+{
+    return 0;
+}
+
+int f_2(X, X)
+{
+    return 0;
+}
+
+int f_3(X, X, X)
+{
+    return 0;
+}
+
+int f_4(X, X, X, X)
+{
+    return 0;
+}
+
+int f_5(X, X, X, X, X)
+{
+    return 0;
+}
+
+int f_6(X, X, X, X, X, X)
+{
+    return 0;
+}
+
+int f_7(X, X, X, X, X, X, X)
+{
+    return 0;
+}
+
+int f_8(X, X, X, X, X, X, X, X)
+{
+    return 0;
+}
+
+int f_9(X, X, X, X, X, X, X, X, X)
+{
+    return 0;
+}
+
+// fv_*
+
+void fv_0()
+{
+}
+
+void fv_1(X)
+{
+}
+
+void fv_2(X, X)
+{
+}
+
+void fv_3(X, X, X)
+{
+}
+
+void fv_4(X, X, X, X)
+{
+}
+
+void fv_5(X, X, X, X, X)
+{
+}
+
+void fv_6(X, X, X, X, X, X)
+{
+}
+
+void fv_7(X, X, X, X, X, X, X)
+{
+}
+
+void fv_8(X, X, X, X, X, X, X, X)
+{
+}
+
+void fv_9(X, X, X, X, X, X, X, X, X)
+{
+}
+
+template<class F> void test_eq(F f1, F f2)
+{
+    BOOST_TEST(f1 == f2);
+    BOOST_TEST(!(f1 != f2));
+}
+
+template<class F> void test_ne(F f1, F f2)
+{
+    BOOST_TEST(f1 != f2);
+    BOOST_TEST(!(f1 == f2));
+}
+
+// 0
+
+template<class F> void test_0(F f)
+{
+    test_eq( boost::bind(f), boost::bind(f) );
+}
+
+// 1
+
+template<class F, class V> void test_1_(F f, V v1, V v2)
+{
+    test_eq( boost::bind(f, v1), boost::bind(f, v1) );
+    test_ne( boost::bind(f, v1), boost::bind(f, v2) );
+}
+
+template<class F> void test_1(F f)
+{
+    test_eq( boost::bind(f, _1), boost::bind(f, _1) );
+
+    test_1_( f, X(1), X(2) );
+
+    X a(0), b(0);
+    test_1_( f, boost::ref(a), boost::ref(b) );
+}
+
+// 2
+
+template<class F, class V> void test_2_(F f, V v1, V v2)
+{
+    test_eq( boost::bind(f, v1, v1), boost::bind(f, v1, v1) );
+    test_ne( boost::bind(f, v1, v1), boost::bind(f, v1, v2) );
+    test_ne( boost::bind(f, v1, v1), boost::bind(f, v2, v1) );
+}
+
+template<class F> void test_2(F f)
+{
+    test_eq( boost::bind(f, _1, _2), boost::bind(f, _1, _2) );
+
+    test_2_( f, X(1), X(2) );
+
+    X a(0), b(0);
+    test_2_( f, boost::ref(a), boost::ref(b) );
+}
+
+// 3
+
+template<class F, class V> void test_3_(F f, V v1, V v2)
+{
+    test_eq( boost::bind(f, v1, v1, v1), boost::bind(f, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1), boost::bind(f, v1, v1, v2) );
+    test_ne( boost::bind(f, v1, v1, v1), boost::bind(f, v1, v2, v1) );
+    test_ne( boost::bind(f, v1, v1, v1), boost::bind(f, v2, v1, v1) );
+}
+
+template<class F> void test_3(F f)
+{
+    test_eq( boost::bind(f, _1, _2, _3), boost::bind(f, _1, _2, _3) );
+
+    test_3_( f, X(1), X(2) );
+
+    X a(0), b(0);
+    test_3_( f, boost::ref(a), boost::ref(b) );
+}
+
+// 4
+
+template<class F, class V> void test_4_(F f, V v1, V v2)
+{
+    test_eq( boost::bind(f, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v2) );
+    test_ne( boost::bind(f, v1, v1, v1, v1), boost::bind(f, v1, v1, v2, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1), boost::bind(f, v1, v2, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1), boost::bind(f, v2, v1, v1, v1) );
+}
+
+template<class F> void test_4(F f)
+{
+    test_eq( boost::bind(f, _1, _2, _3, _4), boost::bind(f, _1, _2, _3, _4) );
+
+    test_4_( f, X(1), X(2) );
+
+    X a(0), b(0);
+    test_4_( f, boost::ref(a), boost::ref(b) );
+}
+
+// 5
+
+template<class F, class V> void test_5_(F f, V v1, V v2)
+{
+    test_eq( boost::bind(f, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v2) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v2, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v2, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1), boost::bind(f, v1, v2, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1), boost::bind(f, v2, v1, v1, v1, v1) );
+}
+
+template<class F> void test_5(F f)
+{
+    test_eq( boost::bind(f, _1, _2, _3, _4, _5), boost::bind(f, _1, _2, _3, _4, _5) );
+
+    test_5_( f, X(1), X(2) );
+
+    X a(0), b(0);
+    test_5_( f, boost::ref(a), boost::ref(b) );
+}
+
+// 6
+
+template<class F, class V> void test_6_(F f, V v1, V v2)
+{
+    test_eq( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v2) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v2, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v2, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v2, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v2, v1, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v2, v1, v1, v1, v1, v1) );
+}
+
+template<class F> void test_6(F f)
+{
+    test_eq( boost::bind(f, _1, _2, _3, _4, _5, _6), boost::bind(f, _1, _2, _3, _4, _5, _6) );
+
+    test_6_( f, X(1), X(2) );
+
+    X a(0), b(0);
+    test_6_( f, boost::ref(a), boost::ref(b) );
+}
+
+// 7
+
+template<class F, class V> void test_7_(F f, V v1, V v2)
+{
+    test_eq( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v2) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v2, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v2, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v2, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v2, v1, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v2, v1, v1, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v2, v1, v1, v1, v1, v1, v1) );
+}
+
+template<class F> void test_7(F f)
+{
+    test_eq( boost::bind(f, _1, _2, _3, _4, _5, _6, _7), boost::bind(f, _1, _2, _3, _4, _5, _6, _7) );
+
+    test_7_( f, X(1), X(2) );
+
+    X a(0), b(0);
+    test_7_( f, boost::ref(a), boost::ref(b) );
+}
+
+// 8
+
+template<class F, class V> void test_8_(F f, V v1, V v2)
+{
+    test_eq( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v2) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v2, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v2, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v2, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v2, v1, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v2, v1, v1, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v2, v1, v1, v1, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v2, v1, v1, v1, v1, v1, v1, v1) );
+}
+
+template<class F> void test_8(F f)
+{
+    test_eq( boost::bind(f, _1, _2, _3, _4, _5, _6, _7, _8), boost::bind(f, _1, _2, _3, _4, _5, _6, _7, _8) );
+
+    test_8_( f, X(1), X(2) );
+
+    X a(0), b(0);
+    test_8_( f, boost::ref(a), boost::ref(b) );
+}
+
+// 9
+
+template<class F, class V> void test_9_(F f, V v1, V v2)
+{
+    test_eq( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v2) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v2, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v2, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v2, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v2, v1, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v2, v1, v1, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v2, v1, v1, v1, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v2, v1, v1, v1, v1, v1, v1, v1) );
+    test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v2, v1, v1, v1, v1, v1, v1, v1, v1) );
+}
+
+template<class F> void test_9(F f)
+{
+    test_eq( boost::bind(f, _1, _2, _3, _4, _5, _6, _7, _8, _9), boost::bind(f, _1, _2, _3, _4, _5, _6, _7, _8, _9) );
+
+    test_9_( f, X(1), X(2) );
+
+    X a(0), b(0);
+    test_9_( f, boost::ref(a), boost::ref(b) );
+}
+
+int main()
+{
+    // 0
+
+    test_0( f_0 );
+    test_0( fv_0 );
+
+    // 1
+
+    test_1( f_1 );
+    test_1( fv_1 );
+
+    // 2
+
+    test_2( f_2 );
+    test_2( fv_2 );
+
+    // 3
+
+    test_3( f_3 );
+    test_3( fv_3 );
+
+    // 4
+
+    test_4( f_4 );
+    test_4( fv_4 );
+
+    // 5
+
+    test_5( f_5 );
+    test_5( fv_5 );
+
+    // 6
+
+    test_6( f_6 );
+    test_6( fv_6 );
+
+    // 7
+
+    test_7( f_7 );
+    test_7( fv_7 );
+
+    // 8
+
+    test_8( f_8 );
+    test_8( fv_8 );
+
+    // 9
+
+    test_9( f_9 );
+    test_9( fv_9 );
+
+    return boost::report_errors();
+}
--- a/test/bind_fastcall_mf_test.cpp
+++ b/test/bind_fastcall_mf_test.cpp
@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion
@@ -10,10 +12,9 @@
 //
 //  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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //

 #define BOOST_MEM_FN_ENABLE_FASTCALL
--- a/test/bind_fastcall_test.cpp
+++ b/test/bind_fastcall_test.cpp
@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion
@@ -10,10 +12,9 @@
 //
 //  Copyright (c) 2002 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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //

 #define BOOST_BIND_ENABLE_FASTCALL
--- a/test/bind_stateful_test.cpp
+++ b/test/bind_stateful_test.cpp
@@ -0,0 +1,222 @@
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
+#pragma warning(disable: 4786)  // identifier truncated in debug info
+#pragma warning(disable: 4710)  // function not inlined
+#pragma warning(disable: 4711)  // function selected for automatic inline expansion
+#pragma warning(disable: 4514)  // unreferenced inline removed
+#endif
+
+//
+//  bind_stateful_test.cpp
+//
+//  Copyright (c) 2004 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/bind.hpp>
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+#pragma warning(push, 3)
+#endif
+
+#include <iostream>
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+#pragma warning(pop)
+#endif
+
+#include <boost/detail/lightweight_test.hpp>
+
+class X
+{
+private:
+
+    int state_;
+
+public:
+
+    X(): state_(0)
+    {
+    }
+
+    int state() const
+    {
+        return state_;
+    }
+
+    int operator()()
+    {
+        return state_ += 17041;
+    }
+
+    int operator()(int x1)
+    {
+        return state_ += x1;
+    }
+
+    int operator()(int x1, int x2)
+    {
+        return state_ += x1+x2;
+    }
+
+    int operator()(int x1, int x2, int x3)
+    {
+        return state_ += x1+x2+x3;
+    }
+
+    int operator()(int x1, int x2, int x3, int x4)
+    {
+        return state_ += x1+x2+x3+x4;
+    }
+
+    int operator()(int x1, int x2, int x3, int x4, int x5)
+    {
+        return state_ += x1+x2+x3+x4+x5;
+    }
+
+    int operator()(int x1, int x2, int x3, int x4, int x5, int x6)
+    {
+        return state_ += x1+x2+x3+x4+x5+x6;
+    }
+
+    int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7)
+    {
+        return state_ += x1+x2+x3+x4+x5+x6+x7;
+    }
+
+    int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8)
+    {
+        return state_ += x1+x2+x3+x4+x5+x6+x7+x8;
+    }
+
+    int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8, int x9)
+    {
+        return state_ += x1+x2+x3+x4+x5+x6+x7+x8+x9;
+    }
+};
+
+int f0(int & state_)
+{
+    return state_ += 17041;
+}
+
+int f1(int & state_, int x1)
+{
+    return state_ += x1;
+}
+
+int f2(int & state_, int x1, int x2)
+{
+    return state_ += x1+x2;
+}
+
+int f3(int & state_, int x1, int x2, int x3)
+{
+    return state_ += x1+x2+x3;
+}
+
+int f4(int & state_, int x1, int x2, int x3, int x4)
+{
+    return state_ += x1+x2+x3+x4;
+}
+
+int f5(int & state_, int x1, int x2, int x3, int x4, int x5)
+{
+    return state_ += x1+x2+x3+x4+x5;
+}
+
+int f6(int & state_, int x1, int x2, int x3, int x4, int x5, int x6)
+{
+    return state_ += x1+x2+x3+x4+x5+x6;
+}
+
+int f7(int & state_, int x1, int x2, int x3, int x4, int x5, int x6, int x7)
+{
+    return state_ += x1+x2+x3+x4+x5+x6+x7;
+}
+
+int f8(int & state_, int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8)
+{
+    return state_ += x1+x2+x3+x4+x5+x6+x7+x8;
+}
+
+template<class F> void test(F f, int a, int b)
+{
+    BOOST_TEST( f() == a +   b );
+    BOOST_TEST( f() == a + 2*b );
+    BOOST_TEST( f() == a + 3*b );
+}
+
+void stateful_function_object_test()
+{
+    test( boost::bind<int>( X() ), 0, 17041 );
+    test( boost::bind<int>( X(), 1 ), 0, 1 );
+    test( boost::bind<int>( X(), 1, 2 ), 0, 1+2 );
+    test( boost::bind<int>( X(), 1, 2, 3 ), 0, 1+2+3 );
+    test( boost::bind<int>( X(), 1, 2, 3, 4 ), 0, 1+2+3+4 );
+    test( boost::bind<int>( X(), 1, 2, 3, 4, 5 ), 0, 1+2+3+4+5 );
+    test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6 ), 0, 1+2+3+4+5+6 );
+    test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7 ), 0, 1+2+3+4+5+6+7 );
+    test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7, 8 ), 0, 1+2+3+4+5+6+7+8 );
+    test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7, 8, 9 ), 0, 1+2+3+4+5+6+7+8+9 );
+
+    X x;
+
+    int n = x.state();
+
+    test( boost::bind<int>( boost::ref(x) ), n, 17041 );
+    n += 3*17041;
+
+    test( boost::bind<int>( boost::ref(x), 1 ), n, 1 );
+    n += 3*1;
+
+    test( boost::bind<int>( boost::ref(x), 1, 2 ), n, 1+2 );
+    n += 3*(1+2);
+
+    test( boost::bind<int>( boost::ref(x), 1, 2, 3 ), n, 1+2+3 );
+    n += 3*(1+2+3);
+
+    test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4 ), n, 1+2+3+4 );
+    n += 3*(1+2+3+4);
+
+    test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4, 5 ), n, 1+2+3+4+5 );
+    n += 3*(1+2+3+4+5);
+
+    test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4, 5, 6 ), n, 1+2+3+4+5+6 );
+    n += 3*(1+2+3+4+5+6);
+
+    test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4, 5, 6, 7 ), n, 1+2+3+4+5+6+7 );
+    n += 3*(1+2+3+4+5+6+7);
+
+    test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4, 5, 6, 7, 8 ), n, 1+2+3+4+5+6+7+8 );
+    n += 3*(1+2+3+4+5+6+7+8);
+
+    test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4, 5, 6, 7, 8, 9 ), n, 1+2+3+4+5+6+7+8+9 );
+    n += 3*(1+2+3+4+5+6+7+8+9);
+
+    BOOST_TEST( x.state() == n );
+}
+
+void stateful_function_test()
+{
+    test( boost::bind( f0, 0 ), 0, 17041 );
+    test( boost::bind( f1, 0, 1 ), 0, 1 );
+    test( boost::bind( f2, 0, 1, 2 ), 0, 1+2 );
+    test( boost::bind( f3, 0, 1, 2, 3 ), 0, 1+2+3 );
+    test( boost::bind( f4, 0, 1, 2, 3, 4 ), 0, 1+2+3+4 );
+    test( boost::bind( f5, 0, 1, 2, 3, 4, 5 ), 0, 1+2+3+4+5 );
+    test( boost::bind( f6, 0, 1, 2, 3, 4, 5, 6 ), 0, 1+2+3+4+5+6 );
+    test( boost::bind( f7, 0, 1, 2, 3, 4, 5, 6, 7 ), 0, 1+2+3+4+5+6+7 );
+    test( boost::bind( f8, 0, 1, 2, 3, 4, 5, 6, 7, 8 ), 0, 1+2+3+4+5+6+7+8 );
+}
+
+int main()
+{
+    stateful_function_object_test();
+    stateful_function_test();
+    return boost::report_errors();
+}
--- a/test/bind_stdcall_mf_test.cpp
+++ b/test/bind_stdcall_mf_test.cpp
@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion
@@ -10,10 +12,9 @@
 //
 //  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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //

 #define BOOST_MEM_FN_ENABLE_STDCALL
--- a/test/bind_stdcall_test.cpp
+++ b/test/bind_stdcall_test.cpp
@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion
@@ -10,10 +12,9 @@
 //
 //  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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //

 #define BOOST_BIND_ENABLE_STDCALL
--- a/test/bind_test.cpp
+++ b/test/bind_test.cpp
@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL) && !defined(__COMO__)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion
@@ -11,10 +13,9 @@
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //  Copyright (c) 2001 David Abrahams
 //
-//  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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //

 #include <boost/bind.hpp>
@@ -188,7 +189,7 @@ void function_object_test()
    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.
+#if !defined(__MWERKS__) || (__MWERKS__ > 0x2407)     // Fails for this version of the compiler.

    global_result = 0;
    bind<void>(Y(), i, _1, 9, 4)(k);
--- a/test/mem_fn_derived_test.cpp
+++ b/test/mem_fn_derived_test.cpp
@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion
@@ -10,10 +12,9 @@
 //
 //  Copyright (c) 2001, 2002 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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //

 #include <boost/mem_fn.hpp>
--- a/test/mem_fn_eq_test.cpp
+++ b/test/mem_fn_eq_test.cpp
@@ -0,0 +1,300 @@
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
+#pragma warning(disable: 4786)  // identifier truncated in debug info
+#pragma warning(disable: 4710)  // function not inlined
+#pragma warning(disable: 4711)  // function selected for automatic inline expansion
+#pragma warning(disable: 4514)  // unreferenced inline removed
+#endif
+
+//
+//  mem_fn_eq_test.cpp - boost::mem_fn equality operator
+//
+//  Copyright (c) 2004 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/mem_fn.hpp>
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+#pragma warning(push, 3)
+#endif
+
+#include <iostream>
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+#pragma warning(pop)
+#endif
+
+#include <boost/detail/lightweight_test.hpp>
+
+struct X
+{
+    int dm_1;
+    int dm_2;
+
+    // 0
+
+    int mf0_1() { return 0; }
+    int mf0_2() { return 0; }
+
+    int cmf0_1() const { return 0; }
+    int cmf0_2() const { return 0; }
+
+    void mf0v_1() {}
+    void mf0v_2() {}
+
+    void cmf0v_1() const {}
+    void cmf0v_2() const {}
+
+    // 1
+
+    int mf1_1(int) { return 0; }
+    int mf1_2(int) { return 0; }
+
+    int cmf1_1(int) const { return 0; }
+    int cmf1_2(int) const { return 0; }
+
+    void mf1v_1(int) {}
+    void mf1v_2(int) {}
+
+    void cmf1v_1(int) const {}
+    void cmf1v_2(int) const {}
+
+    // 2
+
+    int mf2_1(int, int) { return 0; }
+    int mf2_2(int, int) { return 0; }
+
+    int cmf2_1(int, int) const { return 0; }
+    int cmf2_2(int, int) const { return 0; }
+
+    void mf2v_1(int, int) {}
+    void mf2v_2(int, int) {}
+
+    void cmf2v_1(int, int) const {}
+    void cmf2v_2(int, int) const {}
+
+    // 3
+
+    int mf3_1(int, int, int) { return 0; }
+    int mf3_2(int, int, int) { return 0; }
+
+    int cmf3_1(int, int, int) const { return 0; }
+    int cmf3_2(int, int, int) const { return 0; }
+
+    void mf3v_1(int, int, int) {}
+    void mf3v_2(int, int, int) {}
+
+    void cmf3v_1(int, int, int) const {}
+    void cmf3v_2(int, int, int) const {}
+
+    // 4
+
+    int mf4_1(int, int, int, int) { return 0; }
+    int mf4_2(int, int, int, int) { return 0; }
+
+    int cmf4_1(int, int, int, int) const { return 0; }
+    int cmf4_2(int, int, int, int) const { return 0; }
+
+    void mf4v_1(int, int, int, int) {}
+    void mf4v_2(int, int, int, int) {}
+
+    void cmf4v_1(int, int, int, int) const {}
+    void cmf4v_2(int, int, int, int) const {}
+
+    // 5
+
+    int mf5_1(int, int, int, int, int) { return 0; }
+    int mf5_2(int, int, int, int, int) { return 0; }
+
+    int cmf5_1(int, int, int, int, int) const { return 0; }
+    int cmf5_2(int, int, int, int, int) const { return 0; }
+
+    void mf5v_1(int, int, int, int, int) {}
+    void mf5v_2(int, int, int, int, int) {}
+
+    void cmf5v_1(int, int, int, int, int) const {}
+    void cmf5v_2(int, int, int, int, int) const {}
+
+    // 6
+
+    int mf6_1(int, int, int, int, int, int) { return 0; }
+    int mf6_2(int, int, int, int, int, int) { return 0; }
+
+    int cmf6_1(int, int, int, int, int, int) const { return 0; }
+    int cmf6_2(int, int, int, int, int, int) const { return 0; }
+
+    void mf6v_1(int, int, int, int, int, int) {}
+    void mf6v_2(int, int, int, int, int, int) {}
+
+    void cmf6v_1(int, int, int, int, int, int) const {}
+    void cmf6v_2(int, int, int, int, int, int) const {}
+
+    // 7
+
+    int mf7_1(int, int, int, int, int, int, int) { return 0; }
+    int mf7_2(int, int, int, int, int, int, int) { return 0; }
+
+    int cmf7_1(int, int, int, int, int, int, int) const { return 0; }
+    int cmf7_2(int, int, int, int, int, int, int) const { return 0; }
+
+    void mf7v_1(int, int, int, int, int, int, int) {}
+    void mf7v_2(int, int, int, int, int, int, int) {}
+
+    void cmf7v_1(int, int, int, int, int, int, int) const {}
+    void cmf7v_2(int, int, int, int, int, int, int) const {}
+
+    // 8
+
+    int mf8_1(int, int, int, int, int, int, int, int) { return 0; }
+    int mf8_2(int, int, int, int, int, int, int, int) { return 0; }
+
+    int cmf8_1(int, int, int, int, int, int, int, int) const { return 0; }
+    int cmf8_2(int, int, int, int, int, int, int, int) const { return 0; }
+
+    void mf8v_1(int, int, int, int, int, int, int, int) {}
+    void mf8v_2(int, int, int, int, int, int, int, int) {}
+
+    void cmf8v_1(int, int, int, int, int, int, int, int) const {}
+    void cmf8v_2(int, int, int, int, int, int, int, int) const {}
+
+};
+
+int main()
+{
+    BOOST_TEST( boost::mem_fn(&X::dm_1) == boost::mem_fn(&X::dm_1) );
+    BOOST_TEST( boost::mem_fn(&X::dm_1) != boost::mem_fn(&X::dm_2) );
+
+    // 0
+
+    BOOST_TEST( boost::mem_fn(&X::mf0_1) == boost::mem_fn(&X::mf0_1) );
+    BOOST_TEST( boost::mem_fn(&X::mf0_1) != boost::mem_fn(&X::mf0_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::cmf0_1) == boost::mem_fn(&X::cmf0_1) );
+    BOOST_TEST( boost::mem_fn(&X::cmf0_1) != boost::mem_fn(&X::cmf0_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::mf0v_1) == boost::mem_fn(&X::mf0v_1) );
+    BOOST_TEST( boost::mem_fn(&X::mf0v_1) != boost::mem_fn(&X::mf0v_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::cmf0v_1) == boost::mem_fn(&X::cmf0v_1) );
+    BOOST_TEST( boost::mem_fn(&X::cmf0v_1) != boost::mem_fn(&X::cmf0v_2) );
+
+    // 1
+
+    BOOST_TEST( boost::mem_fn(&X::mf1_1) == boost::mem_fn(&X::mf1_1) );
+    BOOST_TEST( boost::mem_fn(&X::mf1_1) != boost::mem_fn(&X::mf1_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::cmf1_1) == boost::mem_fn(&X::cmf1_1) );
+    BOOST_TEST( boost::mem_fn(&X::cmf1_1) != boost::mem_fn(&X::cmf1_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::mf1v_1) == boost::mem_fn(&X::mf1v_1) );
+    BOOST_TEST( boost::mem_fn(&X::mf1v_1) != boost::mem_fn(&X::mf1v_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::cmf1v_1) == boost::mem_fn(&X::cmf1v_1) );
+    BOOST_TEST( boost::mem_fn(&X::cmf1v_1) != boost::mem_fn(&X::cmf1v_2) );
+
+    // 2
+
+    BOOST_TEST( boost::mem_fn(&X::mf2_1) == boost::mem_fn(&X::mf2_1) );
+    BOOST_TEST( boost::mem_fn(&X::mf2_1) != boost::mem_fn(&X::mf2_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::cmf2_1) == boost::mem_fn(&X::cmf2_1) );
+    BOOST_TEST( boost::mem_fn(&X::cmf2_1) != boost::mem_fn(&X::cmf2_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::mf2v_1) == boost::mem_fn(&X::mf2v_1) );
+    BOOST_TEST( boost::mem_fn(&X::mf2v_1) != boost::mem_fn(&X::mf2v_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::cmf2v_1) == boost::mem_fn(&X::cmf2v_1) );
+    BOOST_TEST( boost::mem_fn(&X::cmf2v_1) != boost::mem_fn(&X::cmf2v_2) );
+
+    // 3
+
+    BOOST_TEST( boost::mem_fn(&X::mf3_1) == boost::mem_fn(&X::mf3_1) );
+    BOOST_TEST( boost::mem_fn(&X::mf3_1) != boost::mem_fn(&X::mf3_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::cmf3_1) == boost::mem_fn(&X::cmf3_1) );
+    BOOST_TEST( boost::mem_fn(&X::cmf3_1) != boost::mem_fn(&X::cmf3_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::mf3v_1) == boost::mem_fn(&X::mf3v_1) );
+    BOOST_TEST( boost::mem_fn(&X::mf3v_1) != boost::mem_fn(&X::mf3v_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::cmf3v_1) == boost::mem_fn(&X::cmf3v_1) );
+    BOOST_TEST( boost::mem_fn(&X::cmf3v_1) != boost::mem_fn(&X::cmf3v_2) );
+
+    // 4
+
+    BOOST_TEST( boost::mem_fn(&X::mf4_1) == boost::mem_fn(&X::mf4_1) );
+    BOOST_TEST( boost::mem_fn(&X::mf4_1) != boost::mem_fn(&X::mf4_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::cmf4_1) == boost::mem_fn(&X::cmf4_1) );
+    BOOST_TEST( boost::mem_fn(&X::cmf4_1) != boost::mem_fn(&X::cmf4_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::mf4v_1) == boost::mem_fn(&X::mf4v_1) );
+    BOOST_TEST( boost::mem_fn(&X::mf4v_1) != boost::mem_fn(&X::mf4v_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::cmf4v_1) == boost::mem_fn(&X::cmf4v_1) );
+    BOOST_TEST( boost::mem_fn(&X::cmf4v_1) != boost::mem_fn(&X::cmf4v_2) );
+
+    // 5
+
+    BOOST_TEST( boost::mem_fn(&X::mf5_1) == boost::mem_fn(&X::mf5_1) );
+    BOOST_TEST( boost::mem_fn(&X::mf5_1) != boost::mem_fn(&X::mf5_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::cmf5_1) == boost::mem_fn(&X::cmf5_1) );
+    BOOST_TEST( boost::mem_fn(&X::cmf5_1) != boost::mem_fn(&X::cmf5_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::mf5v_1) == boost::mem_fn(&X::mf5v_1) );
+    BOOST_TEST( boost::mem_fn(&X::mf5v_1) != boost::mem_fn(&X::mf5v_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::cmf5v_1) == boost::mem_fn(&X::cmf5v_1) );
+    BOOST_TEST( boost::mem_fn(&X::cmf5v_1) != boost::mem_fn(&X::cmf5v_2) );
+
+    // 6
+
+    BOOST_TEST( boost::mem_fn(&X::mf6_1) == boost::mem_fn(&X::mf6_1) );
+    BOOST_TEST( boost::mem_fn(&X::mf6_1) != boost::mem_fn(&X::mf6_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::cmf6_1) == boost::mem_fn(&X::cmf6_1) );
+    BOOST_TEST( boost::mem_fn(&X::cmf6_1) != boost::mem_fn(&X::cmf6_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::mf6v_1) == boost::mem_fn(&X::mf6v_1) );
+    BOOST_TEST( boost::mem_fn(&X::mf6v_1) != boost::mem_fn(&X::mf6v_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::cmf6v_1) == boost::mem_fn(&X::cmf6v_1) );
+    BOOST_TEST( boost::mem_fn(&X::cmf6v_1) != boost::mem_fn(&X::cmf6v_2) );
+
+    // 7
+
+    BOOST_TEST( boost::mem_fn(&X::mf7_1) == boost::mem_fn(&X::mf7_1) );
+    BOOST_TEST( boost::mem_fn(&X::mf7_1) != boost::mem_fn(&X::mf7_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::cmf7_1) == boost::mem_fn(&X::cmf7_1) );
+    BOOST_TEST( boost::mem_fn(&X::cmf7_1) != boost::mem_fn(&X::cmf7_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::mf7v_1) == boost::mem_fn(&X::mf7v_1) );
+    BOOST_TEST( boost::mem_fn(&X::mf7v_1) != boost::mem_fn(&X::mf7v_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::cmf7v_1) == boost::mem_fn(&X::cmf7v_1) );
+    BOOST_TEST( boost::mem_fn(&X::cmf7v_1) != boost::mem_fn(&X::cmf7v_2) );
+
+    // 8
+
+    BOOST_TEST( boost::mem_fn(&X::mf8_1) == boost::mem_fn(&X::mf8_1) );
+    BOOST_TEST( boost::mem_fn(&X::mf8_1) != boost::mem_fn(&X::mf8_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::cmf8_1) == boost::mem_fn(&X::cmf8_1) );
+    BOOST_TEST( boost::mem_fn(&X::cmf8_1) != boost::mem_fn(&X::cmf8_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::mf8v_1) == boost::mem_fn(&X::mf8v_1) );
+    BOOST_TEST( boost::mem_fn(&X::mf8v_1) != boost::mem_fn(&X::mf8v_2) );
+
+    BOOST_TEST( boost::mem_fn(&X::cmf8v_1) == boost::mem_fn(&X::cmf8v_1) );
+    BOOST_TEST( boost::mem_fn(&X::cmf8v_1) != boost::mem_fn(&X::cmf8v_2) );
+
+
+    return boost::report_errors();
+}
--- a/test/mem_fn_fastcall_test.cpp
+++ b/test/mem_fn_fastcall_test.cpp
@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion
@@ -10,10 +12,9 @@
 //
 //  Copyright (c) 2002 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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //

 #define BOOST_MEM_FN_ENABLE_FASTCALL
--- a/test/mem_fn_stdcall_test.cpp
+++ b/test/mem_fn_stdcall_test.cpp
@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion
@@ -10,10 +12,9 @@
 //
 //  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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //

 #define BOOST_MEM_FN_ENABLE_STDCALL
--- a/test/mem_fn_test.cpp
+++ b/test/mem_fn_test.cpp
@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion
@@ -10,10 +12,9 @@
 //
 //  Copyright (c) 2001, 2002 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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //

 #include <boost/mem_fn.hpp>
--- a/test/mem_fn_void_test.cpp
+++ b/test/mem_fn_void_test.cpp
@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion
@@ -10,10 +12,9 @@
 //
 //  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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //

 #include <boost/mem_fn.hpp>
Author	SHA1	Message	Date
nobody	b4eda66382	This commit was manufactured by cvs2svn to create tag 'Version_1_32_0'. [SVN r26264]	2004-11-19 19:19:18 +00:00
nobody	924794bbdf	This commit was manufactured by cvs2svn to create branch 'RC_1_32_0'. [SVN r25797]	2004-10-20 08:26:43 +00:00
Aleksey Gurtovoy	f01e59b682	c++boost.gif -> boost.png replacement [SVN r25573]	2004-10-05 15:45:52 +00:00
Peter Dimov	9ffd0a08c5	Switched data members to return by value to avoid a const ref to short lived temp problem [SVN r25058]	2004-09-13 17:43:08 +00:00
Douglas Gregor	4e287df40c	Converted to Boost Software License, Version 1.0 [SVN r24055]	2004-07-26 00:32:12 +00:00
Douglas Gregor	5c53d7db2a	Documentation update from Jon T. Pedant [SVN r23847]	2004-07-20 17:03:55 +00:00
Douglas Gregor	0904a14c1a	T->type [SVN r23410]	2004-07-09 00:56:42 +00:00
Toon Knapen	4377e763a5	port to vacpp [SVN r23057]	2004-06-08 13:43:03 +00:00
Peter Dimov	cc984fad42	Added const operator() overloads [SVN r22934]	2004-05-26 12:50:25 +00:00
Peter Dimov	53c2e449d1	g++ 2.9x fix [SVN r22709]	2004-04-30 13:04:51 +00:00
Peter Dimov	74fae199f6	Disabled bind<R&> for CW8 as it cannot parse the overloads. [SVN r22685]	2004-04-22 15:57:12 +00:00
Dave Abrahams	4a41a09d27	Update skipping of pro7 test [SVN r22672]	2004-04-20 16:32:51 +00:00
Peter Dimov	2244135e86	Enable bind<R&> for data member pointers. [SVN r22460]	2004-03-09 12:49:00 +00:00
Peter Dimov	807bbfd434	Next round of MSVC 6/7 fixes. [SVN r22453]	2004-03-07 16:39:15 +00:00
Peter Dimov	6fbbcd0d3c	Another VC 7 fix. [SVN r22429]	2004-03-04 14:05:50 +00:00
Peter Dimov	21f1171900	Attempt to work around a MSVC 7 bug re F& deduction from void (* const) (). [SVN r22428]	2004-03-03 13:15:05 +00:00
Peter Dimov	f8f4029628	bind_stateful_test.cpp added. [SVN r22424]	2004-03-02 18:42:12 +00:00
Peter Dimov	dbf6e0cf4b	bind_cv_test.cpp added. [SVN r22418]	2004-03-02 13:02:49 +00:00
Peter Dimov	8f1bb7f13f	bind_const_test.cpp added. [SVN r22416]	2004-03-01 21:05:02 +00:00
Peter Dimov	6601553820	Unfix unversioned VC++ check again, VC 7.1 still needs it. [SVN r22377]	2004-02-24 19:49:28 +00:00
Peter Dimov	b6a90777c8	Cv-related fix. [SVN r22338]	2004-02-20 13:56:22 +00:00
Peter Dimov	ea8c0ef25e	bind and mem_fn now support operator== and operator!= [SVN r21978]	2004-01-26 19:13:17 +00:00
Beman Dawes	f91de70d8e	type_traits.htm now type_traits.html [SVN r21232]	2003-12-11 23:35:43 +00:00
Douglas Gregor	4b97a70f64	Redirects to BoostBook-generated documentation [SVN r21183]	2003-12-08 14:18:22 +00:00
Peter Dimov	7feefb7313	_MSC_VER use clarified. [SVN r20992]	2003-11-28 15:35:21 +00:00
Vladimir Prus	46ae046f41	Add V2 Jamfile. [SVN r20208]	2003-09-29 15:37:57 +00:00
Peter Dimov	673d6b0bf0	Fixed VC7 regression [SVN r20088]	2003-09-17 11:56:22 +00:00
Dave Abrahams	9ca672c10d	CWPro8.3 bug workaround [SVN r19993]	2003-09-10 15:37:59 +00:00
Dave Abrahams	016a3b8d96	Use the import rule [SVN r19968]	2003-09-08 17:38:49 +00:00
Peter Dimov	6ed01de60f	-Wundef fixes. [SVN r18788]	2003-06-12 17:09:24 +00:00
Peter Dimov	5f95e4d9de	Support for noncopyable function objects (boost::signal) [SVN r18615]	2003-05-30 17:00:14 +00:00
Peter Dimov	90069948ec	Const-correctness patch extended to the NO_VOID_RETURNS code path. [SVN r18332]	2003-04-29 13:28:57 +00:00
Peter Dimov	367728cafe	Bound arguments are now no more const than the object itself. [SVN r18296]	2003-04-23 22:14:40 +00:00
Douglas Gregor	4be201beba	Updated to reflect BoostBook changes [SVN r17941]	2003-03-15 23:12:35 +00:00
Douglas Gregor	04a438f5f4	Lots of cleanups as BoostBook becomes more strict [SVN r17871]	2003-03-13 00:29:57 +00:00
Douglas Gregor	b06f6a6d89	Move away from attributes, toward elements [SVN r17869]	2003-03-13 00:08:34 +00:00
Douglas Gregor	81c8af90ec	Import of BoostBook documentation for any, array, bind, function, ref, and signals libraries. [SVN r17866]	2003-03-12 23:27:25 +00:00