This commit was manufactured by cvs2svn to create tag

'Version_1_25_0'. [SVN r11317]
2026-04-13 21:25:59 +02:00 · 2001-10-01 16:59:12 +00:00
23 changed files with 1529 additions and 3971 deletions
--- a/bind.html
+++ b/bind.html
@@ -7,15 +7,18 @@
 	<title>Boost: bind.hpp documentation</title>
 </head>

-<body bgcolor="White" style="margin-left: 5%; margin-right: 5%;">
+<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">
+		<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" WIDTH="277" HEIGHT="86">
 	</td>
 	<td align="center">
-		<h1>bind.hpp</h1>
+		<table border="0">
+			<tr><td nowrap><h1>bind.hpp</h1></td></tr>
+			<tr><td align="right" nowrap><small>&nbsp;1.01.0001 (2001-09-02)</small></td></tr>
+		</table>
 	</td>
 </tr>
 <tr>
@@ -23,58 +26,18 @@
 </tr>
 </table>

-<h2>Contents</h2>
+<h2>Files</h2>
+<ul>
+<li><a href="../../boost/bind.hpp">bind.hpp</a> (implementation)</li>
+<li><a href="bind_test.cpp">bind_test.cpp</a> (monolithic test)</li>
+<li><a href="bind_test_1.cpp">bind_test_1.cpp</a> (test with function pointers)</li>
+<li><a href="bind_test_2.cpp">bind_test_2.cpp</a> (test with function objects)</li>
+<li><a href="bind_test_3.cpp">bind_test_3.cpp</a> (test with member function pointers)</li>
+<li><a href="bind_test_4.cpp">bind_test_4.cpp</a> (test with a visitor)</li>
+<li><a href="bind_as_compose.cpp">bind_as_compose.cpp</a> (function composition example)</li>
+</ul>

-<h3 style="margin-left: 20pt;"><a href="#Purpose">Purpose</a></h3>
-<h4 style="margin-left: 40pt;"><a href="#with_functions">Using bind with functions and function pointers</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#with_function_objects">Using bind with function objects</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#with_member_functions">Using bind with member function pointers</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#nested_binds">Using nested binds for function composition</a></h4>
-
-<h3 style="margin-left: 20pt;"><a href="#Examples">Examples</a></h3>
-<h4 style="margin-left: 40pt;"><a href="#with_algorithms">Using bind with standard algorithms</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#with_boost_function">Using bind with Boost.Function</a></h4>
-
-<h3 style="margin-left: 20pt;"><a href="#Limitations">Limitations</a></h3>
-
-<h3 style="margin-left: 20pt;"><a href="#FAQ">Frequently Asked Questions</a></h3>
-<h4 style="margin-left: 40pt;"><a href="#Q_doesnt_compile">Why doesn't this compile?</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#Q_does_compile">Why does this compile? It should not.</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#Q_forms">What is the difference between bind(f, ...) and bind&lt;R&gt;(f, ...)?</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#Q_win32_api">Does <b>bind</b> work with Windows API functions?</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#Q_com">Does <b>bind</b> work with COM methods?</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#Q_mac">Does <b>bind</b> work with Mac toolbox functions?</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#Q_auto_stdcall">Why doesn't <b>bind</b> automatically recognize nonstandard functions?</a></h4>
-
-<h3 style="margin-left: 20pt;"><a href="#Troubleshooting">Troubleshooting</a></h3>
-<h4 style="margin-left: 40pt;"><a href="#err_num_args">Incorrect number of arguments</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#err_signature">The function object cannot be called with the specified arguments</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#err_arg_access">Accessing an argument that does not exist</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#err_short_form">Inappropriate use of bind(f, ...)</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#err_long_form">Inappropriate use of bind&lt;R&gt;(f, ...)</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#err_nonstd">Binding a nonstandard function</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#err_const_arg"><b>const</b> in signatures</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#err_msvc_using">MSVC specific: using boost::bind;</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#err_msvc_class_template">MSVC specific: class templates shadow function templates</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#err_msvc_ellipsis">MSVC specific: ... in signatures treated as type</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="#CommonDefinitions">Common definitions</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#bind">bind</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">&quot;__stdcall&quot; and &quot;pascal&quot; Support</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#BOOST_BIND">Using the BOOST_BIND macro</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#visit_each"><b>visit_each</b> support</a></h4>
-
-<h3 style="margin-left: 20pt;"><a href="#Acknowledgements">Acknowledgements</a></h3>
-
-<h2><a name="Purpose">Purpose</a></h2>
+<h2>Purpose</h2>

 <p>
 <b>boost::bind</b> is a generalization of the standard functions
@@ -86,7 +49,7 @@ in particular, it does not need the <b>result_type</b>,
 <b>first_argument_type</b> and <b>second_argument_type</b> standard typedefs.
 </p>

-<h3><a name="with_functions">Using bind with functions and function pointers</a></h3>
+<h3>Using bind with functions and function pointers</h3>

 <p>
 Given these definitions:
@@ -121,15 +84,15 @@ library primitives:
 </p>

 <pre>
-std::bind2nd(std::ptr_fun(f), 5)(x);
+std::bind1st(std::ptr_fun(f), 5)(x);
 </pre>

 <p>
-<b>bind</b> covers the functionality of <b>std::bind1st</b> as well:
+<b>bind</b> covers the functionality of <b>std::bind2nd</b> as well:
 </p>

 <pre>
-std::bind1st(std::ptr_fun(f), 5)(x);   // f(5, x)
+std::bind2nd(std::ptr_fun(f), 5)(x);   // f(5, x)
 bind(f, 5, _1)(x);                     // f(5, x)
 </pre>

@@ -148,14 +111,6 @@ bind(g, _3, _3, _3)(x, y, z);          // g(z, z, z)
 bind(g, _1, _1, _1)(x, y, z);          // g(x, x, x)
 </pre>

-<p>
-Note that, in the last example, the function object produced by
-<tt>bind(g, _1, _1, _1)</tt> does not contain references to any arguments
-beyond the first, but it can still be used with more than one argument.
-Any extra arguments are silently ignored, just like the first and the second
-argument are ignored in the third example.
-</p>
-
 <p>
 The arguments that <b>bind</b> takes are copied and held internally by
 the returned function object. For example, in the following code:
@@ -180,13 +135,13 @@ int i = 5;
 bind(f, ref(i), _1);
 </pre>

-<h3><a name="with_function_objects">Using bind with function objects</a></h3>
+<h3>Using bind with function objects</h3>

 <p>
-<b>bind</b> is not limited to functions; it accepts arbitrary function objects.
-In the general case, the return type of the generated function object's
+Any function object can be passed as a first argument to <b>bind</b>, but the
+syntax is a bit different. The return type of the generated function object's
 <b>operator()</b> has to be specified explicitly (without a <b>typeof</b>
-operator the return type cannot be inferred):
+operator the return type cannot be inferred in the general case):
 </p>

 <pre>
@@ -204,21 +159,14 @@ bind&lt;int&gt;(f, _1, _1)(x);               // f(x, x), i.e. zero
 </pre>

 <p>
-When the function object exposes a nested type named <b>result_type</b>,
-the explicit return type can be omitted:
+[Note: when, hopefully,
+<a href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/cwg_active.html#226">
+function template default arguments</a> become part of C++,
+<b>bind</b> will no longer require the explicit specification of the return type
+when the function object defines <b>result_type</b>.]
 </p>

-<pre>
-int x = 8;
-
-bind(std::less&lt;int&gt;(), _1, 9)(x);               // x < 9
-</pre>
-
-<p>
-[Note: the ability to omit the return type is not available on all compilers.]
-</p>
-
-<h3><a name="with_member_functions">Using bind with member function pointers</a></h3>
+<h3>Using bind with member function pointers</h3>

 <p>
 Pointers to member functions are not function objects, because they do not
@@ -268,7 +216,7 @@ int i = 5;

 bind(&amp;X::f, ref(x), _1)(i);            // x.f(i)

-bind(&amp;X::f, &amp;x, _1)(i);                // (&amp;x)->f(i)
+bind(&amp;X::f, &x, _1)(i);                // (&x)->f(i)

 bind(&amp;X::f, x, _1)(i);                 // (<i>internal copy of x</i>).f(i)

@@ -285,7 +233,7 @@ the function object retains a reference to its instance of <b>X</b> and will
 remain valid even when <b>p</b> goes out of scope or is <b>reset()</b>.
 </p>

-<h3><a name="nested_binds">Using nested binds for function composition</a></h3>
+<h3>Using nested binds for function composition</h3>

 <p>
 Some of the arguments passed to <b>bind</b> may be nested <b>bind</b> expressions
@@ -330,9 +278,7 @@ int main()
 }
 </pre>

-<h2><a name="Examples">Examples</a></h2>
-
-<h3><a name="with_algorithms">Using bind with standard algorithms</a></h3>
+<h3>Example: using bind with standard algorithms</h3>

 <pre>
 class image;
@@ -365,7 +311,7 @@ void render(image &amp; target)
 }
 </pre>

-<h3><a name="with_boost_function">Using bind with Boost.Function</a></h3>
+<h3>Example: using bind with Boost.Function</h3>

 <pre>
 class button
@@ -393,7 +339,7 @@ void connect()
 }
 </pre>

-<h3><a name="Limitations">Limitations</a></h3>
+<h3>Limitations</h3>

 <p>
 The function objects generated by <b>bind</b> take their arguments by
@@ -437,295 +383,9 @@ partially ordered.
 corresponding issue</a> has not been resolved yet.]
 </p>

-<h2><a name="FAQ">Frequently Asked Questions</a></h2>
+<h2>Interface</h2>

-<h3><a name="Q_doesnt_compile">Why doesn't this compile?</a></h3>
-
-<p>
-See the <a href="#Troubleshooting">dedicated Troubleshooting section</a>.
-</p>
-
-<h3><a name="Q_does_compile">Why does this compile? It should not.</a></h3>
-
-<p>
-Probably because you used the general bind&lt;R&gt;(f, ...) syntax, thereby
-instructing <b>bind</b> to not &quot;inspect&quot; <b>f</b> to detect arity
-and return type errors.
-</p>
-
-<h3><a name="Q_forms">What is the difference between bind(f, ...) and bind&lt;R&gt;(f, ...)?</a></h3>
-
-<p>
-The first form instructs <b>bind</b> to inspect the type of <b>f</b> in order
-to determine its arity (number of arguments) and return type. Arity errors
-will be detected at &quot;bind time&quot;. This syntax, of course, places some
-requirements on <b>f</b>. It must be a function, function pointer, member
-function pointer, or a function object that defines a nested type named
-<b>result_type</b>; in short, it must be something that <b>bind</b> can
-recognize.
-</p>
-
-<p>
-The second form instructs <b>bind</b> to <b>not</b> attempt to recognize the
-type of <b>f</b>. It is generally used with function objects that do not, or
-cannot, expose <b>result_type</b>, but it can also be used with nonstandard
-functions. For example, the current implementation does not automatically
-recognize variable-argument functions like <b>printf</b>, so you will have to
-use <tt>bind&lt;int&gt;(printf, ...)</tt>.
-</p>
-
-<p>
-Another important factor to consider is that compilers without partial template
-specialization or function template partial ordering support cannot handle the
-first form when <b>f</b> is a function object, and in most cases will not handle
-the second form when <b>f</b> is a function (pointer) or a member function pointer.
-</p>
-
-<h3><a name="Q_win32_api">Does <b>bind</b> work with Windows API functions?</a></h3>
-
-<p>
-Yes, if you <a href="#stdcall">#define BOOST_BIND_ENABLE_STDCALL</a>.
-An alternative is to treat the function as a
-<a href="#with_function_objects">generic function object</a> and use the
-bind&lt;R&gt;(f, ...) syntax.
-</p>
-
-<h3><a name="Q_com">Does <b>bind</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="Q_mac">Does <b>bind</b> work with Mac toolbox functions?</a></h3>
-
-<p>
-Yes, if you <a href="#stdcall">#define BOOST_BIND_ENABLE_PASCAL</a>.
-An alternative is to treat the function as a
-<a href="#with_function_objects">generic function object</a> and use the
-bind&lt;R&gt;(f, ...) syntax.
-</p>
-
-<h3><a name="Q_auto_stdcall">Why doesn't <b>bind</b> automatically recognize nonstandard functions?</a></h3>
-
-<p>
-Non-portable extensions, in general, should default to off to prevent vendor
-lock-in. Had the <a href="#stdcall">appropriate macros</a> been defined
-automatically, you could
-have accidentally taken advantage of them without realizing that your code is,
-perhaps, no longer portable. In addition, some compilers have the option to
-make <b>__stdcall</b> their default calling convention, in which case no
-separate support would be necessary.
-</p>
-
-<h2><a name="Troubleshooting">Troubleshooting</a></h2>
-
-<h3><a name="err_num_args">Incorrect number of arguments</a></h3>
-
-<p>
-In a bind(f, a1, a2, ..., aN) expression, the function object <b>f</b> must
-be able to take exactly <b>N</b> arguments. This error is normally detected
-at &quot;bind time&quot;; in other words, the compilation error is reported
-on the line where bind() is invoked:
-</p>
-
-<pre>
-int f(int, int);
-
-int main()
-{
-    boost::bind(f, 1);    // error, f takes two arguments
-    boost::bind(f, 1, 2); // OK
-}
-</pre>
-
-<p>
-A common variation of this error is to forget that member functions have an
-implicit &quot;this&quot; argument:
-</p>
-
-<pre>
-struct X
-{
-    int f(int);
-}
-
-int main()
-{
-    boost::bind(&amp;X::f, 1);     // error, X::f takes two arguments
-    boost::bind(&amp;X::f, <b>_1</b>, 1); // OK
-}
-</pre>
-
-<h3><a name="err_signature">The function object cannot be called with the specified arguments</a></h3>
-
-<p>
-As in normal function calls, the function object that is bound must be
-compatible with the argument list. The incompatibility will usually be
-detected by the compiler at &quot;call time&quot; and the result is
-typically an error in <b>bind.hpp</b> on a line that looks like:
-</p>
-
-<pre>
-    return f(a[a1_], a[a2_]);
-</pre>
-
-<p>
-An example of this kind of error:
-</p>
-
-<pre>
-int f(int);
-
-int main()
-{
-    boost::bind(f, &quot;incompatible&quot;);      // OK so far, no call
-    boost::bind(f, &quot;incompatible&quot;)();    // error, &quot;incompatible&quot; is not an int
-    boost::bind(f, _1);                  // OK
-    boost::bind(f, _1)(&quot;incompatible&quot;);  // error, &quot;incompatible&quot; is not an int
-}
-</pre>
-
-<h3><a name="err_arg_access">Accessing an argument that does not exist</a></h3>
-
-<p>
-The placeholder <b>_N</b> selects the argument at position <b>N</b> from the
-argument list passed at &quot;call time.&quot; Naturally, it is an error to
-attempt to access beyond the end of this list:
-</p>
-
-<pre>
-int f(int);
-
-int main()
-{
-    boost::bind(f, _1);                  // OK
-    boost::bind(f, _1)();                // error, there is no argument number 1
-}
-</pre>
-
-<p>
-The error is usually reported in <b>bind.hpp</b>, at a line similar to:
-</p>
-
-<pre>
-    return f(a[a1_]);
-</pre>
-
-<p>
-When emulating <b>std::bind1st(f, a)</b>, a common mistake of this category
-is to type <b>bind(f, a, _2)</b> instead of the correct <b>bind(f, a, _1)</b>.
-</p>
-
-<h3><a name="err_short_form">Inappropriate use of bind(f, ...)</a></h3>
-
-<p>
-The bind(f, a1, a2, ..., aN) <a href="#Q_forms">form</a> causes automatic
-recognition of the type of <b>f</b>. It will not work with arbitrary
-function objects; <b>f</b> must be a function or a member function pointer.
-</p>
-
-<p>
-It is possible to use this form with function objects that define
-<b>result_type</b>, but <b>only on compilers</b> that support partial
-specialization and partial ordering. In particular, MSVC up to version 7.0
-does not support this syntax for function objects.
-</p>
-
-<h3><a name="err_long_form">Inappropriate use of bind&lt;R&gt;(f, ...)</a></h3>
-
-<p>
-The bind&lt;R&gt;(f, a1, a2, ..., aN) <a href="#Q_forms">form</a> supports
-arbitrary function objects.
-</p>
-
-<p>
-It is possible (but not recommended) to use this form with functions or
-member function pointers, but <b>only on compilers</b> that support partial
-ordering. In particular, MSVC up to version 7.0 does not fully support this
-syntax for functions and member function pointers.
-</p>
-
-<h3><a name="err_nonstd">Binding a nonstandard function</a></h3>
-
-<p>
-(to be written)
-</p>
-
-<h3><a name="err_const_arg"><b>const</b> in signatures</a></h3>
-
-<p>
-Some compilers, including MSVC 6.0 and Borland C++ 5.5.1, have problems
-with the top-level <b>const</b> in function signatures:
-</p>
-
-<pre>
-int f(int const);
-
-int main()
-{
-    boost::bind(f, 1);     // error
-}
-</pre>
-
-<p>
-Workaround: remove the <b>const</b> qualifier from the argument.
-</p>
-
-<h3><a name="err_msvc_using">MSVC specific: using boost::bind;</a></h3>
-
-<p>
-On MSVC (up to version 7.0), when <b>boost::bind</b> is brought into scope
-with an using declaration:
-</p>
-
-<pre>
-using boost::bind;
-</pre>
-
-<p>
-the syntax <b>bind&lt;R&gt;(...)</b> does not work. Workaround: either use the
-qualified name, <b>boost::bind</b>, or use an using directive instead:
-</p>
-
-<pre>
-using namespace boost;
-</pre>
-
-<h3><a name="err_msvc_class_template">MSVC specific: class templates shadow function templates</a></h3>
-
-<p>
-On MSVC (up to version 7.0), a nested class template named <b>bind</b> will
-shadow the function template <b>boost::bind</b>, breaking the
-<b>bind&lt;R&gt;(...)</b> syntax. Unfortunately, some libraries contain nested
-class templates named <b>bind</b> (ironically, such code is often an MSVC
-specific workaround.) You may try to patch the library in question or contact
-its author/maintainer. The other option is use the
-<a href="#BOOST_BIND">BOOST_BIND</a> macro to rename <b>bind</b>.
-</p>
-
-<h3><a name="err_msvc_ellipsis">MSVC specific: ... in signatures treated as type</a></h3>
-
-<p>
-MSVC (up to version 7.0) treats the ellipsis in a variable argument function
-(such as <b>std::printf</b>) as a type. Therefore, it will accept the
-(incorrect in the current implementation) form:
-</p>
-
-<pre>
-    bind(printf, &quot;%s\n&quot;, _1);
-</pre>
-
-<p>
-and will reject the correct version:
-</p>
-
-<pre>
-    bind&lt;int&gt;(printf, &quot;%s\n&quot;, _1);
-</pre>
-
-<h2><a name="Interface">Interface</a></h2>
-
-<h3><a name="Synopsis">Synopsis</a></h3>
+<h3>Synopsis</h3>

 <pre>
 namespace boost
@@ -735,16 +395,12 @@ namespace boost

 template&lt;class R, class F&gt; <i>implementation-defined-1</i> <a href="#bind_1">bind</a>(F f);

-template&lt;class F&gt; <i>implementation-defined-1-1</i> <a href="#bind_1_1">bind</a>(F f);
-
 template&lt;class R&gt; <i>implementation-defined-2</i> <a href="#bind_2">bind</a>(R (*f) ());

 // one argument

 template&lt;class R, class F, class A1&gt; <i>implementation-defined-3</i> <a href="#bind_3">bind</a>(F f, A1 a1);

-template&lt;class F, class A1&gt; <i>implementation-defined-3-1</i> <a href="#bind_3_1">bind</a>(F f, A1 a1);
-
 template&lt;class R, class B1, class A1&gt; <i>implementation-defined-4</i> <a href="#bind_4">bind</a>(R (*f) (B1), A1 a1);

 template&lt;class R, class T, class A1&gt; <i>implementation-defined-5</i> <a href="#bind_5">bind</a>(R (T::*f) (), A1 a1);
@@ -755,8 +411,6 @@ template&lt;class R, class T, class A1&gt; <i>implementation-defined-6</i> <a hr

 template&lt;class R, class F, class A1, class A2&gt; <i>implementation-defined-7</i> <a href="#bind_7">bind</a>(F f, A1 a1, A2 a2);

-template&lt;class F, class A1, class A2&gt; <i>implementation-defined-7-1</i> <a href="#bind_7_1">bind</a>(F f, A1 a1, A2 a2);
-
 template&lt;class R, class B1, class B2, class A1, class A2&gt; <i>implementation-defined-8</i> <a href="#bind_8">bind</a>(R (*f) (B1, B2), A1 a1, A2 a2);

 template&lt;class R, class T, class B1, class A1, class A2&gt; <i>implementation-defined-9</i> <a href="#bind_9">bind</a>(R (T::*f) (B1), A1 a1, A2 a2);
@@ -781,7 +435,7 @@ namespace
 }
 </pre>

-<h3><a name="CommonRequirements">Common requirements</a></h3>
+<h3>Common requirements</h3>

 <p>
 All <tt><i>implementation-defined-N</i></tt> types returned by <b>bind</b> are
@@ -794,7 +448,7 @@ All <tt><i>implementation-defined-placeholder-N</i></tt> types are
 <b>CopyConstructible</b>. Their copy constructors do not throw exceptions.
 </p>

-<h3><a name="CommonDefinitions">Common definitions</a></h3>
+<h3>Common definitions</h3>

 <p>
 The function &micro;(x, v<sub>1</sub>, v<sub>2</sub>, ..., v<sub>m</sub>), where m is a nonnegative integer, is defined as:
@@ -810,7 +464,7 @@ when <tt>x</tt> is (a copy of) a function object returned by <b>bind</b>;</li>
 </ul>


-<h3><a name="bind">bind</a></h3>
+<h3>bind</h3>

 <h4><a name="bind_1">template&lt;class R, class F&gt; <i>implementation-defined-1</i> bind(F f)</a></h4>

@@ -823,12 +477,6 @@ implicitly converted to <b>R</b>.
 <b>Throws:</b> Nothing unless the copy constructor of <b>F</b> throws an exception.
 </p>

-<h4><a name="bind_1_1">template&lt;class F&gt; <i>implementation-defined-1-1</i> bind(F f)</a></h4>
-
-<p>
-<b>Effects:</b> equivalent to <tt>bind&lt;typename F::result_type, F&gt;(f);</tt>
-</p>
-
 <h4><a name="bind_2">template&lt;class R&gt; <i>implementation-defined-2</i> bind(R (*f) ())</a></h4>

 <p>
@@ -848,13 +496,7 @@ implicitly converted to <b>R</b>.
 implicitly converted to <b>R</b>.
 </p>
 <p>
-<b>Throws:</b> Nothing unless the copy constructors of <b>F</b> or <b>A1</b> throw an exception.
-</p>
-
-<h4><a name="bind_3_1">template&lt;class F, class A1&gt; <i>implementation-defined-3-1</i> bind(F f, A1 a1)</a></h4>
-
-<p>
-<b>Effects:</b> equivalent to <tt>bind&lt;typename F::result_type, F, A1&gt;(f, a1);</tt>
+<b>Throws:</b> Nothing unless the copy constructors of <b>F</b> and <b>A1</b> throw an exception.
 </p>

 <h4><a name="bind_4">template&lt;class R, class B1, class A1&gt; <i>implementation-defined-4</i> bind(R (*f) (B1), A1 a1)</a></h4>
@@ -889,13 +531,7 @@ implicitly converted to <b>R</b>.
 implicitly converted to <b>R</b>.
 </p>
 <p>
-<b>Throws:</b> Nothing unless the copy constructors of <b>F</b>, <b>A1</b> or <b>A2</b> throw an exception.
-</p>
-
-<h4><a name="bind_7_1">template&lt;class F, class A1, class A2&gt; <i>implementation-defined-7-1</i> bind(F f, A1 a1, A2 a2)</a></h4>
-
-<p>
-<b>Effects:</b> equivalent to <tt>bind&lt;typename F::result_type, F, A1, A2&gt;(f, a1, a2);</tt>
+<b>Throws:</b> Nothing unless the copy constructors of <b>F</b>, <b>A1</b> and <b>A2</b> throw an exception.
 </p>

 <h4><a name="bind_8">template&lt;class R, class B1, class B2, class A1, class A2&gt; <i>implementation-defined-8</i> bind(R (*f) (B1, B2), A1 a1, A2 a2)</a></h4>
@@ -906,7 +542,7 @@ implicitly converted to <b>R</b>.
 <tt><b>f</b>(&micro;(<b>a1</b>, v<sub>1</sub>, v<sub>2</sub>, ..., v<sub>m</sub>), &micro;(<b>a2</b>, v<sub>1</sub>, v<sub>2</sub>, ..., v<sub>m</sub>))</tt>.
 </p>
 <p>
-<b>Throws:</b> Nothing unless the copy constructors of <b>A1</b> or <b>A2</b> throw an exception.
+<b>Throws:</b> Nothing unless the copy constructors of <b>A1</b> and <b>A2</b> throw an exception.
 </p>

 <h4><a name="bind_9">template&lt;class R, class T, class B1, class A1, class A2&gt; <i>implementation-defined-9</i> bind(R (T::*f) (B1), A1 a1, A2 a2)</a></h4>
@@ -921,29 +557,7 @@ implicitly converted to <b>R</b>.
 <b>Effects:</b> equivalent to <tt>bind&lt;R&gt;(<a href="mem_fn.html">boost::mem_fn</a>(f), a1, a2);</tt>
 </p>

-<h2><a name="Implementation">Implementation</a></h2>
-
-<h3><a name="Files">Files</a></h3>
-<ul>
-<li><a href="../../boost/bind.hpp">boost/bind.hpp</a> (main header)</li>
-<li><a href="../../boost/bind/bind_cc.hpp">boost/bind/bind_cc.hpp</a> (used by bind.hpp, do not include directly)
-<li><a href="../../boost/bind/bind_mf_cc.hpp">boost/bind/bind_mf_cc.hpp</a> (used by bind.hpp, do not include directly)
-<li><a href="../../boost/bind/bind_template.hpp">boost/bind/bind_template.hpp</a> (used by bind.hpp, do not include directly)
-<li><a href="bind_test.cpp">libs/bind/bind_test.cpp</a> (test)</li>
-<li><a href="bind_as_compose.cpp">libs/bind/bind_as_compose.cpp</a> (function composition example)</li>
-<li><a href="bind_visitor.cpp">libs/bind/bind_visitor.cpp</a> (visitor example)</li>
-<li><a href="bind_stdcall_test.cpp">libs/bind/bind_stdcall_test.cpp</a> (test with __stdcall functions)</li>
-<li><a href="bind_stdcall_mf_test.cpp">libs/bind/bind_stdcall_mf_test.cpp</a> (test with __stdcall member functions)</li>
-</ul>
-
-<h3><a name="Dependencies">Dependencies</a></h3>
-<ul>
-<li><a href="../config/config.htm">Boost.Config</a>
-<li><a href="ref.html">boost/ref.hpp</a>
-<li><a href="mem_fn.html">boost/mem_fn.hpp</a>
-</ul>
-
-<h3><a name="NumberOfArguments">Number of Arguments</a></h3>
+<h2>Implementation</h2>

 <p>
 This implementation supports function objects with up to nine arguments.
@@ -951,54 +565,68 @@ This is an implementation detail, not an inherent limitation of the
 design.
 </p>

-<h3><a name="stdcall">&quot;__stdcall&quot; and &quot;pascal&quot; Support</a></h3>
+<h3>Void returns</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.)
+The following C++ code:
+</p>
+
+<pre>
+void f();
+
+void g()
+{
+    return f();
+}
+</pre>
+
+<p>
+is legal; in fact it was deliberately made legal in order to support
+forwarding functions that return <b>void</b>.
 </p>

 <p>
-For example, Windows API functions and COM interface member functions use a
-calling convention known as <b>__stdcall</b>. Mac toolbox functions use a
-<b>pascal</b> calling convention.
+Unfortunately, some compilers have not caught up with the C++ Standard yet
+and do not allow void returns. This implementation of <b>bind</b> will not
+work for function pointers, member function pointers or function objects that
+return <b>void</b> if the compiler does not support the feature. A possible
+workaround is to change the return type of the function object in question
+from <b>void</b> to <b>int</b> and return a dummy value of 0.
 </p>

+<h3>MSVC specific problems and workarounds</h3>
+
 <p>
-To use <b>bind</b> with <b>__stdcall</b> functions, <b>#define</b> the macro
-<b>BOOST_BIND_ENABLE_STDCALL</b> before including <b>&lt;boost/bind.hpp&gt;</b>.
+Microsoft Visual C++ (up to version 7.0) does not fully support the
+<b>bind&lt;R&gt;(...)</b>
+syntax required by the library when arbitrary function objects are bound.
+The first problem is that when <b>boost::bind</b> is brought into scope
+with an <b>using declaration</b>:
 </p>

+<pre>
+using boost::bind;
+</pre>
+
 <p>
-To use <b>bind</b> with <b>__stdcall</b> <b>member</b> functions, <b>#define</b> the
-macro <b>BOOST_MEM_FN_ENABLE_STDCALL</b> before including <b>&lt;boost/bind.hpp&gt;</b>.
+the syntax above does not work. Workaround: either use the qualified name,
+<b>boost::bind</b>, or use an <b>using directive</b> instead:
 </p>

-<p>
-To use <b>bind</b> with <b>pascal</b> functions, <b>#define</b> the macro
-<b>BOOST_BIND_ENABLE_PASCAL</b> before including <b>&lt;boost/bind.hpp&gt;</b>.
-</p>
+<pre>
+using namespace boost;
+</pre>

 <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>
-
-<h3><a name="BOOST_BIND">Using the BOOST_BIND macro</a></h3>
-
-<p>
-A <a href="#err_msvc_class_template">bug in MSVC (up to version 7.0)</a>
-causes <b>boost::bind</b> to be incompatible
-with libraries that contain nested class templates named <b>bind</b>. To work
-around this problem, <b>#define</b> the macro <b>BOOST_BIND</b> to something
-other than <b>bind</b> (before the inclusion of <b>&lt;boost/bind.hpp&gt;</b>)
-and use this identifier throughout your code wherever you'd normally use
-<b>bind</b>.
+The second problem is that some libraries contain nested class templates
+named <b>bind</b> (ironically, such code is often an MSVC specific
+workaround.) Due to some quirks with the parser, such a class template
+breaks the <b>bind&lt;R&gt;(...)</b> syntax, even when the name <b>bind</b>
+is fully qualified. You may try to patch the library in question or contact
+its author/maintainer. The other option is to define the macro
+<b>BOOST_BIND</b> to something other than <b>bind</b> (before the inclusion of
+<b>&lt;boost/bind.hpp&gt;</b>) and use this identifier throughout your code
+wherever you'd normally use <b>bind</b>.
 </p>

 <p style="color: Red;">
@@ -1007,18 +635,33 @@ interface, and is not guaranteed to work on other compilers, or persist between
 library versions. In short, don't use it unless you absolutely have to.]
 </p>

-<h3><a name="visit_each"><b>visit_each</b> support</a></h3>
+<h3>Visitor support</h3>

-<p>
-Function objects returned by <b>bind</b> support the experimental and
-undocumented, as of yet, <b>visit_each</b> enumeration interface.
+<p style="color: Red;">
+[Note: this is an experimental feature. It may evolve over time
+when other libraries start to exploit it; or it may be removed altogether if
+no other library needs it. It is not part of the interface.]
 </p>

 <p>
-See <a href="bind_visitor.cpp">bind_visitor.cpp</a> for an example.
+For better integration with other libraries, the function objects returned by
+<b>bind</b> define a member function
 </p>

-<h2><a name="Acknowledgements">Acknowledgements</a></h2>
+<pre>
+template&lt;class Visitor&gt; void accept(Visitor &amp; v);
+</pre>
+
+<p>
+that applies <b>v</b>, as a function object, to its internal state. Using
+<b>accept</b> is implementation-specific and not intended for end users.
+</p>
+
+<p>
+See <a href="bind_test_4.cpp">bind_test_4.cpp</a> for an example.
+</p>
+
+<h2>Acknowledgements</h2>

 <p>
 Earlier efforts that have influenced the library design:
@@ -1053,21 +696,6 @@ was Darin Adler.
 The precise semantics of <b>bind</b> were refined in discussions with Jaakko J&auml;rvi.
 </p>

-<p>
-Dave Abrahams fixed a MSVC-specific conflict between <b>bind</b> and the
-<a href="../utility\iterator_adaptors.htm">iterator adaptors library</a>.
-</p>
-
-<p>
-Dave Abrahams modified <b>bind</b> and <b>mem_fn</b> to support void returns
-on deficient compilers.
-</p>
-
-<p>
-Mac Murrett contributed the &quot;pascal&quot; support enabled by
-BOOST_BIND_ENABLE_PASCAL.
-</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
--- a/bind_stdcall_test.cpp
+++ b/bind_stdcall_test.cpp
@@ -1,110 +0,0 @@
-#if defined(_MSC_VER) && !defined(__ICL)
-#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_stdcall_test.cpp - test for bind.hpp + __stdcall (free functions)
-//
-//  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.
-//
-
-#define BOOST_BIND_ENABLE_STDCALL
-
-#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
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-
-//
-
-long __stdcall f_0()
-{
-    return 17041L;
-}
-
-long __stdcall f_1(long a)
-{
-    return a;
-}
-
-long __stdcall f_2(long a, long b)
-{
-    return a + 10 * b;
-}
-
-long __stdcall f_3(long a, long b, long c)
-{
-    return a + 10 * b + 100 * c;
-}
-
-long __stdcall f_4(long a, long b, long c, long d)
-{
-    return a + 10 * b + 100 * c + 1000 * d;
-}
-
-long __stdcall f_5(long a, long b, long c, long d, long e)
-{
-    return a + 10 * b + 100 * c + 1000 * d + 10000 * e;
-}
-
-long __stdcall 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 __stdcall 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 __stdcall 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 __stdcall 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;
-}
-
-void function_test()
-{
-    using namespace boost;
-
-    int const i = 1;
-
-    BOOST_TEST( bind(f_0)(i) == 17041L );
-    BOOST_TEST( bind(f_1, _1)(i) == 1L );
-    BOOST_TEST( bind(f_2, _1, 2)(i) == 21L );
-    BOOST_TEST( bind(f_3, _1, 2, 3)(i) == 321L );
-    BOOST_TEST( bind(f_4, _1, 2, 3, 4)(i) == 4321L );
-    BOOST_TEST( bind(f_5, _1, 2, 3, 4, 5)(i) == 54321L );
-    BOOST_TEST( bind(f_6, _1, 2, 3, 4, 5, 6)(i) == 654321L );
-    BOOST_TEST( bind(f_7, _1, 2, 3, 4, 5, 6, 7)(i) == 7654321L );
-    BOOST_TEST( bind(f_8, _1, 2, 3, 4, 5, 6, 7, 8)(i) == 87654321L );
-    BOOST_TEST( bind(f_9, _1, 2, 3, 4, 5, 6, 7, 8, 9)(i) == 987654321L );
-}
-
-int test_main(int, char * [])
-{
-    function_test();
-    return 0;
-}
--- a/bind_test.cpp
+++ b/bind_test.cpp
@@ -8,8 +8,9 @@
 //
 //  bind_test.cpp - monolithic test for bind.hpp
 //
+//  Version 1.00.0002 (2001-09-02)
+//
 //  Copyright (c) 2001 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.
@@ -19,18 +20,8 @@

 #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
-
-
 #define BOOST_INCLUDE_MAIN
 #include <boost/test/test_tools.hpp>

@@ -86,58 +77,6 @@ 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;
-}
-
 void function_test()
 {
    using namespace boost;
@@ -154,17 +93,6 @@ void function_test()
    BOOST_TEST( bind(f_7, _1, 2, 3, 4, 5, 6, 7)(i) == 7654321L );
    BOOST_TEST( bind(f_8, _1, 2, 3, 4, 5, 6, 7, 8)(i) == 87654321L );
    BOOST_TEST( bind(f_9, _1, 2, 3, 4, 5, 6, 7, 8, 9)(i) == 987654321L );
-
-    BOOST_TEST( (bind(fv_0)(i), (global_result == 17041L)) );
-    BOOST_TEST( (bind(fv_1, _1)(i), (global_result == 1L)) );
-    BOOST_TEST( (bind(fv_2, _1, 2)(i), (global_result == 21L)) );
-    BOOST_TEST( (bind(fv_3, _1, 2, 3)(i), (global_result == 321L)) );
-    BOOST_TEST( (bind(fv_4, _1, 2, 3, 4)(i), (global_result == 4321L)) );
-    BOOST_TEST( (bind(fv_5, _1, 2, 3, 4, 5)(i), (global_result == 54321L)) );
-    BOOST_TEST( (bind(fv_6, _1, 2, 3, 4, 5, 6)(i), (global_result == 654321L)) );
-    BOOST_TEST( (bind(fv_7, _1, 2, 3, 4, 5, 6, 7)(i), (global_result == 7654321L)) );
-    BOOST_TEST( (bind(fv_8, _1, 2, 3, 4, 5, 6, 7, 8)(i), (global_result == 87654321L)) );
-    BOOST_TEST( (bind(fv_9, _1, 2, 3, 4, 5, 6, 7, 8, 9)(i), (global_result == 987654321L)) );
 }

 //
@@ -174,7 +102,6 @@ struct Y
    short operator()(short & r) const { return ++r; }
    int operator()(int a, int b) const { return a + 10 * b; }
    long operator() (long a, long b, long c) const { return a + 10 * b + 100 * c; }
-    void operator() (long a, long b, long c, long d) const { global_result = a + 10 * b + 100 * c + 1000 * d; }
 };

 void function_object_test()
@@ -189,34 +116,10 @@ void function_object_test()
    BOOST_TEST( bind<short>(Y(), ref(i))() == 8 );
    BOOST_TEST( bind<int>(Y(), i, _1)(k) == 38 );
    BOOST_TEST( bind<long>(Y(), i, _1, 9)(k) == 938 );
-
-#if !defined(__MWERKS__) || (__MWERKS__ > 0x2406)     // Fails for this version of the compiler.
-
-    bind<void>(Y(), i, _1, 9, 4)(k);
-    BOOST_TEST( global_result == 4938 );
-
-#endif
 }

 //

-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-
-struct Z
-{
-    typedef int result_type;
-    int operator()(int a, int b) const { return a + 10 * b; }
-};
-
-void adaptable_function_object_test()
-{
-    BOOST_TEST( boost::bind(Z(), 7, 4)() == 47 );
-}
-
-#endif
-
-//
-
 struct X
 {
    mutable unsigned int hash;
@@ -251,40 +154,6 @@ struct X
    int g8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) const { g7(a1, a2, a3, a4, a5, a6, a7); g1(a8); return 0; }
 };

-struct V
-{
-    mutable unsigned int hash;
-
-    V(): hash(0) {}
-
-    void f0() { f1(17); }
-    void g0() const { g1(17); }
-
-    void f1(int a1) { hash = (hash * 17041 + a1) % 32768; }
-    void g1(int a1) const { hash = (hash * 17041 + a1 * 2) % 32768; }
-
-    void f2(int a1, int a2) { f1(a1); f1(a2); }
-    void g2(int a1, int a2) const { g1(a1); g1(a2); }
-
-    void f3(int a1, int a2, int a3) { f2(a1, a2); f1(a3); }
-    void g3(int a1, int a2, int a3) const { g2(a1, a2); g1(a3); }
-
-    void f4(int a1, int a2, int a3, int a4) { f3(a1, a2, a3); f1(a4); }
-    void g4(int a1, int a2, int a3, int a4) const { g3(a1, a2, a3); g1(a4); }
-
-    void f5(int a1, int a2, int a3, int a4, int a5) { f4(a1, a2, a3, a4); f1(a5); }
-    void g5(int a1, int a2, int a3, int a4, int a5) const { g4(a1, a2, a3, a4); g1(a5); }
-
-    void f6(int a1, int a2, int a3, int a4, int a5, int a6) { f5(a1, a2, a3, a4, a5); f1(a6); }
-    void g6(int a1, int a2, int a3, int a4, int a5, int a6) const { g5(a1, a2, a3, a4, a5); g1(a6); }
-
-    void f7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) { f6(a1, a2, a3, a4, a5, a6); f1(a7); }
-    void g7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) const { g6(a1, a2, a3, a4, a5, a6); g1(a7); }
-
-    void f8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) { f7(a1, a2, a3, a4, a5, a6, a7); f1(a8); }
-    void g8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) const { g7(a1, a2, a3, a4, a5, a6, a7); g1(a8); }
-};
-
 void member_function_test()
 {
    using namespace boost;
@@ -375,96 +244,6 @@ void member_function_test()
    BOOST_TEST( x.hash == 23558 );
 }

-void member_function_void_test()
-{
-    using namespace boost;
-
-    V v;
-
-    // 0
-
-    bind(&V::f0, &v)();
-    bind(&V::f0, ref(v))();
-
-    bind(&V::g0, &v)();
-    bind(&V::g0, v)();
-    bind(&V::g0, ref(v))();
-
-    // 1
-
-    bind(&V::f1, &v, 1)();
-    bind(&V::f1, ref(v), 1)();
-
-    bind(&V::g1, &v, 1)();
-    bind(&V::g1, v, 1)();
-    bind(&V::g1, ref(v), 1)();
-
-    // 2
-
-    bind(&V::f2, &v, 1, 2)();
-    bind(&V::f2, ref(v), 1, 2)();
-
-    bind(&V::g2, &v, 1, 2)();
-    bind(&V::g2, v, 1, 2)();
-    bind(&V::g2, ref(v), 1, 2)();
-
-    // 3
-
-    bind(&V::f3, &v, 1, 2, 3)();
-    bind(&V::f3, ref(v), 1, 2, 3)();
-
-    bind(&V::g3, &v, 1, 2, 3)();
-    bind(&V::g3, v, 1, 2, 3)();
-    bind(&V::g3, ref(v), 1, 2, 3)();
-
-    // 4
-
-    bind(&V::f4, &v, 1, 2, 3, 4)();
-    bind(&V::f4, ref(v), 1, 2, 3, 4)();
-
-    bind(&V::g4, &v, 1, 2, 3, 4)();
-    bind(&V::g4, v, 1, 2, 3, 4)();
-    bind(&V::g4, ref(v), 1, 2, 3, 4)();
-
-    // 5
-
-    bind(&V::f5, &v, 1, 2, 3, 4, 5)();
-    bind(&V::f5, ref(v), 1, 2, 3, 4, 5)();
-
-    bind(&V::g5, &v, 1, 2, 3, 4, 5)();
-    bind(&V::g5, v, 1, 2, 3, 4, 5)();
-    bind(&V::g5, ref(v), 1, 2, 3, 4, 5)();
-
-    // 6
-
-    bind(&V::f6, &v, 1, 2, 3, 4, 5, 6)();
-    bind(&V::f6, ref(v), 1, 2, 3, 4, 5, 6)();
-
-    bind(&V::g6, &v, 1, 2, 3, 4, 5, 6)();
-    bind(&V::g6, v, 1, 2, 3, 4, 5, 6)();
-    bind(&V::g6, ref(v), 1, 2, 3, 4, 5, 6)();
-
-    // 7
-
-    bind(&V::f7, &v, 1, 2, 3, 4, 5, 6, 7)();
-    bind(&V::f7, ref(v), 1, 2, 3, 4, 5, 6, 7)();
-
-    bind(&V::g7, &v, 1, 2, 3, 4, 5, 6, 7)();
-    bind(&V::g7, v, 1, 2, 3, 4, 5, 6, 7)();
-    bind(&V::g7, ref(v), 1, 2, 3, 4, 5, 6, 7)();
-
-    // 8
-
-    bind(&V::f8, &v, 1, 2, 3, 4, 5, 6, 7, 8)();
-    bind(&V::f8, ref(v), 1, 2, 3, 4, 5, 6, 7, 8)();
-
-    bind(&V::g8, &v, 1, 2, 3, 4, 5, 6, 7, 8)();
-    bind(&V::g8, v, 1, 2, 3, 4, 5, 6, 7, 8)();
-    bind(&V::g8, ref(v), 1, 2, 3, 4, 5, 6, 7, 8)();
-
-    BOOST_TEST( v.hash == 23558 );
-}
-
 void nested_bind_test()
 {
    using namespace boost;
@@ -477,25 +256,13 @@ void nested_bind_test()
    BOOST_TEST( bind(f_2, bind(f_1, _1), bind(f_1, _1))(x) == 11L );
    BOOST_TEST( bind(f_2, bind(f_1, _1), bind(f_1, _2))(x, y) == 21L );
    BOOST_TEST( bind(f_1, bind(f_0))() == 17041L );
-
-    BOOST_TEST( (bind(fv_1, bind(f_1, _1))(x), (global_result == 1L)) );
-    BOOST_TEST( (bind(fv_1, bind(f_2, _1, _2))(x, y), (global_result == 21L)) );
-    BOOST_TEST( (bind(fv_2, bind(f_1, _1), bind(f_1, _1))(x), (global_result == 11L)) );
-    BOOST_TEST( (bind(fv_2, bind(f_1, _1), bind(f_1, _2))(x, y), (global_result == 21L)) );
-    BOOST_TEST( (bind(fv_1, bind(f_0))(), (global_result == 17041L)) );
 }

 int test_main(int, char * [])
 {
    function_test();
    function_object_test();
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-    adaptable_function_object_test();
-#endif
-
    member_function_test();
-    member_function_void_test();
    nested_bind_test();

    return 0;
--- a/bind_test_1.cpp
+++ b/bind_test_1.cpp
@@ -0,0 +1,104 @@
+#if defined(_MSC_VER) && !defined(__ICL)
+#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_test_1.cpp - tests bind.hpp with function pointers
+//
+//  Version 1.00.0003 (2001-07-13)
+//
+//  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.
+//
+
+#include <boost/bind.hpp>
+#include <iostream>
+
+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;
+}
+
+unsigned long hash = 0;
+
+template<class F> void test(F f)
+{
+    int const i = 1;
+    hash = (hash * 17041 + f(i)) % 32768;
+}
+
+int detect_errors(bool x)
+{
+    if(x)
+    {
+        std::cerr << "no errors detected.\n";
+        return 0;
+    }
+    else
+    {
+        std::cerr << "test failed.\n";
+        return 1;
+    }
+}
+
+int main()
+{
+    test(boost::bind(f_1, _1));
+    test(boost::bind(f_2, _1, 2));
+    test(boost::bind(f_3, _1, 2, 3));
+    test(boost::bind(f_4, _1, 2, 3, 4));
+    test(boost::bind(f_5, _1, 2, 3, 4, 5));
+    test(boost::bind(f_6, _1, 2, 3, 4, 5, 6));
+    test(boost::bind(f_7, _1, 2, 3, 4, 5, 6, 7));
+    test(boost::bind(f_8, _1, 2, 3, 4, 5, 6, 7, 8));
+    test(boost::bind(f_9, _1, 2, 3, 4, 5, 6, 7, 8, 9));
+
+    return detect_errors(hash == 18797);
+}
--- a/bind_test_2.cpp
+++ b/bind_test_2.cpp
@@ -0,0 +1,65 @@
+#if defined(_MSC_VER) && !defined(__ICL)
+#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_test_2.cpp - tests bind.hpp with function objects
+//
+//  Version 1.00.0005 (2001-07-13)
+//
+//  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.
+//
+
+#include <boost/bind.hpp>
+#include <boost/ref.hpp>
+#include <iostream>
+
+struct X
+{
+    short operator()(short & r) const { return ++r; }
+    int operator()(int a, int b) const { return a + 10 * b; }
+    long operator() (long a, long b, long c) const { return a + 10 * b + 100 * c; }
+};
+
+unsigned long hash = 0;
+
+template<class F> void test(F f, int const i)
+{
+    hash = (hash * 17041 + f(i)) % 32768;
+}
+
+int detect_errors(bool x)
+{
+    if(x)
+    {
+        std::cerr << "no errors detected.\n";
+        return 0;
+    }
+    else
+    {
+        std::cerr << "test failed.\n";
+        return 1;
+    }
+}
+
+int main()
+{
+    using namespace boost;
+
+    short i(6);
+
+    test(bind<short>(X(), ref(i)), 1);
+    test(bind<short>(X(), ref(i)), 2);
+    test(bind<int>(X(), i, _1), 3);
+    test(bind<long>(X(), i, _1, 9), 4);
+
+    return detect_errors(hash == 24857);
+}
--- a/bind_stdcall_mf_test.cpp
+++ b/bind_stdcall_mf_test.cpp
@@ -6,7 +6,9 @@
 #endif

 //
-//  bind_stdcall_mf_test.cpp - test for bind.hpp + __stdcall (member functions)
+//  bind_test_3.cpp - tests bind.hpp with member function pointers
+//
+//  Version 1.00.0003 (2001-07-13)
 //
 //  Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
 //
@@ -16,59 +18,59 @@
 //  warranty, and with no claim as to its suitability for any purpose.
 //

-#define BOOST_MEM_FN_ENABLE_STDCALL
-
 #include <boost/bind.hpp>
-
-#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
-#pragma warning(push, 3)
-#endif
-
+#include <boost/ref.hpp>
 #include <iostream>

-#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
-#pragma warning(pop)
-#endif
-
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-
 struct X
 {
    mutable unsigned int hash;

    X(): hash(0) {}

-    int __stdcall f0() { f1(17); return 0; }
-    int __stdcall g0() const { g1(17); return 0; }
+    int f0() { f1(17); return 0; }
+    int g0() const { g1(17); return 0; }

-    int __stdcall f1(int a1) { hash = (hash * 17041 + a1) % 32768; return 0; }
-    int __stdcall g1(int a1) const { hash = (hash * 17041 + a1 * 2) % 32768; return 0; }
+    int f1(int a1) { hash = (hash * 17041 + a1) % 32768; return 0; }
+    int g1(int a1) const { hash = (hash * 17041 + a1 * 2) % 32768; return 0; }

-    int __stdcall f2(int a1, int a2) { f1(a1); f1(a2); return 0; }
-    int __stdcall g2(int a1, int a2) const { g1(a1); g1(a2); return 0; }
+    int f2(int a1, int a2) { f1(a1); f1(a2); return 0; }
+    int g2(int a1, int a2) const { g1(a1); g1(a2); return 0; }

-    int __stdcall f3(int a1, int a2, int a3) { f2(a1, a2); f1(a3); return 0; }
-    int __stdcall g3(int a1, int a2, int a3) const { g2(a1, a2); g1(a3); return 0; }
+    int f3(int a1, int a2, int a3) { f2(a1, a2); f1(a3); return 0; }
+    int g3(int a1, int a2, int a3) const { g2(a1, a2); g1(a3); return 0; }

-    int __stdcall f4(int a1, int a2, int a3, int a4) { f3(a1, a2, a3); f1(a4); return 0; }
-    int __stdcall g4(int a1, int a2, int a3, int a4) const { g3(a1, a2, a3); g1(a4); return 0; }
+    int f4(int a1, int a2, int a3, int a4) { f3(a1, a2, a3); f1(a4); return 0; }
+    int g4(int a1, int a2, int a3, int a4) const { g3(a1, a2, a3); g1(a4); return 0; }

-    int __stdcall f5(int a1, int a2, int a3, int a4, int a5) { f4(a1, a2, a3, a4); f1(a5); return 0; }
-    int __stdcall g5(int a1, int a2, int a3, int a4, int a5) const { g4(a1, a2, a3, a4); g1(a5); return 0; }
+    int f5(int a1, int a2, int a3, int a4, int a5) { f4(a1, a2, a3, a4); f1(a5); return 0; }
+    int g5(int a1, int a2, int a3, int a4, int a5) const { g4(a1, a2, a3, a4); g1(a5); return 0; }

-    int __stdcall f6(int a1, int a2, int a3, int a4, int a5, int a6) { f5(a1, a2, a3, a4, a5); f1(a6); return 0; }
-    int __stdcall g6(int a1, int a2, int a3, int a4, int a5, int a6) const { g5(a1, a2, a3, a4, a5); g1(a6); return 0; }
+    int f6(int a1, int a2, int a3, int a4, int a5, int a6) { f5(a1, a2, a3, a4, a5); f1(a6); return 0; }
+    int g6(int a1, int a2, int a3, int a4, int a5, int a6) const { g5(a1, a2, a3, a4, a5); g1(a6); return 0; }

-    int __stdcall f7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) { f6(a1, a2, a3, a4, a5, a6); f1(a7); return 0; }
-    int __stdcall g7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) const { g6(a1, a2, a3, a4, a5, a6); g1(a7); return 0; }
+    int f7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) { f6(a1, a2, a3, a4, a5, a6); f1(a7); return 0; }
+    int g7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) const { g6(a1, a2, a3, a4, a5, a6); g1(a7); return 0; }

-    int __stdcall f8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) { f7(a1, a2, a3, a4, a5, a6, a7); f1(a8); return 0; }
-    int __stdcall g8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) const { g7(a1, a2, a3, a4, a5, a6, a7); g1(a8); return 0; }
+    int f8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) { f7(a1, a2, a3, a4, a5, a6, a7); f1(a8); return 0; }
+    int g8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) const { g7(a1, a2, a3, a4, a5, a6, a7); g1(a8); return 0; }
 };

-void member_function_test()
+int detect_errors(bool x)
+{
+    if(x)
+    {
+        std::cerr << "no errors detected.\n";
+        return 0;
+    }
+    else
+    {
+        std::cerr << "test failed.\n";
+        return 1;
+    }
+}
+
+int main()
 {
    using namespace boost;

@@ -155,11 +157,5 @@ void member_function_test()
    bind(&X::g8, x, 1, 2, 3, 4, 5, 6, 7, 8)();
    bind(&X::g8, ref(x), 1, 2, 3, 4, 5, 6, 7, 8)();

-    BOOST_TEST( x.hash == 23558 );
-}
-
-int test_main(int, char * [])
-{
-    member_function_test();
-    return 0;
+    return detect_errors(x.hash == 23558);
 }
--- a/bind_visitor.cpp
+++ b/bind_visitor.cpp
@@ -6,7 +6,9 @@
 #endif

 //
-//  bind_visitor.cpp - tests bind.hpp with a visitor
+//  bind_test_4.cpp - tests bind.hpp with a visitor
+//
+//  Version 1.00.0003 (2001-08-30)
 //
 //  Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
 //
@@ -18,48 +20,42 @@

 #include <boost/bind.hpp>
 #include <boost/ref.hpp>
-
-#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
-#pragma warning(push, 3)
-#endif
-
 #include <iostream>
 #include <typeinfo>

-#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
-#pragma warning(pop)
-#endif
-
-// default implementation of visit_each
-
-namespace boost
-{
-    template<class V, class T> void visit_each(V & v, T const & t, long)
-    {
-        v(t, 0);
-    }
-}
-
-// visitor
-
 int hash = 0;

-struct visitor
+struct ref_visitor
 {
-    template<class T> void operator()(boost::reference_wrapper<T> const & r, int) const
+    template<class R, class F, class L> void operator()(boost::_bi::bind_t<R, F, L> const & b) const
+    {
+        b.accept(*this);
+    }
+
+    template<class T> void operator()(boost::reference_wrapper<T> const & r) const
    {
        std::cout << "Reference to " << typeid(T).name() << " @ " << &r.get() << " (with value " << r.get() << ")\n";
        hash += r.get();
    }

-    template<class T> void operator()(T const &, long) const
+#ifndef BOOST_MSVC
+
+    template<class T> void operator()(T const &) const
    {
-        std::cout << "Value of type " << typeid(T).name() << '\n';
-        ++hash;
+        std::cout << "Catch-all: " << typeid(T).name() << '\n';
    }
+
+#else
+
+    void operator()(...) const
+    {
+    }
+
+#endif
+
 };

-int f(int & i, int & j, int)
+int f(int & i, int & j)
 {
    ++i;
    --j;
@@ -87,8 +83,7 @@ int main()
 {
    using namespace boost;

-    visitor v;
-    visit_each(v, bind<int>(bind(f, ref(x), _1, 42), ref(y)), 0);
+    ref_visitor()(bind<int>(bind(f, ref(x), _1), ref(y)));

-    return detect_errors(hash == 12);
+    return detect_errors(hash == 9);
 }
--- a/include/boost/bind.hpp
+++ b/include/boost/bind.hpp
--- a/include/boost/bind/arg.hpp
+++ b/include/boost/bind/arg.hpp
@@ -1,30 +0,0 @@
-#ifndef BOOST_BIND_ARG_HPP_INCLUDED
-#define BOOST_BIND_ARG_HPP_INCLUDED
-
-#if _MSC_VER >= 1020
-#pragma once
-#endif
-
-//
-//  bind/arg.hpp
-//
-//  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.
-//
-//  See http://www.boost.org/libs/bind/bind.html for documentation.
-//
-
-namespace boost
-{
-
-template<int I> class arg
-{
-};
-
-} // namespace boost
-
-#endif // #ifndef BOOST_BIND_ARG_HPP_INCLUDED
--- a/include/boost/bind/bind_cc.hpp
+++ b/include/boost/bind/bind_cc.hpp
@@ -1,118 +0,0 @@
-//
-//  bind/bind_cc.hpp - support for different calling conventions
-//
-//  Do not include this header directly.
-//
-//  Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
-//
-//  Permission to copy, use, modify, sell and distribute this software
-//  is granted provided this copyright notice appears in all copies.
-//  This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  See http://www.boost.org/libs/bind/bind.html for documentation.
-//
-
-template<class R>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (), _bi::list0>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) ())
-{
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) ();
-    typedef _bi::list0 list_type;
-    return _bi::bind_t<R, F, list_type> (f, list_type());
-}
-
-template<class R, class B1, class A1>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1), typename _bi::list_av_1<A1>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1), A1 a1)
-{
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1);
-    typedef typename _bi::list_av_1<A1>::type list_type;
-    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
-}
-
-template<class R, class B1, class B2, class A1, class A2>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2), typename _bi::list_av_2<A1, A2>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2), A1 a1, A2 a2)
-{
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2);
-    typedef typename _bi::list_av_2<A1, A2>::type list_type;
-    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
-}
-
-template<class R,
-    class B1, class B2, class B3,
-    class A1, class A2, class A3>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3), typename _bi::list_av_3<A1, A2, A3>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3), A1 a1, A2 a2, A3 a3)
-{
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3);
-    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
-    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
-}
-
-template<class R,
-    class B1, class B2, class B3, class B4,
-    class A1, class A2, class A3, class A4>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4), typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4)
-{
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4);
-    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
-    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
-}
-
-template<class R,
-    class B1, class B2, class B3, class B4, class B5,
-    class A1, class A2, class A3, class A4, class A5>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5), typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
-{
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5);
-    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
-    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
-}
-
-template<class R,
-    class B1, class B2, class B3, class B4, class B5, class B6,
-    class A1, class A2, class A3, class A4, class A5, class A6>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6), typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
-{
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6);
-    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
-    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
-}
-
-template<class R,
-    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7), typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
-{
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7);
-    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
-    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
-}
-
-template<class R,
-    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7, B8), typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
-{
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8);
-    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
-    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
-}
-
-template<class R,
-    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8, class B9,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7, B8, B9), typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
-{
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9);
-    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
-    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
-}
--- a/include/boost/bind/bind_mf_cc.hpp
+++ b/include/boost/bind/bind_mf_cc.hpp
@@ -1,228 +0,0 @@
-//
-//  bind/bind_mf_cc.hpp - support for different calling conventions
-//
-//  Do not include this header directly.
-//
-//  Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
-//
-//  Permission to copy, use, modify, sell and distribute this software
-//  is granted provided this copyright notice appears in all copies.
-//  This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  See http://www.boost.org/libs/bind/bind.html for documentation.
-//
-
-// 0
-
-template<class R, class T,
-    class A1>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf0)<R, T>, typename _bi::list_av_1<A1>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (), A1 a1)
-{
-    typedef _mfi::BOOST_BIND_MF_NAME(mf0)<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));
-}
-
-template<class R, class T,
-    class A1>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf0)<R, T>, typename _bi::list_av_1<A1>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const, A1 a1)
-{
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf0)<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));
-}
-
-// 1
-
-template<class R, class T,
-    class B1,
-    class A1, class A2>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1), A1 a1, A2 a2)
-{
-    typedef _mfi::BOOST_BIND_MF_NAME(mf1)<R, T, B1> F;
-    typedef typename _bi::list_av_2<A1, A2>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
-}
-
-template<class R, class T,
-    class B1,
-    class A1, class A2>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const, A1 a1, A2 a2)
-{
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf1)<R, T, B1> F;
-    typedef typename _bi::list_av_2<A1, A2>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
-}
-
-// 2
-
-template<class R, class T,
-    class B1, class B2,
-    class A1, class A2, class A3>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
-{
-    typedef _mfi::BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2> F;
-    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
-}
-
-template<class R, class T,
-    class B1, class B2,
-    class A1, class A2, class A3>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
-{
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2> F;
-    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
-}
-
-// 3
-
-template<class R, class T,
-    class B1, class B2, class B3,
-    class A1, class A2, class A3, class A4>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
-{
-    typedef _mfi::BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3> F;
-    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
-}
-
-template<class R, class T,
-    class B1, class B2, class B3,
-    class A1, class A2, class A3, class A4>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
-{
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3> F;
-    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
-}
-
-// 4
-
-template<class R, class T,
-    class B1, class B2, class B3, class B4,
-    class A1, class A2, class A3, class A4, class A5>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
-{
-    typedef _mfi::BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4> F;
-    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
-}
-
-template<class R, class T,
-    class B1, class B2, class B3, class B4,
-    class A1, class A2, class A3, class A4, class A5>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
-{
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4> F;
-    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
-}
-
-// 5
-
-template<class R, class T,
-    class B1, class B2, class B3, class B4, class B5,
-    class A1, class A2, class A3, class A4, class A5, class A6>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
-{
-    typedef _mfi::BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5> F;
-    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
-}
-
-template<class R, class T,
-    class B1, class B2, class B3, class B4, class B5,
-    class A1, class A2, class A3, class A4, class A5, class A6>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
-{
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5> F;
-    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
-}
-
-// 6
-
-template<class R, class T,
-    class B1, class B2, class B3, class B4, class B5, class B6,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
-{
-    typedef _mfi::BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6> F;
-    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
-}
-
-template<class R, class T,
-    class B1, class B2, class B3, class B4, class B5, class B6,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
-{
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6> F;
-    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
-}
-
-// 7
-
-template<class R, class T,
-    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
-{
-    typedef _mfi::BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
-    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
-}
-
-template<class R, class T,
-    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
-{
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
-    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
-}
-
-// 8
-
-template<class R, class T,
-    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
-{
-    typedef _mfi::BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
-    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
-}
-
-template<class R, class T,
-    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
-{
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
-    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
-}
--- a/include/boost/bind/bind_template.hpp
+++ b/include/boost/bind/bind_template.hpp
@@ -1,157 +0,0 @@
-//
-//  bind/bind_template.hpp
-//
-//  Do not include this header directly.
-//
-//  Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
-//
-//  Permission to copy, use, modify, sell and distribute this software
-//  is granted provided this copyright notice appears in all copies.
-//  This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  See http://www.boost.org/libs/bind/bind.html for documentation.
-//
-
-    typedef typename result_traits<R, F>::type result_type;
-
-    result_type operator()()
-    {
-        list0 a;
-        BOOST_BIND_EVALUATE;
-    }
-
-    result_type operator()() const
-    {
-        list0 a;
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class A1> result_type operator()(A1 & a1)
-    {
-        list1<A1 &> a(a1);
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class A1> result_type operator()(A1 & a1) const
-    {
-        list1<A1 &> a(a1);
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
-    {
-        list2<A1 &, A2 &> a(a1, a2);
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
-    {
-        list2<A1 &, A2 &> a(a1, a2);
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
-    {
-        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
-    {
-        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
-    {
-        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
-    {
-        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
-    {
-        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
-    {
-        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
-    {
-        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
-    {
-        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
-    {
-        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
-    {
-        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
-    {
-        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
-    {
-        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
-    {
-        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
-    {
-        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class A> result_type eval(A & a)
-    {
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class A> result_type eval(A & a) const
-    {
-        BOOST_BIND_EVALUATE;
-    }
-
-    template<class V> void accept(V & v) const
-    {
-        BOOST_BIND_VISIT_EACH(v, f_, 0);
-        l_.accept(v);
-    }
-
-private:
-
-    F f_;
-    L l_;
--- a/include/boost/bind/mem_fn_cc.hpp
+++ b/include/boost/bind/mem_fn_cc.hpp
@@ -1,104 +0,0 @@
-//
-//  bind/mem_fn_cc.hpp - support for different calling conventions
-//
-//  Do not include this header directly.
-//
-//  Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
-//
-//  Permission to copy, use, modify, sell and distribute this software
-//  is granted provided this copyright notice appears in all copies.
-//  This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
-//
-
-template<class R, class T> _mfi::BOOST_MEM_FN_NAME(mf0)<R, T> mem_fn(R (BOOST_MEM_FN_CC T::*f) ())
-{
-    return _mfi::BOOST_MEM_FN_NAME(mf0)<R, T>(f);
-}
-
-template<class R, class T> _mfi::BOOST_MEM_FN_NAME(cmf0)<R, T> mem_fn(R (BOOST_MEM_FN_CC T::*f) () const)
-{
-    return _mfi::BOOST_MEM_FN_NAME(cmf0)<R, T>(f);
-}
-
-template<class R, class T, class A1> _mfi::BOOST_MEM_FN_NAME(mf1)<R, T, A1> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1))
-{
-    return _mfi::BOOST_MEM_FN_NAME(mf1)<R, T, A1>(f);
-}
-
-template<class R, class T, class A1> _mfi::BOOST_MEM_FN_NAME(cmf1)<R, T, A1> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1) const)
-{
-    return _mfi::BOOST_MEM_FN_NAME(cmf1)<R, T, A1>(f);
-}
-
-template<class R, class T, class A1, class A2> _mfi::BOOST_MEM_FN_NAME(mf2)<R, T, A1, A2> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2))
-{
-    return _mfi::BOOST_MEM_FN_NAME(mf2)<R, T, A1, A2>(f);
-}
-
-template<class R, class T, class A1, class A2> _mfi::BOOST_MEM_FN_NAME(cmf2)<R, T, A1, A2> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2) const)
-{
-    return _mfi::BOOST_MEM_FN_NAME(cmf2)<R, T, A1, A2>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3> _mfi::BOOST_MEM_FN_NAME(mf3)<R, T, A1, A2, A3> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3))
-{
-    return _mfi::BOOST_MEM_FN_NAME(mf3)<R, T, A1, A2, A3>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3> _mfi::BOOST_MEM_FN_NAME(cmf3)<R, T, A1, A2, A3> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3) const)
-{
-    return _mfi::BOOST_MEM_FN_NAME(cmf3)<R, T, A1, A2, A3>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3, class A4> _mfi::BOOST_MEM_FN_NAME(mf4)<R, T, A1, A2, A3, A4> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4))
-{
-    return _mfi::BOOST_MEM_FN_NAME(mf4)<R, T, A1, A2, A3, A4>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3, class A4> _mfi::BOOST_MEM_FN_NAME(cmf4)<R, T, A1, A2, A3, A4> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4) const)
-{
-    return _mfi::BOOST_MEM_FN_NAME(cmf4)<R, T, A1, A2, A3, A4>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::BOOST_MEM_FN_NAME(mf5)<R, T, A1, A2, A3, A4, A5> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5))
-{
-    return _mfi::BOOST_MEM_FN_NAME(mf5)<R, T, A1, A2, A3, A4, A5>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::BOOST_MEM_FN_NAME(cmf5)<R, T, A1, A2, A3, A4, A5> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5) const)
-{
-    return _mfi::BOOST_MEM_FN_NAME(cmf5)<R, T, A1, A2, A3, A4, A5>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::BOOST_MEM_FN_NAME(mf6)<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6))
-{
-    return _mfi::BOOST_MEM_FN_NAME(mf6)<R, T, A1, A2, A3, A4, A5, A6>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::BOOST_MEM_FN_NAME(cmf6)<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6) const)
-{
-    return _mfi::BOOST_MEM_FN_NAME(cmf6)<R, T, A1, A2, A3, A4, A5, A6>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::BOOST_MEM_FN_NAME(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7))
-{
-    return _mfi::BOOST_MEM_FN_NAME(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::BOOST_MEM_FN_NAME(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7) const)
-{
-    return _mfi::BOOST_MEM_FN_NAME(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::BOOST_MEM_FN_NAME(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7, A8))
-{
-    return _mfi::BOOST_MEM_FN_NAME(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::BOOST_MEM_FN_NAME(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7, A8) const)
-{
-    return _mfi::BOOST_MEM_FN_NAME(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
-}
--- a/include/boost/bind/mem_fn_template.hpp
+++ b/include/boost/bind/mem_fn_template.hpp
@@ -1,755 +0,0 @@
-//
-//  bind/mem_fn_template.hpp
-//
-//  Do not include this header directly
-//
-//  Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
-//
-//  Permission to copy, use, modify, sell and distribute this software
-//  is granted provided this copyright notice appears in all copies.
-//  This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
-//
-
-// mf0
-
-template<class R, class T BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf0)
-{
-public:
-
-    typedef R result_type;
-    typedef T * argument_type;
-
-private:
-    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) ())
-    F f_;
-
-    template<class U> R call(U & u, T const *) const
-    {
-        BOOST_MEM_FN_RETURN (u.*f_)();
-    }
-
-    template<class U> R call(U & u, void const *) const
-    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
-    }
-
-public:
-    
-    explicit BOOST_MEM_FN_NAME(mf0)(F f): f_(f) {}
-
-    R operator()(T * p) const
-    {
-        BOOST_MEM_FN_RETURN (p->*f_)();
-    }
-
-    template<class U> R operator()(U & u) const
-    {
-        BOOST_MEM_FN_RETURN call(u, &u);
-    }
-
-    R operator()(T & t) const
-    {
-        BOOST_MEM_FN_RETURN (t.*f_)();
-    }
-};
-
-// cmf0
-
-template<class R, class T BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf0)
-{
-public:
-
-    typedef R result_type;
-    typedef T const * argument_type;
-
-private:
-    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) () const)
-    F f_;
-
-    template<class U> R call(U & u, T const *) const
-    {
-        BOOST_MEM_FN_RETURN (u.*f_)();
-    }
-
-    template<class U> R call(U & u, void const *) const
-    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
-    }
-
-public:
-    
-    explicit BOOST_MEM_FN_NAME(cmf0)(F f): f_(f) {}
-
-    template<class U> R operator()(U const & u) const
-    {
-        BOOST_MEM_FN_RETURN call(u, &u);
-    }
-
-    R operator()(T const & t) const
-    {
-        BOOST_MEM_FN_RETURN (t.*f_)();
-    }
-};
-
-// mf1
-
-template<class R, class T, class A1 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf1)
-{
-public:
-
-    typedef R result_type;
-    typedef T * first_argument_type;
-    typedef A1 second_argument_type;
-
-private:
-    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1))
-    F f_;
-
-    template<class U, class B1> R call(U & u, T const *, B1 & b1) const
-    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1);
-    }
-
-    template<class U, class B1> R call(U & u, void const *, B1 & b1) const
-    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
-    }
-
-public:
-    
-    explicit BOOST_MEM_FN_NAME(mf1)(F f): f_(f) {}
-
-    R operator()(T * p, A1 a1) const
-    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1);
-    }
-
-    template<class U> R operator()(U & u, A1 a1) const
-    {
-        BOOST_MEM_FN_RETURN call(u, &u, a1);
-    }
-
-    R operator()(T & t, A1 a1) const
-    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1);
-    }
-};
-
-// cmf1
-
-template<class R, class T, class A1 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf1)
-{
-public:
-
-    typedef R result_type;
-    typedef T const * first_argument_type;
-    typedef A1 second_argument_type;
-
-private:
-    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1) const)
-    F f_;
-
-    template<class U, class B1> R call(U & u, T const *, B1 & b1) const
-    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1);
-    }
-
-    template<class U, class B1> R call(U & u, void const *, B1 & b1) const
-    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
-    }
-
-public:
-    
-    explicit BOOST_MEM_FN_NAME(cmf1)(F f): f_(f) {}
-
-    template<class U> R operator()(U const & u, A1 a1) const
-    {
-        BOOST_MEM_FN_RETURN call(u, &u, a1);
-    }
-
-    R operator()(T const & t, A1 a1) const
-    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1);
-    }
-};
-
-// mf2
-
-template<class R, class T, class A1, class A2 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf2)
-{
-public:
-
-    typedef R result_type;
-
-private:
-    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2))
-    F f_;
-
-    template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
-    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
-    }
-
-    template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
-    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
-    }
-
-public:
-    
-    explicit BOOST_MEM_FN_NAME(mf2)(F f): f_(f) {}
-
-    R operator()(T * p, A1 a1, A2 a2) const
-    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2);
-    }
-
-    template<class U> R operator()(U & u, A1 a1, A2 a2) const
-    {
-        BOOST_MEM_FN_RETURN call(u, &u, a1, a2);
-    }
-
-    R operator()(T & t, A1 a1, A2 a2) const
-    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
-    }
-};
-
-// cmf2
-
-template<class R, class T, class A1, class A2 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf2)
-{
-public:
-
-    typedef R result_type;
-
-private:
-    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2) const)
-    F f_;
-
-    template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
-    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
-    }
-
-    template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
-    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
-    }
-
-public:
-    
-    explicit BOOST_MEM_FN_NAME(cmf2)(F f): f_(f) {}
-
-    template<class U> R operator()(U const & u, A1 a1, A2 a2) const
-    {
-        BOOST_MEM_FN_RETURN call(u, &u, a1, a2);
-    }
-
-    R operator()(T const & t, A1 a1, A2 a2) const
-    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
-    }
-};
-
-// mf3
-
-template<class R, class T, class A1, class A2, class A3 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf3)
-{
-public:
-
-    typedef R result_type;
-
-private:
-    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3))
-    F f_;
-
-    template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
-    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3);
-    }
-
-    template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
-    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3);
-    }
-
-public:
-    
-    explicit BOOST_MEM_FN_NAME(mf3)(F f): f_(f) {}
-
-    R operator()(T * p, A1 a1, A2 a2, A3 a3) const
-    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3);
-    }
-
-    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
-    {
-        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3);
-    }
-
-    R operator()(T & t, A1 a1, A2 a2, A3 a3) const
-    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
-    }
-};
-
-// cmf3
-
-template<class R, class T, class A1, class A2, class A3 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf3)
-{
-public:
-
-    typedef R result_type;
-
-private:
-
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const)
-    F f_;
-
-    template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
-    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3);
-    }
-
-    template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
-    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3);
-    }
-
-public:
-
-    explicit BOOST_MEM_FN_NAME(cmf3)(F f): f_(f) {}
-
-    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
-    {
-        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3);
-    }
-
-    R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
-    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
-    }
-};
-
-// mf4
-
-template<class R, class T, class A1, class A2, class A3, class A4 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf4)
-{
-public:
-
-    typedef R result_type;
-
-private:
-    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4))
-    F f_;
-
-    template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
-    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
-    }
-
-    template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
-    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
-    }
-
-public:
-    
-    explicit BOOST_MEM_FN_NAME(mf4)(F f): f_(f) {}
-
-    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const
-    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4);
-    }
-
-    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
-    {
-        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4);
-    }
-
-    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const
-    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
-    }
-};
-
-// cmf4
-
-template<class R, class T, class A1, class A2, class A3, class A4 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf4)
-{
-public:
-
-    typedef R result_type;
-
-private:
-    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const)
-    F f_;
-
-    template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
-    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
-    }
-
-    template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
-    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
-    }
-
-public:
-    
-    explicit BOOST_MEM_FN_NAME(cmf4)(F f): f_(f) {}
-
-    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
-    {
-        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4);
-    }
-
-    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
-    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
-    }
-};
-
-// mf5
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf5)
-{
-public:
-
-    typedef R result_type;
-
-private:
-    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5))
-    F f_;
-
-    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
-    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5);
-    }
-
-    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
-    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
-    }
-
-public:
-    
-    explicit BOOST_MEM_FN_NAME(mf5)(F f): f_(f) {}
-
-    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
-    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5);
-    }
-
-    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
-    {
-        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5);
-    }
-
-    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
-    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
-    }
-};
-
-// cmf5
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf5)
-{
-public:
-
-    typedef R result_type;
-
-private:
-    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const)
-    F f_;
-
-    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
-    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5);
-    }
-
-    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
-    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
-    }
-
-public:
-    
-    explicit BOOST_MEM_FN_NAME(cmf5)(F f): f_(f) {}
-
-    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
-    {
-        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5);
-    }
-
-    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
-    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
-    }
-};
-
-// mf6
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf6)
-{
-public:
-
-    typedef R result_type;
-
-private:
-
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6))
-    F f_;
-
-    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
-    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6);
-    }
-
-    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
-    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
-    }
-
-public:
-
-    explicit BOOST_MEM_FN_NAME(mf6)(F f): f_(f) {}
-
-    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
-    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6);
-    }
-
-    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
-    {
-        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6);
-    }
-
-    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
-    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
-    }
-};
-
-// cmf6
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf6)
-{
-public:
-
-    typedef R result_type;
-
-private:
-    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const)
-    F f_;
-
-    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
-    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6);
-    }
-
-    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
-    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
-    }
-
-public:
-    
-    explicit BOOST_MEM_FN_NAME(cmf6)(F f): f_(f) {}
-
-    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
-    {
-        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6);
-    }
-
-    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
-    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
-    }
-};
-
-// mf7
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf7)
-{
-public:
-
-    typedef R result_type;
-
-private:
-    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7))
-    F f_;
-
-    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
-    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
-    }
-
-    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
-    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
-    }
-
-public:
-    
-    explicit BOOST_MEM_FN_NAME(mf7)(F f): f_(f) {}
-
-    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
-    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
-    }
-
-    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
-    {
-        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7);
-    }
-
-    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
-    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
-    }
-};
-
-// cmf7
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf7)
-{
-public:
-
-    typedef R result_type;
-
-private:
-    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const)
-    F f_;
-
-    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
-    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
-    }
-
-    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
-    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
-    }
-
-public:
-    
-    explicit BOOST_MEM_FN_NAME(cmf7)(F f): f_(f) {}
-
-    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
-    {
-        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7);
-    }
-
-    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
-    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
-    }
-};
-
-// mf8
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf8)
-{
-public:
-
-    typedef R result_type;
-
-private:
-    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8))
-    F f_;
-
-    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
-    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
-    }
-
-    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
-    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
-    }
-
-public:
-    
-    explicit BOOST_MEM_FN_NAME(mf8)(F f): f_(f) {}
-
-    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
-    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
-    }
-
-    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
-    {
-        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7, a8);
-    }
-
-    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
-    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
-    }
-};
-
-// cmf8
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf8)
-{
-public:
-
-    typedef R result_type;
-
-private:
-    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const)
-    F f_;
-
-    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
-    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
-    }
-
-    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
-    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
-    }
-
-public:
-    
-    explicit BOOST_MEM_FN_NAME(cmf8)(F f): f_(f) {}
-
-    R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
-    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
-    }
-
-    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
-    {
-        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7, a8);
-    }
-
-    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
-    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
-    }
-};
-
--- a/include/boost/bind/mem_fn_vw.hpp
+++ b/include/boost/bind/mem_fn_vw.hpp
@@ -1,131 +0,0 @@
-//
-//  bind/mem_fn_vw.hpp - void return helper wrappers
-//
-//  Do not include this header directly
-//
-//  Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
-//
-//  Permission to copy, use, modify, sell and distribute this software
-//  is granted provided this copyright notice appears in all copies.
-//  This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
-//
-
-template<class R, class T> struct BOOST_MEM_FN_NAME(mf0): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf0)<R, T, R (BOOST_MEM_FN_CC T::*) ()>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) ();
-    explicit BOOST_MEM_FN_NAME(mf0)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf0)<R, T, F>(f) {}
-};
-
-template<class R, class T> struct BOOST_MEM_FN_NAME(cmf0): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf0)<R, T, R (BOOST_MEM_FN_CC T::*) () const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) () const;
-    explicit BOOST_MEM_FN_NAME(cmf0)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf0)<R, T, F>(f) {}
-};
-
-
-template<class R, class T, class A1> struct BOOST_MEM_FN_NAME(mf1): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf1)<R, T, A1, R (BOOST_MEM_FN_CC T::*) (A1)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1);
-    explicit BOOST_MEM_FN_NAME(mf1)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf1)<R, T, A1, F>(f) {}
-};
-
-template<class R, class T, class A1> struct BOOST_MEM_FN_NAME(cmf1): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf1)<R, T, A1, R (BOOST_MEM_FN_CC T::*) (A1) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1) const;
-    explicit BOOST_MEM_FN_NAME(cmf1)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf1)<R, T, A1, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2> struct BOOST_MEM_FN_NAME(mf2): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf2)<R, T, A1, A2, R (BOOST_MEM_FN_CC T::*) (A1, A2)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2);
-    explicit BOOST_MEM_FN_NAME(mf2)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf2)<R, T, A1, A2, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2> struct BOOST_MEM_FN_NAME(cmf2): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf2)<R, T, A1, A2, R (BOOST_MEM_FN_CC T::*) (A1, A2) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2) const;
-    explicit BOOST_MEM_FN_NAME(cmf2)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf2)<R, T, A1, A2, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2, class A3> struct BOOST_MEM_FN_NAME(mf3): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf3)<R, T, A1, A2, A3, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3);
-    explicit BOOST_MEM_FN_NAME(mf3)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf3)<R, T, A1, A2, A3, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2, class A3> struct BOOST_MEM_FN_NAME(cmf3): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf3)<R, T, A1, A2, A3, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const;
-    explicit BOOST_MEM_FN_NAME(cmf3)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf3)<R, T, A1, A2, A3, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2, class A3, class A4> struct BOOST_MEM_FN_NAME(mf4): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf4)<R, T, A1, A2, A3, A4, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4);
-    explicit BOOST_MEM_FN_NAME(mf4)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf4)<R, T, A1, A2, A3, A4, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2, class A3, class A4> struct BOOST_MEM_FN_NAME(cmf4): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf4)<R, T, A1, A2, A3, A4, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const;
-    explicit BOOST_MEM_FN_NAME(cmf4)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf4)<R, T, A1, A2, A3, A4, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5> struct BOOST_MEM_FN_NAME(mf5): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf5)<R, T, A1, A2, A3, A4, A5, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5);
-    explicit BOOST_MEM_FN_NAME(mf5)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf5)<R, T, A1, A2, A3, A4, A5, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5> struct BOOST_MEM_FN_NAME(cmf5): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf5)<R, T, A1, A2, A3, A4, A5, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const;
-    explicit BOOST_MEM_FN_NAME(cmf5)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf5)<R, T, A1, A2, A3, A4, A5, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> struct BOOST_MEM_FN_NAME(mf6): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf6)<R, T, A1, A2, A3, A4, A5, A6, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6);
-    explicit BOOST_MEM_FN_NAME(mf6)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf6)<R, T, A1, A2, A3, A4, A5, A6, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> struct BOOST_MEM_FN_NAME(cmf6): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf6)<R, T, A1, A2, A3, A4, A5, A6, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const;
-    explicit BOOST_MEM_FN_NAME(cmf6)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf6)<R, T, A1, A2, A3, A4, A5, A6, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct BOOST_MEM_FN_NAME(mf7): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7);
-    explicit BOOST_MEM_FN_NAME(mf7)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct BOOST_MEM_FN_NAME(cmf7): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const;
-    explicit BOOST_MEM_FN_NAME(cmf7)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct BOOST_MEM_FN_NAME(mf8): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7, A8)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8);
-    explicit BOOST_MEM_FN_NAME(mf8)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct BOOST_MEM_FN_NAME(cmf8): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7, A8) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const;
-    explicit BOOST_MEM_FN_NAME(cmf8)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, F>(f) {}
-};
-
--- a/include/boost/bind/placeholders.hpp
+++ b/include/boost/bind/placeholders.hpp
@@ -1,49 +0,0 @@
-#ifndef BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED
-#define BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED
-
-#if _MSC_VER >= 1020
-#pragma once
-#endif
-
-//
-//  bind/placeholders.hpp - _N definitions
-//
-//  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.
-//
-//  See http://www.boost.org/libs/bind/bind.html for documentation.
-//
-
-#include <boost/bind/arg.hpp>
-#include <boost/config.hpp>
-
-// With MSVC precompiled headers, unnamed namespaces are not unique
-
-#ifdef BOOST_MSVC
-# define BOOST_BIND_STATIC static
-#else
-# define BOOST_BIND_STATIC
-#endif
-
-namespace
-{
-
-BOOST_BIND_STATIC boost::arg<1> _1;
-BOOST_BIND_STATIC boost::arg<2> _2;
-BOOST_BIND_STATIC boost::arg<3> _3;
-BOOST_BIND_STATIC boost::arg<4> _4;
-BOOST_BIND_STATIC boost::arg<5> _5;
-BOOST_BIND_STATIC boost::arg<6> _6;
-BOOST_BIND_STATIC boost::arg<7> _7;
-BOOST_BIND_STATIC boost::arg<8> _8;
-BOOST_BIND_STATIC boost::arg<9> _9;
-
-} // unnamed namespace
-
-#undef BOOST_BIND_STATIC
-
-#endif // #ifndef BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED
--- a/include/boost/mem_fn.hpp
+++ b/include/boost/mem_fn.hpp
@@ -1,15 +1,16 @@
 #ifndef BOOST_MEM_FN_HPP_INCLUDED
 #define BOOST_MEM_FN_HPP_INCLUDED

-#if _MSC_VER+0 >= 1020
+#if _MSC_VER >= 1020
 #pragma once
 #endif

 //
 //  mem_fn.hpp - a generalization of std::mem_fun[_ref]
 //
+//  Version 1.02.0001 (2001-08-30)
+//
 //  Copyright (c) 2001 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.
@@ -19,8 +20,6 @@
 //  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
 //

-#include <boost/config.hpp>
-
 namespace boost
 {

@@ -31,161 +30,674 @@ template<class T> T * get_pointer(T * p)
    return p;
 }

-// get_pointer(shared_ptr<T> const & p) has been moved to shared_ptr.hpp
+// implementation of get_pointer for boost::shared_ptr
+// this will probably migrate to boost/shared_ptr.hpp

-#if defined(BOOST_NO_VOID_RETURNS)
+template<class T> class shared_ptr;

-#define BOOST_MEM_FN_CLASS_F , class F
-#define BOOST_MEM_FN_TYPEDEF(X)
+template<class T> T * get_pointer(shared_ptr<T> const & p)
+{
+    return p.get();
+}
+
+//

 namespace _mfi // mem_fun_impl
 {

-template<class V> struct mf
+// mf0
+
+template<class R, class T> class mf0
 {
+public:

-#define BOOST_MEM_FN_RETURN return
+    typedef R result_type;
+    typedef T * first_argument_type;

-#define BOOST_MEM_FN_NAME(X) inner_##X
-#define BOOST_MEM_FN_CC
+private:
+    
+    typedef R (T::*F) ();
+    F f_;

-#include <boost/bind/mem_fn_template.hpp>
+public:
+    
+    explicit mf0(F f): f_(f) {}

-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
+    R operator()(T * p) const
+    {
+        return (p->*f_)();
+    }

-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
+    template<class U> R operator()(U & u) const
+    {
+        return (get_pointer(u)->*f_)();
+    }

-#define BOOST_MEM_FN_NAME(X) inner_##X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
+    R operator()(T & t) const
+    {
+        return (t.*f_)();
+    }
+};

-#include <boost/bind/mem_fn_template.hpp>
+// cmf0

-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#undef BOOST_MEM_FN_RETURN
-
-}; // struct mf<V>
-
-template<> struct mf<void>
+template<class R, class T> class cmf0
 {
+public:

-#define BOOST_MEM_FN_RETURN
+    typedef R result_type;
+    typedef T const * first_argument_type;

-#define BOOST_MEM_FN_NAME(X) inner_##X
-#define BOOST_MEM_FN_CC
+private:
+    
+    typedef R (T::*F) () const;
+    F f_;

-#include <boost/bind/mem_fn_template.hpp>
+public:
+    
+    explicit cmf0(F f): f_(f) {}

-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
+    template<class U> R operator()(U const & u) const
+    {
+        return (get_pointer(u)->*f_)();
+    }

-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
+    R operator()(T const & t) const
+    {
+        return (t.*f_)();
+    }
+};

-#define BOOST_MEM_FN_NAME(X) inner_##X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
+// mf1

-#include <boost/bind/mem_fn_template.hpp>
+template<class R, class T, class A1> class mf1
+{
+public:

-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
+    typedef R result_type;
+    typedef T * first_argument_type;
+    typedef A1 second_argument_type;

-#endif
+private:
+    
+    typedef R (T::*F) (A1);
+    F f_;

-#undef BOOST_MEM_FN_RETURN
+public:
+    
+    explicit mf1(F f): f_(f) {}

-}; // struct mf<void>
+    R operator()(T * p, A1 a1) const
+    {
+        return (p->*f_)(a1);
+    }

-#undef BOOST_MEM_FN_CLASS_F
-#undef BOOST_MEM_FN_TYPEDEF_F
+    template<class U> R operator()(U & u, A1 a1) const
+    {
+        return (get_pointer(u)->*f_)(a1);
+    }

-#define BOOST_MEM_FN_NAME(X) X
-#define BOOST_MEM_FN_NAME2(X) inner_##X
-#define BOOST_MEM_FN_CC
+    R operator()(T & t, A1 a1) const
+    {
+        return (t.*f_)(a1);
+    }
+};

-#include <boost/bind/mem_fn_vw.hpp>
+// cmf1

-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
+template<class R, class T, class A1> class cmf1
+{
+public:

-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
+    typedef R result_type;
+    typedef T const * first_argument_type;
+    typedef A1 second_argument_type;

-#define BOOST_MEM_FN_NAME(X) X##_stdcall
-#define BOOST_MEM_FN_NAME2(X) inner_##X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
+private:
+    
+    typedef R (T::*F) (A1) const;
+    F f_;

-#include <boost/bind/mem_fn_vw.hpp>
+public:
+    
+    explicit cmf1(F f): f_(f) {}

-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
+    template<class U> R operator()(U const & u, A1 a1) const
+    {
+        return (get_pointer(u)->*f_)(a1);
+    }

-#endif
+    R operator()(T const & t, A1 a1) const
+    {
+        return (t.*f_)(a1);
+    }
+};
+
+// mf2
+
+template<class R, class T, class A1, class A2> class mf2
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (T::*F) (A1, A2);
+    F f_;
+
+public:
+    
+    explicit mf2(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2) const
+    {
+        return (p->*f_)(a1, a2);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2) const
+    {
+        return (get_pointer(u)->*f_)(a1, a2);
+    }
+
+    R operator()(T & t, A1 a1, A2 a2) const
+    {
+        return (t.*f_)(a1, a2);
+    }
+};
+
+// cmf2
+
+template<class R, class T, class A1, class A2> class cmf2
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (T::*F) (A1, A2) const;
+    F f_;
+
+public:
+    
+    explicit cmf2(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2) const
+    {
+        return (get_pointer(u)->*f_)(a1, a2);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2) const
+    {
+        return (t.*f_)(a1, a2);
+    }
+};
+
+// mf3
+
+template<class R, class T, class A1, class A2, class A3> class mf3
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (T::*F) (A1, A2, A3);
+    F f_;
+
+public:
+    
+    explicit mf3(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3) const
+    {
+        return (p->*f_)(a1, a2, a3);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
+    {
+        return (get_pointer(u)->*f_)(a1, a2, a3);
+    }
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3) const
+    {
+        return (t.*f_)(a1, a2, a3);
+    }
+};
+
+// cmf3
+
+template<class R, class T, class A1, class A2, class A3> class cmf3
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R (T::*F) (A1, A2, A3) const;
+    F f_;
+
+public:
+
+    explicit cmf3(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
+    {
+        return (get_pointer(u)->*f_)(a1, a2, a3);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
+    {
+        return (t.*f_)(a1, a2, a3);
+    }
+};
+
+// mf4
+
+template<class R, class T, class A1, class A2, class A3, class A4> class mf4
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (T::*F) (A1, A2, A3, A4);
+    F f_;
+
+public:
+    
+    explicit mf4(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        return (p->*f_)(a1, a2, a3, a4);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        return (get_pointer(u)->*f_)(a1, a2, a3, a4);
+    }
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        return (t.*f_)(a1, a2, a3, a4);
+    }
+};
+
+// cmf4
+
+template<class R, class T, class A1, class A2, class A3, class A4> class cmf4
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (T::*F) (A1, A2, A3, A4) const;
+    F f_;
+
+public:
+    
+    explicit cmf4(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        return (get_pointer(u)->*f_)(a1, a2, a3, a4);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        return (t.*f_)(a1, a2, a3, a4);
+    }
+};
+
+// mf5
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> class mf5
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (T::*F) (A1, A2, A3, A4, A5);
+    F f_;
+
+public:
+    
+    explicit mf5(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        return (p->*f_)(a1, a2, a3, a4, a5);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        return (get_pointer(u)->*f_)(a1, a2, a3, a4, a5);
+    }
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5);
+    }
+};
+
+// cmf5
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> class cmf5
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (T::*F) (A1, A2, A3, A4, A5) const;
+    F f_;
+
+public:
+    
+    explicit cmf5(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        return (get_pointer(u)->*f_)(a1, a2, a3, a4, a5);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5);
+    }
+};
+
+// mf6
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> class mf6
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R (T::*F) (A1, A2, A3, A4, A5, A6);
+    F f_;
+
+public:
+
+    explicit mf6(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        return (p->*f_)(a1, a2, a3, a4, a5, a6);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        return (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6);
+    }
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6);
+    }
+};
+
+// cmf6
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> class cmf6
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (T::*F) (A1, A2, A3, A4, A5, A6) const;
+    F f_;
+
+public:
+    
+    explicit cmf6(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        return (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6);
+    }
+};
+
+// mf7
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> class mf7
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (T::*F) (A1, A2, A3, A4, A5, A6, A7);
+    F f_;
+
+public:
+    
+    explicit mf7(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        return (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6, a7);
+    }
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
+    }
+};
+
+// cmf7
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> class cmf7
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (T::*F) (A1, A2, A3, A4, A5, A6, A7) const;
+    F f_;
+
+public:
+    
+    explicit cmf7(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        return (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6, a7);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
+    }
+};
+
+// mf8
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> class mf8
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (T::*F) (A1, A2, A3, A4, A5, A6, A7, A8);
+    F f_;
+
+public:
+    
+    explicit mf8(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        return (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+};
+
+// cmf8
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> class cmf8
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const;
+    F f_;
+
+public:
+    
+    explicit cmf8(F f): f_(f) {}
+
+    R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        return (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+};

 } // namespace _mfi

-#else // #ifdef BOOST_NO_VOID_RETURNS
+// mem_fn

-#define BOOST_MEM_FN_CLASS_F
-#define BOOST_MEM_FN_TYPEDEF(X) typedef X;
-
-namespace _mfi
+template<class R, class T> _mfi::mf0<R, T> mem_fn(R (T::*f) ())
 {
+    return _mfi::mf0<R, T>(f);
+}

-#define BOOST_MEM_FN_RETURN return
+template<class R, class T> _mfi::cmf0<R, T> mem_fn(R (T::*f) () const)
+{
+    return _mfi::cmf0<R, T>(f);
+}

-#define BOOST_MEM_FN_NAME(X) X
-#define BOOST_MEM_FN_CC
+template<class R, class T, class A1> _mfi::mf1<R, T, A1> mem_fn(R (T::*f) (A1))
+{
+    return _mfi::mf1<R, T, A1>(f);
+}

-#include <boost/bind/mem_fn_template.hpp>
+template<class R, class T, class A1> _mfi::cmf1<R, T, A1> mem_fn(R (T::*f) (A1) const)
+{
+    return _mfi::cmf1<R, T, A1>(f);
+}

-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
+template<class R, class T, class A1, class A2> _mfi::mf2<R, T, A1, A2> mem_fn(R (T::*f) (A1, A2))
+{
+    return _mfi::mf2<R, T, A1, A2>(f);
+}

-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
+template<class R, class T, class A1, class A2> _mfi::cmf2<R, T, A1, A2> mem_fn(R (T::*f) (A1, A2) const)
+{
+    return _mfi::cmf2<R, T, A1, A2>(f);
+}

-#define BOOST_MEM_FN_NAME(X) X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
+template<class R, class T, class A1, class A2, class A3> _mfi::mf3<R, T, A1, A2, A3> mem_fn(R (T::*f) (A1, A2, A3))
+{
+    return _mfi::mf3<R, T, A1, A2, A3>(f);
+}

-#include <boost/bind/mem_fn_template.hpp>
+template<class R, class T, class A1, class A2, class A3> _mfi::cmf3<R, T, A1, A2, A3> mem_fn(R (T::*f) (A1, A2, A3) const)
+{
+    return _mfi::cmf3<R, T, A1, A2, A3>(f);
+}

-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
+template<class R, class T, class A1, class A2, class A3, class A4> _mfi::mf4<R, T, A1, A2, A3, A4> mem_fn(R (T::*f) (A1, A2, A3, A4))
+{
+    return _mfi::mf4<R, T, A1, A2, A3, A4>(f);
+}

-#endif
+template<class R, class T, class A1, class A2, class A3, class A4> _mfi::cmf4<R, T, A1, A2, A3, A4> mem_fn(R (T::*f) (A1, A2, A3, A4) const)
+{
+    return _mfi::cmf4<R, T, A1, A2, A3, A4>(f);
+}

-#undef BOOST_MEM_FN_RETURN
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::mf5<R, T, A1, A2, A3, A4, A5> mem_fn(R (T::*f) (A1, A2, A3, A4, A5))
+{
+    return _mfi::mf5<R, T, A1, A2, A3, A4, A5>(f);
+}

-} // namespace _mfi
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::cmf5<R, T, A1, A2, A3, A4, A5> mem_fn(R (T::*f) (A1, A2, A3, A4, A5) const)
+{
+    return _mfi::cmf5<R, T, A1, A2, A3, A4, A5>(f);
+}

-#undef BOOST_MEM_FN_CLASS_F
-#undef BOOST_MEM_FN_TYPEDEF
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R (T::*f) (A1, A2, A3, A4, A5, A6))
+{
+    return _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6>(f);
+}

-#endif // #ifdef BOOST_NO_VOID_RETURNS
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R (T::*f) (A1, A2, A3, A4, A5, A6) const)
+{
+    return _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6>(f);
+}

-#define BOOST_MEM_FN_NAME(X) X
-#define BOOST_MEM_FN_CC
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R (T::*f) (A1, A2, A3, A4, A5, A6, A7))
+{
+    return _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
+}

-#include <boost/bind/mem_fn_cc.hpp>
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R (T::*f) (A1, A2, A3, A4, A5, A6, A7) const)
+{
+    return _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
+}

-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_CC
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R (T::*f) (A1, A2, A3, A4, A5, A6, A7, A8))
+{
+    return _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
+}

-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
-
-#define BOOST_MEM_FN_NAME(X) X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
-
-#include <boost/bind/mem_fn_cc.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_CC
-
-#endif
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R (T::*f) (A1, A2, A3, A4, A5, A6, A7, A8) const)
+{
+    return _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
+}

 } // namespace boost

--- a/mem_fn.html
+++ b/mem_fn.html
@@ -7,15 +7,18 @@
 	<title>Boost: mem_fn.hpp documentation</title>
 </head>

-<body bgcolor="White" style="margin-left: 5%; margin-right: 5%;">
+<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">
+		<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" WIDTH="277" HEIGHT="86">
 	</td>
 	<td align="center">
-		<h1>mem_fn.hpp</h1>
+		<table border="0">
+			<tr><td nowrap><h1>mem_fn.hpp</h1></td></tr>
+			<tr><td align="right" nowrap><small>&nbsp;1.02.0001 (2001-08-30)</small></td></tr>
+		</table>
 	</td>
 </tr>
 <tr>
@@ -23,29 +26,13 @@
 </tr>
 </table>

-<h2>Contents</h2>
+<h2>Files</h2>
+<ul>
+<li><a href="../../boost/mem_fn.hpp">mem_fn.hpp</a> (implementation)
+<li><a href="mem_fn_test.cpp">mem_fn_test.cpp</a> (test)
+</ul>

-<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">&quot;__stdcall&quot; Support</a></h4>
-<h3 style="margin-left: 20pt;"><a href="#Acknowledgements">Acknowledgements</a></h3>
-
-<h2><a name="Purpose">Purpose</a></h2>
+<h2>Purpose</h2>

 <p>
 <b>boost::mem_fn</b> is a generalization of the standard functions
@@ -55,55 +42,6 @@ object can take a pointer, a reference, or a smart pointer to an object
 instance as its first argument.
 </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 function, and
 returns a function object suitable for use with standard or user-defined
@@ -168,52 +106,9 @@ 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.
 </p>

-<h2><a name="FAQ">Frequently Asked Questions</a></h2>
+<h2>Interface</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>
+<h3>Synopsis</h3>

 <pre>
 namespace boost
@@ -240,7 +135,7 @@ template&lt;class R, class T, class A1, class A2&gt; <i>implementation-defined-6
 }
 </pre>

-<h3><a name="CommonRequirements">Common requirements</a></h3>
+<h3>Common requirements</h3>

 <p>
 All <tt><i>implementation-defined-N</i></tt> types mentioned in the Synopsis are
@@ -251,7 +146,7 @@ the return type of the member function pointer passed as an argument to <b>mem_f
 (<b>R</b> in the Synopsis.)
 </p>

-<h3><a name="get_pointer">get_pointer</a></h3>
+<h3>get_pointer</h3>

 <h4><a name="get_pointer_1">template&lt;class T&gt; T * get_pointer(T * p)</a></h4>

@@ -271,7 +166,7 @@ the return type of the member function pointer passed as an argument to <b>mem_f
 <b>Throws:</b> Nothing.
 </p>

-<h3><a name="mem_fn">mem_fn</a></h3>
+<h3>mem_fn</h3>

 <h4><a name="mem_fn_1">template&lt;class R, class T&gt; <i>implementation-defined-1</i> mem_fn(R (T::*pmf) ())</a></h4>

@@ -339,25 +234,7 @@ is of type <b>T <i>[</i>const<i>]</i></b>, <tt>(get_pointer(t)->*pmf)(a1, a2)</t
 <b>Throws:</b> Nothing.
 </p>

-<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="mem_fn_test.cpp">libs/bind/mem_fn_test.cpp</a> (test)
-<li><a href="mem_fn_stdcall_test.cpp">libs/bind/mem_fn_stdcall_test.cpp</a> (test for __stdcall)
-<li><a href="mem_fn_void_test.cpp">libs/bind/mem_fn_void_test.cpp</a> (test for void returns)
-</ul>
-
-<h3><a name="Dependencies">Dependencies</a></h3>
-<ul>
-<li><a href="../config/config.htm">Boost.Config</a>
-</ul>
-
-<h3><a name="NumberOfArguments">Number of Arguments</a></h3>
+<h2>Implementation</h2>

 <p>
 This implementation supports member functions with up to eight arguments.
@@ -365,36 +242,7 @@ This is not an inherent limitation of the design, but an implementation
 detail.
 </p>

-<h3><a name="stdcall">&quot;__stdcall&quot; 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>.
-</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>
-[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>
+<h2>Acknowledgements</h2>

 <p>
 Rene Jager's initial suggestion of using traits classes to make
@@ -408,14 +256,6 @@ 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 &copy; 2001 by Peter Dimov and Multi Media
 Ltd. Permission to copy, use, modify, sell and distribute this document is
--- a/mem_fn_derived_test.cpp
+++ b/mem_fn_derived_test.cpp
@@ -1,187 +0,0 @@
-#if defined(_MSC_VER) && !defined(__ICL)
-#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_derived_test.cpp - tests mem_fn.hpp with derived objects
-//
-//  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.
-//
-
-#include <boost/mem_fn.hpp>
-#include <boost/shared_ptr.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
-
-
-struct B
-{
-    mutable unsigned int hash;
-
-    B(): hash(0) {}
-
-    int f0() { f1(17); return 0; }
-    int g0() const { g1(17); return 0; }
-
-    int f1(int a1) { hash = (hash * 17041 + a1) % 32768; return 0; }
-    int g1(int a1) const { hash = (hash * 17041 + a1 * 2) % 32768; return 0; }
-
-    int f2(int a1, int a2) { f1(a1); f1(a2); return 0; }
-    int g2(int a1, int a2) const { g1(a1); g1(a2); return 0; }
-
-    int f3(int a1, int a2, int a3) { f2(a1, a2); f1(a3); return 0; }
-    int g3(int a1, int a2, int a3) const { g2(a1, a2); g1(a3); return 0; }
-
-    int f4(int a1, int a2, int a3, int a4) { f3(a1, a2, a3); f1(a4); return 0; }
-    int g4(int a1, int a2, int a3, int a4) const { g3(a1, a2, a3); g1(a4); return 0; }
-
-    int f5(int a1, int a2, int a3, int a4, int a5) { f4(a1, a2, a3, a4); f1(a5); return 0; }
-    int g5(int a1, int a2, int a3, int a4, int a5) const { g4(a1, a2, a3, a4); g1(a5); return 0; }
-
-    int f6(int a1, int a2, int a3, int a4, int a5, int a6) { f5(a1, a2, a3, a4, a5); f1(a6); return 0; }
-    int g6(int a1, int a2, int a3, int a4, int a5, int a6) const { g5(a1, a2, a3, a4, a5); g1(a6); return 0; }
-
-    int f7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) { f6(a1, a2, a3, a4, a5, a6); f1(a7); return 0; }
-    int g7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) const { g6(a1, a2, a3, a4, a5, a6); g1(a7); return 0; }
-
-    int f8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) { f7(a1, a2, a3, a4, a5, a6, a7); f1(a8); return 0; }
-    int g8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) const { g7(a1, a2, a3, a4, a5, a6, a7); g1(a8); return 0; }
-};
-
-struct X: public B
-{
-};
-
-int detect_errors(bool x)
-{
-    if(x)
-    {
-        std::cerr << "no errors detected.\n";
-        return 0;
-    }
-    else
-    {
-        std::cerr << "test failed.\n";
-        return 1;
-    }
-}
-
-int main()
-{
-    using boost::mem_fn;
-
-    X x;
-
-    X const & rcx = x;
-    X const * pcx = &x;
-
-    boost::shared_ptr<X> sp(new X);
-
-    mem_fn(&X::f0)(x);
-    mem_fn(&X::f0)(&x);
-    mem_fn(&X::f0)(sp);
-
-    mem_fn(&X::g0)(x);
-    mem_fn(&X::g0)(rcx);
-    mem_fn(&X::g0)(&x);
-    mem_fn(&X::g0)(pcx);
-    mem_fn(&X::g0)(sp);
-
-    mem_fn(&X::f1)(x, 1);
-    mem_fn(&X::f1)(&x, 1);
-    mem_fn(&X::f1)(sp, 1);
-
-    mem_fn(&X::g1)(x, 1);
-    mem_fn(&X::g1)(rcx, 1);
-    mem_fn(&X::g1)(&x, 1);
-    mem_fn(&X::g1)(pcx, 1);
-    mem_fn(&X::g1)(sp, 1);
-
-    mem_fn(&X::f2)(x, 1, 2);
-    mem_fn(&X::f2)(&x, 1, 2);
-    mem_fn(&X::f2)(sp, 1, 2);
-
-    mem_fn(&X::g2)(x, 1, 2);
-    mem_fn(&X::g2)(rcx, 1, 2);
-    mem_fn(&X::g2)(&x, 1, 2);
-    mem_fn(&X::g2)(pcx, 1, 2);
-    mem_fn(&X::g2)(sp, 1, 2);
-
-    mem_fn(&X::f3)(x, 1, 2, 3);
-    mem_fn(&X::f3)(&x, 1, 2, 3);
-    mem_fn(&X::f3)(sp, 1, 2, 3);
-
-    mem_fn(&X::g3)(x, 1, 2, 3);
-    mem_fn(&X::g3)(rcx, 1, 2, 3);
-    mem_fn(&X::g3)(&x, 1, 2, 3);
-    mem_fn(&X::g3)(pcx, 1, 2, 3);
-    mem_fn(&X::g3)(sp, 1, 2, 3);
-
-    mem_fn(&X::f4)(x, 1, 2, 3, 4);
-    mem_fn(&X::f4)(&x, 1, 2, 3, 4);
-    mem_fn(&X::f4)(sp, 1, 2, 3, 4);
-
-    mem_fn(&X::g4)(x, 1, 2, 3, 4);
-    mem_fn(&X::g4)(rcx, 1, 2, 3, 4);
-    mem_fn(&X::g4)(&x, 1, 2, 3, 4);
-    mem_fn(&X::g4)(pcx, 1, 2, 3, 4);
-    mem_fn(&X::g4)(sp, 1, 2, 3, 4);
-
-    mem_fn(&X::f5)(x, 1, 2, 3, 4, 5);
-    mem_fn(&X::f5)(&x, 1, 2, 3, 4, 5);
-    mem_fn(&X::f5)(sp, 1, 2, 3, 4, 5);
-
-    mem_fn(&X::g5)(x, 1, 2, 3, 4, 5);
-    mem_fn(&X::g5)(rcx, 1, 2, 3, 4, 5);
-    mem_fn(&X::g5)(&x, 1, 2, 3, 4, 5);
-    mem_fn(&X::g5)(pcx, 1, 2, 3, 4, 5);
-    mem_fn(&X::g5)(sp, 1, 2, 3, 4, 5);
-
-    mem_fn(&X::f6)(x, 1, 2, 3, 4, 5, 6);
-    mem_fn(&X::f6)(&x, 1, 2, 3, 4, 5, 6);
-    mem_fn(&X::f6)(sp, 1, 2, 3, 4, 5, 6);
-
-    mem_fn(&X::g6)(x, 1, 2, 3, 4, 5, 6);
-    mem_fn(&X::g6)(rcx, 1, 2, 3, 4, 5, 6);
-    mem_fn(&X::g6)(&x, 1, 2, 3, 4, 5, 6);
-    mem_fn(&X::g6)(pcx, 1, 2, 3, 4, 5, 6);
-    mem_fn(&X::g6)(sp, 1, 2, 3, 4, 5, 6);
-
-    mem_fn(&X::f7)(x, 1, 2, 3, 4, 5, 6, 7);
-    mem_fn(&X::f7)(&x, 1, 2, 3, 4, 5, 6, 7);
-    mem_fn(&X::f7)(sp, 1, 2, 3, 4, 5, 6, 7);
-
-    mem_fn(&X::g7)(x, 1, 2, 3, 4, 5, 6, 7);
-    mem_fn(&X::g7)(rcx, 1, 2, 3, 4, 5, 6, 7);
-    mem_fn(&X::g7)(&x, 1, 2, 3, 4, 5, 6, 7);
-    mem_fn(&X::g7)(pcx, 1, 2, 3, 4, 5, 6, 7);
-    mem_fn(&X::g7)(sp, 1, 2, 3, 4, 5, 6, 7);
-
-    mem_fn(&X::f8)(x, 1, 2, 3, 4, 5, 6, 7, 8);
-    mem_fn(&X::f8)(&x, 1, 2, 3, 4, 5, 6, 7, 8);
-    mem_fn(&X::f8)(sp, 1, 2, 3, 4, 5, 6, 7, 8);
-
-    mem_fn(&X::g8)(x, 1, 2, 3, 4, 5, 6, 7, 8);
-    mem_fn(&X::g8)(rcx, 1, 2, 3, 4, 5, 6, 7, 8);
-    mem_fn(&X::g8)(&x, 1, 2, 3, 4, 5, 6, 7, 8);
-    mem_fn(&X::g8)(pcx, 1, 2, 3, 4, 5, 6, 7, 8);
-    mem_fn(&X::g8)(sp, 1, 2, 3, 4, 5, 6, 7, 8);
-
-    return detect_errors(x.hash == 17610 && sp->hash == 2155);
-}
--- a/mem_fn_stdcall_test.cpp
+++ b/mem_fn_stdcall_test.cpp
@@ -1,185 +0,0 @@
-#if defined(_MSC_VER) && !defined(__ICL)
-#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_stdcall_test.cpp - a test for mem_fn.hpp + __stdcall
-//
-//  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.
-//
-
-#define BOOST_MEM_FN_ENABLE_STDCALL
-
-#include <boost/mem_fn.hpp>
-#include <boost/shared_ptr.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
-
-
-struct X
-{
-    mutable unsigned int hash;
-
-    X(): hash(0) {}
-
-    int __stdcall f0() { f1(17); return 0; }
-    int __stdcall g0() const { g1(17); return 0; }
-
-    int __stdcall f1(int a1) { hash = (hash * 17041 + a1) % 32768; return 0; }
-    int __stdcall g1(int a1) const { hash = (hash * 17041 + a1 * 2) % 32768; return 0; }
-
-    int __stdcall f2(int a1, int a2) { f1(a1); f1(a2); return 0; }
-    int __stdcall g2(int a1, int a2) const { g1(a1); g1(a2); return 0; }
-
-    int __stdcall f3(int a1, int a2, int a3) { f2(a1, a2); f1(a3); return 0; }
-    int __stdcall g3(int a1, int a2, int a3) const { g2(a1, a2); g1(a3); return 0; }
-
-    int __stdcall f4(int a1, int a2, int a3, int a4) { f3(a1, a2, a3); f1(a4); return 0; }
-    int __stdcall g4(int a1, int a2, int a3, int a4) const { g3(a1, a2, a3); g1(a4); return 0; }
-
-    int __stdcall f5(int a1, int a2, int a3, int a4, int a5) { f4(a1, a2, a3, a4); f1(a5); return 0; }
-    int __stdcall g5(int a1, int a2, int a3, int a4, int a5) const { g4(a1, a2, a3, a4); g1(a5); return 0; }
-
-    int __stdcall f6(int a1, int a2, int a3, int a4, int a5, int a6) { f5(a1, a2, a3, a4, a5); f1(a6); return 0; }
-    int __stdcall g6(int a1, int a2, int a3, int a4, int a5, int a6) const { g5(a1, a2, a3, a4, a5); g1(a6); return 0; }
-
-    int __stdcall f7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) { f6(a1, a2, a3, a4, a5, a6); f1(a7); return 0; }
-    int __stdcall g7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) const { g6(a1, a2, a3, a4, a5, a6); g1(a7); return 0; }
-
-    int __stdcall f8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) { f7(a1, a2, a3, a4, a5, a6, a7); f1(a8); return 0; }
-    int __stdcall g8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) const { g7(a1, a2, a3, a4, a5, a6, a7); g1(a8); return 0; }
-};
-
-int detect_errors(bool x)
-{
-    if(x)
-    {
-        std::cerr << "no errors detected.\n";
-        return 0;
-    }
-    else
-    {
-        std::cerr << "test failed.\n";
-        return 1;
-    }
-}
-
-int main()
-{
-    using boost::mem_fn;
-
-    X x;
-
-    X const & rcx = x;
-    X const * pcx = &x;
-
-    boost::shared_ptr<X> sp(new X);
-
-    mem_fn(&X::f0)(x);
-    mem_fn(&X::f0)(&x);
-    mem_fn(&X::f0)(sp);
-
-    mem_fn(&X::g0)(x);
-    mem_fn(&X::g0)(rcx);
-    mem_fn(&X::g0)(&x);
-    mem_fn(&X::g0)(pcx);
-    mem_fn(&X::g0)(sp);
-
-    mem_fn(&X::f1)(x, 1);
-    mem_fn(&X::f1)(&x, 1);
-    mem_fn(&X::f1)(sp, 1);
-
-    mem_fn(&X::g1)(x, 1);
-    mem_fn(&X::g1)(rcx, 1);
-    mem_fn(&X::g1)(&x, 1);
-    mem_fn(&X::g1)(pcx, 1);
-    mem_fn(&X::g1)(sp, 1);
-
-    mem_fn(&X::f2)(x, 1, 2);
-    mem_fn(&X::f2)(&x, 1, 2);
-    mem_fn(&X::f2)(sp, 1, 2);
-
-    mem_fn(&X::g2)(x, 1, 2);
-    mem_fn(&X::g2)(rcx, 1, 2);
-    mem_fn(&X::g2)(&x, 1, 2);
-    mem_fn(&X::g2)(pcx, 1, 2);
-    mem_fn(&X::g2)(sp, 1, 2);
-
-    mem_fn(&X::f3)(x, 1, 2, 3);
-    mem_fn(&X::f3)(&x, 1, 2, 3);
-    mem_fn(&X::f3)(sp, 1, 2, 3);
-
-    mem_fn(&X::g3)(x, 1, 2, 3);
-    mem_fn(&X::g3)(rcx, 1, 2, 3);
-    mem_fn(&X::g3)(&x, 1, 2, 3);
-    mem_fn(&X::g3)(pcx, 1, 2, 3);
-    mem_fn(&X::g3)(sp, 1, 2, 3);
-
-    mem_fn(&X::f4)(x, 1, 2, 3, 4);
-    mem_fn(&X::f4)(&x, 1, 2, 3, 4);
-    mem_fn(&X::f4)(sp, 1, 2, 3, 4);
-
-    mem_fn(&X::g4)(x, 1, 2, 3, 4);
-    mem_fn(&X::g4)(rcx, 1, 2, 3, 4);
-    mem_fn(&X::g4)(&x, 1, 2, 3, 4);
-    mem_fn(&X::g4)(pcx, 1, 2, 3, 4);
-    mem_fn(&X::g4)(sp, 1, 2, 3, 4);
-
-    mem_fn(&X::f5)(x, 1, 2, 3, 4, 5);
-    mem_fn(&X::f5)(&x, 1, 2, 3, 4, 5);
-    mem_fn(&X::f5)(sp, 1, 2, 3, 4, 5);
-
-    mem_fn(&X::g5)(x, 1, 2, 3, 4, 5);
-    mem_fn(&X::g5)(rcx, 1, 2, 3, 4, 5);
-    mem_fn(&X::g5)(&x, 1, 2, 3, 4, 5);
-    mem_fn(&X::g5)(pcx, 1, 2, 3, 4, 5);
-    mem_fn(&X::g5)(sp, 1, 2, 3, 4, 5);
-
-    mem_fn(&X::f6)(x, 1, 2, 3, 4, 5, 6);
-    mem_fn(&X::f6)(&x, 1, 2, 3, 4, 5, 6);
-    mem_fn(&X::f6)(sp, 1, 2, 3, 4, 5, 6);
-
-    mem_fn(&X::g6)(x, 1, 2, 3, 4, 5, 6);
-    mem_fn(&X::g6)(rcx, 1, 2, 3, 4, 5, 6);
-    mem_fn(&X::g6)(&x, 1, 2, 3, 4, 5, 6);
-    mem_fn(&X::g6)(pcx, 1, 2, 3, 4, 5, 6);
-    mem_fn(&X::g6)(sp, 1, 2, 3, 4, 5, 6);
-
-    mem_fn(&X::f7)(x, 1, 2, 3, 4, 5, 6, 7);
-    mem_fn(&X::f7)(&x, 1, 2, 3, 4, 5, 6, 7);
-    mem_fn(&X::f7)(sp, 1, 2, 3, 4, 5, 6, 7);
-
-    mem_fn(&X::g7)(x, 1, 2, 3, 4, 5, 6, 7);
-    mem_fn(&X::g7)(rcx, 1, 2, 3, 4, 5, 6, 7);
-    mem_fn(&X::g7)(&x, 1, 2, 3, 4, 5, 6, 7);
-    mem_fn(&X::g7)(pcx, 1, 2, 3, 4, 5, 6, 7);
-    mem_fn(&X::g7)(sp, 1, 2, 3, 4, 5, 6, 7);
-
-    mem_fn(&X::f8)(x, 1, 2, 3, 4, 5, 6, 7, 8);
-    mem_fn(&X::f8)(&x, 1, 2, 3, 4, 5, 6, 7, 8);
-    mem_fn(&X::f8)(sp, 1, 2, 3, 4, 5, 6, 7, 8);
-
-    mem_fn(&X::g8)(x, 1, 2, 3, 4, 5, 6, 7, 8);
-    mem_fn(&X::g8)(rcx, 1, 2, 3, 4, 5, 6, 7, 8);
-    mem_fn(&X::g8)(&x, 1, 2, 3, 4, 5, 6, 7, 8);
-    mem_fn(&X::g8)(pcx, 1, 2, 3, 4, 5, 6, 7, 8);
-    mem_fn(&X::g8)(sp, 1, 2, 3, 4, 5, 6, 7, 8);
-
-    return detect_errors(x.hash == 17610 && sp->hash == 2155);
-}
--- a/mem_fn_test.cpp
+++ b/mem_fn_test.cpp
@@ -8,6 +8,8 @@
 //
 //  mem_fn_test.cpp - a test for mem_fn.hpp
 //
+//  Version 1.02.0001 (2001-08-30)
+//
 //  Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
 //
 //  Permission to copy, use, modify, sell and distribute this software
@@ -17,19 +19,9 @@
 //

 #include <boost/mem_fn.hpp>
-#include <boost/shared_ptr.hpp>
-
-#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
-#pragma warning(push, 3)
-#endif
-
+#include <boost/smart_ptr.hpp>
 #include <iostream>

-#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
-#pragma warning(pop)
-#endif
-
-
 struct X
 {
    mutable unsigned int hash;
--- a/mem_fn_void_test.cpp
+++ b/mem_fn_void_test.cpp
@@ -1,183 +0,0 @@
-#if defined(_MSC_VER) && !defined(__ICL)
-#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_void_test.cpp - a test for mem_fn.hpp + void returns
-//
-//  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.
-//
-
-#include <boost/mem_fn.hpp>
-#include <boost/shared_ptr.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
-
-
-struct X
-{
-    mutable unsigned int hash;
-
-    X(): hash(0) {}
-
-    void f0() { f1(17); }
-    void g0() const { g1(17); }
-
-    void f1(int a1) { hash = (hash * 17041 + a1) % 32768; }
-    void g1(int a1) const { hash = (hash * 17041 + a1 * 2) % 32768; }
-
-    void f2(int a1, int a2) { f1(a1); f1(a2); }
-    void g2(int a1, int a2) const { g1(a1); g1(a2); }
-
-    void f3(int a1, int a2, int a3) { f2(a1, a2); f1(a3); }
-    void g3(int a1, int a2, int a3) const { g2(a1, a2); g1(a3); }
-
-    void f4(int a1, int a2, int a3, int a4) { f3(a1, a2, a3); f1(a4); }
-    void g4(int a1, int a2, int a3, int a4) const { g3(a1, a2, a3); g1(a4); }
-
-    void f5(int a1, int a2, int a3, int a4, int a5) { f4(a1, a2, a3, a4); f1(a5); }
-    void g5(int a1, int a2, int a3, int a4, int a5) const { g4(a1, a2, a3, a4); g1(a5); }
-
-    void f6(int a1, int a2, int a3, int a4, int a5, int a6) { f5(a1, a2, a3, a4, a5); f1(a6); }
-    void g6(int a1, int a2, int a3, int a4, int a5, int a6) const { g5(a1, a2, a3, a4, a5); g1(a6); }
-
-    void f7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) { f6(a1, a2, a3, a4, a5, a6); f1(a7); }
-    void g7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) const { g6(a1, a2, a3, a4, a5, a6); g1(a7); }
-
-    void f8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) { f7(a1, a2, a3, a4, a5, a6, a7); f1(a8); }
-    void g8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) const { g7(a1, a2, a3, a4, a5, a6, a7); g1(a8); }
-};
-
-int detect_errors(bool x)
-{
-    if(x)
-    {
-        std::cerr << "no errors detected.\n";
-        return 0;
-    }
-    else
-    {
-        std::cerr << "test failed.\n";
-        return 1;
-    }
-}
-
-int main()
-{
-    using boost::mem_fn;
-
-    X x;
-
-    X const & rcx = x;
-    X const * pcx = &x;
-
-    boost::shared_ptr<X> sp(new X);
-
-    mem_fn(&X::f0)(x);
-    mem_fn(&X::f0)(&x);
-    mem_fn(&X::f0)(sp);
-
-    mem_fn(&X::g0)(x);
-    mem_fn(&X::g0)(rcx);
-    mem_fn(&X::g0)(&x);
-    mem_fn(&X::g0)(pcx);
-    mem_fn(&X::g0)(sp);
-
-    mem_fn(&X::f1)(x, 1);
-    mem_fn(&X::f1)(&x, 1);
-    mem_fn(&X::f1)(sp, 1);
-
-    mem_fn(&X::g1)(x, 1);
-    mem_fn(&X::g1)(rcx, 1);
-    mem_fn(&X::g1)(&x, 1);
-    mem_fn(&X::g1)(pcx, 1);
-    mem_fn(&X::g1)(sp, 1);
-
-    mem_fn(&X::f2)(x, 1, 2);
-    mem_fn(&X::f2)(&x, 1, 2);
-    mem_fn(&X::f2)(sp, 1, 2);
-
-    mem_fn(&X::g2)(x, 1, 2);
-    mem_fn(&X::g2)(rcx, 1, 2);
-    mem_fn(&X::g2)(&x, 1, 2);
-    mem_fn(&X::g2)(pcx, 1, 2);
-    mem_fn(&X::g2)(sp, 1, 2);
-
-    mem_fn(&X::f3)(x, 1, 2, 3);
-    mem_fn(&X::f3)(&x, 1, 2, 3);
-    mem_fn(&X::f3)(sp, 1, 2, 3);
-
-    mem_fn(&X::g3)(x, 1, 2, 3);
-    mem_fn(&X::g3)(rcx, 1, 2, 3);
-    mem_fn(&X::g3)(&x, 1, 2, 3);
-    mem_fn(&X::g3)(pcx, 1, 2, 3);
-    mem_fn(&X::g3)(sp, 1, 2, 3);
-
-    mem_fn(&X::f4)(x, 1, 2, 3, 4);
-    mem_fn(&X::f4)(&x, 1, 2, 3, 4);
-    mem_fn(&X::f4)(sp, 1, 2, 3, 4);
-
-    mem_fn(&X::g4)(x, 1, 2, 3, 4);
-    mem_fn(&X::g4)(rcx, 1, 2, 3, 4);
-    mem_fn(&X::g4)(&x, 1, 2, 3, 4);
-    mem_fn(&X::g4)(pcx, 1, 2, 3, 4);
-    mem_fn(&X::g4)(sp, 1, 2, 3, 4);
-
-    mem_fn(&X::f5)(x, 1, 2, 3, 4, 5);
-    mem_fn(&X::f5)(&x, 1, 2, 3, 4, 5);
-    mem_fn(&X::f5)(sp, 1, 2, 3, 4, 5);
-
-    mem_fn(&X::g5)(x, 1, 2, 3, 4, 5);
-    mem_fn(&X::g5)(rcx, 1, 2, 3, 4, 5);
-    mem_fn(&X::g5)(&x, 1, 2, 3, 4, 5);
-    mem_fn(&X::g5)(pcx, 1, 2, 3, 4, 5);
-    mem_fn(&X::g5)(sp, 1, 2, 3, 4, 5);
-
-    mem_fn(&X::f6)(x, 1, 2, 3, 4, 5, 6);
-    mem_fn(&X::f6)(&x, 1, 2, 3, 4, 5, 6);
-    mem_fn(&X::f6)(sp, 1, 2, 3, 4, 5, 6);
-
-    mem_fn(&X::g6)(x, 1, 2, 3, 4, 5, 6);
-    mem_fn(&X::g6)(rcx, 1, 2, 3, 4, 5, 6);
-    mem_fn(&X::g6)(&x, 1, 2, 3, 4, 5, 6);
-    mem_fn(&X::g6)(pcx, 1, 2, 3, 4, 5, 6);
-    mem_fn(&X::g6)(sp, 1, 2, 3, 4, 5, 6);
-
-    mem_fn(&X::f7)(x, 1, 2, 3, 4, 5, 6, 7);
-    mem_fn(&X::f7)(&x, 1, 2, 3, 4, 5, 6, 7);
-    mem_fn(&X::f7)(sp, 1, 2, 3, 4, 5, 6, 7);
-
-    mem_fn(&X::g7)(x, 1, 2, 3, 4, 5, 6, 7);
-    mem_fn(&X::g7)(rcx, 1, 2, 3, 4, 5, 6, 7);
-    mem_fn(&X::g7)(&x, 1, 2, 3, 4, 5, 6, 7);
-    mem_fn(&X::g7)(pcx, 1, 2, 3, 4, 5, 6, 7);
-    mem_fn(&X::g7)(sp, 1, 2, 3, 4, 5, 6, 7);
-
-    mem_fn(&X::f8)(x, 1, 2, 3, 4, 5, 6, 7, 8);
-    mem_fn(&X::f8)(&x, 1, 2, 3, 4, 5, 6, 7, 8);
-    mem_fn(&X::f8)(sp, 1, 2, 3, 4, 5, 6, 7, 8);
-
-    mem_fn(&X::g8)(x, 1, 2, 3, 4, 5, 6, 7, 8);
-    mem_fn(&X::g8)(rcx, 1, 2, 3, 4, 5, 6, 7, 8);
-    mem_fn(&X::g8)(&x, 1, 2, 3, 4, 5, 6, 7, 8);
-    mem_fn(&X::g8)(pcx, 1, 2, 3, 4, 5, 6, 7, 8);
-    mem_fn(&X::g8)(sp, 1, 2, 3, 4, 5, 6, 7, 8);
-
-    return detect_errors(x.hash == 17610 && sp->hash == 2155);
-}
--- a/ref.html
+++ b/ref.html
@@ -17,7 +17,7 @@
 	<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>
+			<tr><td align="right" nowrap><small>&nbsp;1.00.0003 (2001-08-22)</small></td></tr>
 		</table>
 	</td>
 </tr>
@@ -35,9 +35,8 @@

 <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>.
+<b>boost::reference_wrapper&lt;T&gt;</b> and the two functions <b>boost::ref</b> and
+<b>boost::cref</b> that return instances of <b>boost::reference_wrapper&lt;T&gt;</b>.
 </p>

 <p>
@@ -53,8 +52,8 @@ 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>).
+<b>boost::reference_wrapper&lt;T&gt;</b> is <b>CopyConstructible</b>, but it is not
+<b>Assignable</b>.
 </p>

 <p>
@@ -63,14 +62,6 @@ 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>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.
-
 <h2>Interface</h2>

 <h3>Synopsis</h3>
@@ -81,8 +72,6 @@ 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>

@@ -92,7 +81,6 @@ namespace boost
 template&lt;class T&gt; class reference_wrapper
 {
 public:
-    typedef T type;

    explicit <a href="#rt_construct">reference_wrapper</a>(T &amp; t);

@@ -104,36 +92,30 @@ public:

 <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>

 <h3><a name="ref">ref</a></h3>

@@ -141,14 +123,12 @@ public:
 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>

@@ -156,47 +136,19 @@ template&lt;class T&gt; reference_wrapper&lt;T&gt; ref(T &amp; t);
 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>.
+<b>ref</b> and <b>cref</b> were originally part of the Boost.Tuple library.
+They were "promoted to <b>boost::</b> status" because they are generally
+useful.
 </p>