This commit was manufactured by cvs2svn to create branch

'thread_rewrite'. [SVN r30953]
Large patch from Ulrich Eckhardt to fix support for EVC++ 4.
2005-09-13 14:20:32 +00:00 · 2005-08-25 16:27:28 +00:00 · 2005-08-24 14:12:03 +00:00 · 2005-08-22 12:55:34 +00:00 · 2005-08-12 13:02:37 +00:00 · 2005-05-10 13:30:35 +00:00
36 changed files with 1377 additions and 3741 deletions
--- a/doc/faq.html
+++ b/doc/faq.html
@ -1,44 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-  <head>
-    <title>Boost.Function Frequently Asked Questions</title>
-  </head>
-
-  <body bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080">
-<h1><IMG SRC="../../../c++boost.gif" WIDTH="276" HEIGHT="86">boost::function Frequently Asked Questions</h1>
-
-<h2>Q: I see void pointers; is this [mess] type safe?</h2>
-<p>Yes, <code>boost::function</code> is type safe even though it uses void pointers and pointers to functions returning void and taking no arguments. Essentially, all type information is encoded in the functions that manage and invoke function pointers and function objects. Only these functions are instantiated with the exact type that is pointed to by the void pointer or pointer to void function. The reason that both are required is that one may cast between void pointers and object pointers safely or between different types of function pointers (provided you don't invoke a function pointer with the wrong type). 
-
-<h2>Q: Why are there workarounds for void returns? C++ allows them!</h2>
-<p>Void returns are permitted by the C++ standard, as in this code snippet:
-<pre>
-void f();
-void g() { return f(); }
-</pre>
-
-<p> One reason for not using void returns is that not all compilers support them. In fact, very few compilers seem to support this trivial feature. Additionally, <code>boost::function</code> is more flexible because it does not use void returns. Consider the following code:
-<pre>
-int do_something(int);
-
-boost::function<void, int> f;
-f = do_something;
-</pre>
-<p> This is a valid usage of <code>boost::function</code> because void returns are not used. With void returns, we would attempting to compile ill-formed code similar to:
-<pre>
-int f();
-void g() { return f(); }
-</pre>
-<p> In essence, not using void returns allows <code>boost::function</code> to swallow a return value. This is consistent with allowing the user to assign and invoke functions and function objects with parameters that don't exactly match.
-
-<h2>Q: Why (function) cloning? </h2>
-<p> In November and December of 2000, the issue of cloning vs. reference counting was debated at length and it was decided that cloning gave more predictable semantics. I won't rehash the discussion here, but if it cloning is incorrect for a particular application a reference-counting allocator could be used. 
-
-    <hr>
-    <address><a href="mailto:gregod@cs.rpi.edu">Doug Gregor</a></address>
-<!-- Created: Fri Feb 16 09:30:41 EST 2001 -->
-<!-- hhmts start -->
-Last modified: Wed Nov  7 15:11:52 EST 2001
-<!-- hhmts end -->
-  </body>
-</html>
--- a/doc/reference.html
+++ b/doc/reference.html
@ -1,299 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-  <head>
-    <title>Boost.Function Reference Manual</title>
-  </head>
-
-  <body bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080">
-
-  <h1><IMG SRC="../../../c++boost.gif" WIDTH="276" HEIGHT="86">Boost.Function Reference Manual</h1>
-
-<h2><a name="header">Header <code>&lt;<a href="../../../boost/function.hpp">boost/function.hpp</a>&gt;</code> synopsis</a></h2>
-<p> Here <code><i>MAX_ARGS</i></code> is an implementation-defined constant that defines the maximum number of function arguments supported by Boost.Function and will be at least 10. The <code><i>MAX_ARGS</i></code> constant referred to in this document need not have any direct representation in the library.
-
-<pre>
-<b>namespace</b> boost {
-  <b>class</b> <a href="#function_base">function_base</a>
-  {
-    <b>typedef</b> <em>implementation-defined</em> safe_bool;
-    <a href="#empty"><b>bool</b> empty() <b>const</b></a>;
-    <a href="#bool"><b>operator</b> safe_bool() <b>const</b></a>;
-    <a href="#not">safe_bool <b>operator!</b>() <b>const</b></a>;
-  };
-
-  // For <i>N</i> in [0, <i>MAX_ARGS</i>]
-  <b>template</b>&lt;<b>typename</b> ResultType,
-           <b>typename</b> Arg1,
-	   <b>typename</b> Arg2,
-           <i>...</i>
-           <b>typename</b> Arg<i>N</i>,
-	   <b>typename</b> Policy    = empty_function_policy,
-	   <b>typename</b> Mixin     = empty_function_mixin,
-	   <b>typename</b> Allocator = std::allocator&lt;function_base&gt; &gt;
-  <b>class</b> <a href="#functionN">function<i>N</i></a> : <b>public</b> <a href="#function_base">function_base</a>, <b>public</b> Mixin
-  {
-    <b>typedef</b> ResultType result_type; <em>// <a href="#novoid">[1]</a></em>
-    <b>typedef</b> Policy     policy_type;
-    <b>typedef</b> Mixin      mixin_type;
-    <b>typedef</b> Allocator  allocator_type;
-
-    <b>typedef</b> Arg1 argument_type;        <i>// If N == 1</i>
-
-    <b>typedef</b> Arg1 first_argument_type;  <i>// If N == 2</i>
-    <b>typedef</b> Arg2 second_argument_type; <i>// If N == 2</i>
-
-    <i>// Construction</i>
-    <a href="#functionN_default"><b>explicit</b> function<i>N</i>(<b>const</b> Mixin<b>&amp;</b> = Mixin())</a>;
-    <a href="#functionN_copy">function<i>N</i>(<b>const</b> function<i>N</i><b>&amp;</b>)</a>;
-    <a href="#functionN_target"><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(F, <b>const</b> Mixin<b>&amp;</b> = Mixin())</a>;
-    <a href="#functionN_target_ref"><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(reference_wrapper&lt;F&gt;)</a>;
-    
-    <i>// Assignment</i>
-    <a href="#functionN_copy_assn">function<i>N</i><b>&amp;</b> <b>operator</b>=(<b>const</b> function<i>N</i><b>&amp;</b>)</a>;
-    <a href="#functionN_target_assn"><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i><b>&amp;</b> <b>operator</b>=(F)</a>;
-    <a href="#functionN_target_ref_assn"><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i><b>&amp;</b> <b>operator</b>=(reference_wrapper&lt;F&gt;)</a>;
-    <a href="#functionN_copy_set"><b>void</b> set(<b>const</b> function<i>N</i><b>&amp;</b>)</a>;
-    <a href="#functionN_target_set"><b>template</b>&lt;<b>typename</b> F&gt; <b>void</b> set(F)</a>;
-    <a href="#functionN_swap"><b>void</b> swap(function<i>N</i><b>&amp;</b>)</a>;
-    <a href="#functionN_clear"><b>void</b> clear()</a>;
-
-    <i>// Invocation</i>
-    <a href="#functionN_call_const">result_type <b>operator</b>()(Arg1 a1, Arg2 a2, <i>...</i>, Arg<i>N</i> a<i>N</i>) <b>const</b></a>;
-  };
-
-  <b>template</b>&lt;<b>typename</b> ResultType,
-           <b>typename</b> Arg1,
-	   <b>typename</b> Arg2,
-           <i>...</i>
-	   <b>typename</b> Arg<i>N</i>,
-           <b>typename</b> Policy,
-           <b>typename</b> Mixin,
-           <b>typename</b> Allocator&gt;
-  <b>void</b> <a href="#swap_functionN">swap</a>(function<em>N</em>&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator&gt;<b>&amp;</b>,
-            function<em>N</em>&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator&gt;<b>&amp;</b>);
-
-  // For any <i>N</i> in [0, <i>MAX_ARGS</i>]
-  <b>template</b>&lt;<b>typename</b> ResultType,
-           <b>typename</b> Arg1,
-	   <b>typename</b> Arg2,
-           <i>...</i>
-           <b>typename</b> Arg<i>N</i>,
-           <b>typename</b> Arg<i>N+1</i> = <i>implementation-defined</i>,
-           <b>typename</b> Arg<i>N+2</i> = <i>implementation-defined</i>,
-	   <i>...</i>
-	   <b>typename</b> Arg<i>MAX_ARGS</i> = <i>implementation-defined</i>&gt;
-  <b>class</b> <a href="#function">function</a> : <b>public</b> <a href="#functionN">function<i>N</i></a>&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>&gt;
-  {
-    <i>// Construction</i>
-    function();
-    function(<b>const</b> function<b>&amp;</b>);
-    function(<b>const</b> function<i>N</i>&lt;ResultType, Arg1, Arg2, ..., Arg<i>N</i>&gt;<b>&amp;</b>);
-    <b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(F);
-    
-    <i>// Assignment</i>
-    function<b>&amp;</b> <b>operator</b>=(<b>const</b> function<b>&amp;</b>);
-    function<b>&amp;</b> <b>operator</b>=(<b>const</b> function<i>N</i>&lt;ResultType, Arg1, Arg2, ..., Arg<i>N</i>&gt;<b>&amp;</b>);
-    <b>template</b>&lt;<b>typename</b> F&gt; function<b>&amp;</b> <b>operator</b>=(F);
-    <b>void</b> set(<b>const</b> function<b>&amp;</b>);
-    <b>void</b> set(<b>const</b> function<i>N</i>&lt;ResultType, Arg1, Arg2, ..., Arg<i>N</i>&gt;<b>&amp;</b>);
-    <b>template</b>&lt;<b>typename</b> F&gt; <b>void</b> set(F);
-  };
-
-  <b>template</b>&lt;<b>typename</b> ResultType,
-           <b>typename</b> Arg1,
-	   <b>typename</b> Arg2,
-           <i>...</i>
-	   <b>typename</b> Arg<i>MAX_ARGS</i>&gt;
-  <b>void</b> <a href="#swap_function">swap</a>(function&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>&gt;<b>&amp;</b>,
-            function&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>&gt;<b>&amp;</b>);
-}	   
-</pre>
-
-<h2>Definitions</h2>
-<p>
-<ul>
-  <li><a name="compatible"></a>A function object <code>f</code> is <em>compatible</em> if for the given set of argument types <code>Arg1</code>, <code>Arg2</code>, ..., <code>Arg<em>N</em></code> and a return type <code>ResultType</code>, the appropriate following function is well-formed:
-<pre>
-  <em>// if ResultType is not <b>void</b></em>
-  ResultType foo(Arg1 arg1, Arg2 arg2, ..., Arg<em>N</em> arg<em>N</em>)
-  {
-    <b>return</b> f(arg1, arg2, ..., arg<em>N</em>);
-  }
-
-  <em>// if ResultType is <b>void</b></em>
-  ResultType foo(Arg1 arg1, Arg2 arg2, ..., Arg<em>N</em> arg<em>N</em>)
-  {
-    f(arg1, arg2, ..., arg<em>N</em>);
-  }
-</pre>
-        <p> A special provision is made for pointers to member functions. Though they are not function objects, Boost.Function will adapt them internally to function objects. This requires that a pointer to member function of the form <code>R (X::*mf)(Arg1, Arg2, ..., Arg<em>N</em>) <em>cv-quals</em></code> be adapted to a function object with the following function call operator overloads:
-<pre>
-  <b>template</b>&lt;<b>typename P</b>&gt;
-  R <b>operator</b>()(<em>cv-quals</em> P&amp; x, Arg1 arg1, Arg2 arg2, ..., Arg<em>N</em> arg<em>N</em>) <b>const</b>
-  {
-    <b>return</b> (*x).*mf(arg1, arg2, ..., arg<em>N</em>);
-  }
-</pre>
-  <li><a name="stateless"></a>A function object <code>f</code> of type <code>F</code> is <em>stateless</em> if it is a function pointer or if <a href="../../type_traits/index.htm#properties"><code>boost::is_stateless&lt;T&gt;</code></a> is true. The construction of or copy to a Boost.Function object from a stateless function object will not cause exceptions to be thrown and will not allocate any storage.</li>
-</ul>
-
-<h2><a name="function_base">Class <code>function_base</code></a></h2>
-<p> Class <code>function_base</code> is the common base class for all Boost.Function objects. Objects of type <code>function_base</code> may not be created directly. 
-
-<p> <a name="empty"><code><b>bool</b> empty() <b>const</b></code></a>
-<ul>
-  <li><b>Returns</b>: <code>true</code> if the function object has a target, <code>false</code> otherwise.</li>
-  <li><b>Throws</b>: will not throw.</li>
-</ul>
-
-<p> <a name="bool"><code><b>operator</b> safe_bool() <b>const</b></code></a>
-<ul>
-  <li><b>Returns</b>: <code>safe_bool</code> equivalent of <code>!<a href="#empty">empty</a>()</code></li>
-  <li><b>Throws</b>: will not throw.</li>
-  <li><b>Notes</b>: The <code>safe_bool</code> type can be used in contexts where a <b>bool</b> is expected (e.g., an <b>if</b> condition); however, implicit conversions (e.g., to <b>int</b>) that can occur with <b>bool</b> are not allowed, eliminating some sources of user error.
-</ul>
-
-<p> <a name="not"><code>safe_bool <b>operator!</b>() <b>const</b></code></a>
-<ul>
-  <li><b>Returns</b>: <code>safe_bool</code> equivalent of <code><a href="#empty">empty</a>()</code></li>
-  <li><b>Throws</b>: will not throw.</li>
-  <li><b>Notes</b>: See <a href="#bool"><code>safe_bool</code> conversion</a>
-</ul>
-
-<h2><a name="functionN">Class template <code>function<i>N</i></code></a></h2>
-<p> Class template <code>function<i>N</i></code> is actually a family of related classes <code>function0</code>, <code>function1</code>, etc., up to some implementation-defined maximum. In this context, <code><i>N</i></code> refers to the number of parameters and <code>f</code> refers to the implicit object parameter.
-
-<p> <a name="functionN_default"><code><b>explicit</b> function<i>N</i>(<b>const</b> Mixin<b>&amp;</b> = Mixin());</code></a>
-<ul>
-  <li><b>Effects</b>: Constructs the <code>Mixin</code> subobject with the given mixin.</li>
-  <li><b>Postconditions</b>: <code>f.<a href="#empty">empty</a>()</code>.</li>
-  <li><b>Throws</b>: will not throw unless construction of the <code>Mixin</code> subobject throws.</li>
-</ul>
-
-<p> <a name="functionN_copy"><code>function<i>N</i>(<b>const</b> function<i>N</i><b>&amp;</b> g);</code></a>
-<ul>
-  <li><b>Postconditions</b>: <code>f</code> contains a copy of the <code>g</code>'s target, if it has one, or is empty if <code>g.<a href="#empty">empty</a>()</code>. The mixin for the <code>f</code> is copy-constructed from the mixin of <code>g</code>.</li>
-  <li><b>Throws</b>: will not throw unless copying the target of <code>g</code> or construction of the <code>Mixin</code> subobject throws.</li>
-</ul>
-
-<p> <a name="functionN_target"><code><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(F g, <b>const</b> Mixin<b>&amp;</b> = Mixin());</code></a>
-<ul>
-  <li><b>Requires</b>: <code>g</code> is a <a href="#compatible">compatible</a> function object.</li>
-  <li><b>Effects</b>: Constructs the <code>Mixin</code> subobject from the given mixin.</li>
-  <li><b>Postconditions</b>: <code>f</code> targets a copy of <code>g</code> if <code>g</code> is nonempty, or <code>f.<a href="#empty">empty</a>()</code> if <code>g</code> is empty.</li>
-  <li><b>Throws</b>: will not throw when <code>g</code> is a <a href="#stateless">stateless</a> function object unless construction of the <code>Mixin</code> subobject throws.</li>
-</ul>
-
-<p> <a name="functionN_target_ref"><code><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(<a href="../../bind/ref.html">reference_wrapper</a>&lt;F&gt; g);</code></a>
-<ul>
-  <li><b>Requires</b>: <code>g.get()</code> is a <a href="#compatible">compatible</a> function object.</li>
-  <li><b>Effects</b>: Constructs the <code>Mixin</code> subobject from the given mixin.</li>
-  <li><b>Postconditions</b>: <code>this</code> object targets <code>g</code> (<em>not</em> a copy of <code>g.get()</code>) if <code>g.get()</code> is nonempty, or <code>this-&gt;empty()</code> if <code>g.get()</code> is empty.</li>
-  <li><b>Throws</b>: will not throw unless the construction of the <code>Mixin</code> subobject throws.</li>
-</ul>
-
-<p> <a name="functionN_copy_assn"><code>function<i>N</i><b>&amp;</b> <b>operator</b>=(<b>const</b> function<i>N</i><b>&amp;</b> g);</code></a>
-<ul>
-  <li><b>Postconditions</b>: <code>f</code> targets a copy of <code>g</code>'s target, if it has one, or is empty if <code>g.<a href="#empty">empty</a>()</code>. The mixin for <code>f</code> is assigned the value of the mixin for <code>g</code>.</li>
-  <li><b>Returns</b>: <code>*this</code>.</li>
-  <li><b>Throws</b>: will not throw when the target of <code>g</code> is a <a href="#stateless">stateless</a> function object or a reference to the function object, unless the copy of the <code>Mixin</code> subobject throws.</li>
-</ul>
-
-<p> <a name="functionN_target_assn"><code><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i><b>&amp;</b> <b>operator</b>=(F g);</code></a>
-<ul>
-  <li><b>Requires</b>: <code>g</code> is a <a href="#compatible">compatible</a> function object.</li>
-  <li><b>Postconditions</b>: <code>f</code> targets a copy of <code>g</code> if <code>g</code> is nonempty, or <code>f.<a href="#empty">empty</a>()</code> if <code>g</code> is empty.</li>
-  <li><b>Returns</b>: <code>*this</code>.</li>
-  <li><b>Throws</b>: will not throw when <code>g</code> is a <a href="#stateless">stateless</a> function object.</li>
-</ul>
-
-<p> <a name="functionN_target_ref_assn"><code><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i><b>&amp;</b> <b>operator</b>=(<a href="../../bind/ref.html">reference_wrapper</a>&lt;F&gt; g);</code></a>
-<ul>
-  <li><b>Requires</b>: <code>g.get()</code> is a <a href="#compatible">compatible</a> function object.</li>
-  <li><b>Postconditions</b>: <code>f</code> targets <code>g.get()</code> (not a copy of <code>g.get()</code>) if <code>g.get()</code> is nonempty, or <code>f.<a href="#empty">empty</a>()</code> if <code>g.get()</code> is empty.</li>
-  <li><b>Returns</b>: <code>*this</code>.</li>
-  <li><b>Throws</b>: will throw only if the destruction or deallocation of the target of <code>this</code> throws.</li>
-</ul>
-
-<p> <a name="functionN_copy_set"><code><b>void</b> set(<b>const</b> function<i>N</i><b>&amp;</b> g);</code></a>
-<ul>
-  <li><b>Effects</b>: <code><a href="#functionN_copy_assn">*this = g</a></code>.</li>
-</ul>
-
-<p> <a name="functionN_target_set"><code><b>template</b>&lt;<b>typename</b> F&gt; <b>void</b> set(F g);</code></a>
-<ul>
-  <li><b>Effects</b>: <code><a href="#functionN_target_assn">*this = g</a></code>.</li>
-</ul>
-
-<p> <a name="functionN_swap"><code><b>void</b> swap(function<i>N</i><b>&amp;</b> g);</code></a>
-<ul>
-  <li><b>Effects</b>: interchanges the targets of <code>f</code> and <code>g</code> and swaps the mixins of <code>f</code> and <code>g</code>.</li>
-  <li><b>Throws</b>: will not throw.</li>
-</ul>
-
-<p> <a name="functionN_clear"><code><b>void</b> clear(); </code></a>
-<ul>
-  <li><b>Effects</b>: If <code>!<a href="#empty">empty</a>()</code>, deallocates current target.</li>
-  <li><b>Postconditions</b>: <code><a href="#empty">empty</a>()</code>.</li>
-</ul>
-
-<p> <a name="functionN_call_const"><code> result_type <b>operator</b>()(Arg1 a1, Arg2 a2, <i>...</i>, Arg<i>N</i> a<i>N</i>) <b>const</b>;</code></a>
-<ul>
-  <li><b>Requires</b>: <code>!<a href="#empty">empty</a>()</code>.</li>
-  <li><b>Effects</b>: <i>target</i> is the underlying function target. It is not <code><b>const</b></code> or <code><b>volatile</b></code> qualified.
-    <ol>
-      <li><code>policy_type policy;</code></li>
-      <li><code>policy.precall(this);</code></li>
-      <li><code><i>target</i>(a1, a2, <i>...</i>, a<i>N</i>);</code></li>
-      <li><code>policy.postcall(this);</code></li>
-    </ol>
-  <li><b>Returns</b>: the value returned by <i>target</i>.</li>
-</ul>
-
-<h2><a name="function">Class template <code>function</code></a></h2>
-<p> Class template <code>function</code> is a thin wrapper around the numbered class templates <code>function0</code>, <code>function1</code>, etc. It accepts up to <i>MAX_ARGS</i> arguments, but when passed <i>N</i> arguments it will derive from <code>function<i>N</i></code> specialized with the arguments it receives.
-
-<p> The semantics of all operations in class template <code>function</code> are equivalent to that of the underlying <code>function<i>N</i></code> object, although additional member functions are required to allow proper copy construction and copy assignment of <code>function</code> objects.
-
-<h2><a name="operations">Operations</a></h2>
-<p>
-<pre>
-<b>template</b>&lt;<b>typename</b> ResultType,
-         <b>typename</b> Arg1,
-	 <b>typename</b> Arg2,
-         <i>...</i>
-	 <b>typename</b> Arg<i>N</i>,
-         <b>typename</b> Policy,
-         <b>typename</b> Mixin,
-         <b>typename</b> Allocator&gt;
-<b>void</b> <a name="swap_functionN">swap</a>(function<i>N</i>&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator&gt;<b>&amp;</b> f,
-          function<i>N</i>&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator&gt;<b>&amp;</b> g);
-</pre>
-<ul>
-  <li><b>Effects</b>: <code>f.<a href="#functionN_swap">swap</a>(g);</code></li>
-</ul>
-
-<p>
-<pre>
-<b>template</b>&lt;<b>typename</b> ResultType,
-         <b>typename</b> Arg1,
-	 <b>typename</b> Arg2,
-         <i>...</i>
-	 <b>typename</b> Arg<i>MAX_ARGS</i>&gt;
-<b>void</b> <a name="swap_function">swap</a>(function&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>&gt;<b>&amp;</b> f,
-          function&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>&gt;<b>&amp;</b> g);
-</pre>
-<ul>
-  <li><b>Effects</b>: <code>f.<a href="#functionN_swap">swap</a>(g);</code></li>
-</ul>
-
-    <hr>
-<p><a name="novoid">[1]</a> On compilers not supporting void returns, when the <code>ReturnType</code> is <b>void</b>, the <code>result_type</code> of a Boost.Function object is implementation-defined.
-    <hr>
-    <address><a href="mailto:gregod@cs.rpi.edu">Douglas Gregor</a></address>
-<!-- Created: Fri Jul 13 10:57:20 EDT 2001 -->
-<!-- hhmts start -->
-Last modified: Thu Jan 31 21:55:35 EST 2002
-<!-- hhmts end -->
-  </body>
-</html>
--- a/doc/tutorial.html
+++ b/doc/tutorial.html
@ -1,205 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-  <head>
-    <title>Boost.Function Tutorial</title>
-  </head>
-
-  <body bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080">
-
-    <h1><IMG SRC="../../../c++boost.gif" WIDTH="276" HEIGHT="86">Boost.Function Tutorial</h1>
-
-<h2><a name="usage">Basic usage</a></h2>
-<p> A function wrapper is defined simply by instantiating the <code>function</code> class template with the desired return type and argument types. Any number of arguments may be supplied, up to some implementation-defined limit (10 is the default maximum). The following declares a function object wrapper <code>f</code> that takes two <code>int</code> parameters and returns a <code>float</code>:
-<pre>
-boost::<a href="reference.html#function">function</a>&lt;float, int, int&gt; f;
-</pre>
-
-<p> By default, function object wrappers are empty, so we can create a 
-function object to assign to <code>f</code>:
-<pre>
-struct int_div { 
-  float operator()(int x, int y) const { return ((float)x)/y; }; 
-};
-
-f = int_div();
-</pre>
-
-<p> Now we can use <code>f</code> to execute the underlying function object
-<code>int_div</code>:
-<pre>
-std::cout << f(5, 3) << std::endl;
-</pre>
-
-<p> We are free to assign any compatible function object to <code>f</code>. If <code>int_div</code> had been declared to take two <code>long</code> operands,
-the implicit conversions would have been applied to the arguments without any user interference. The only limit on the types of arguments is that they be CopyConstructible, so we can even use references and arrays:
-<pre>
-boost::function&lt;void, int[], int, int&, float&&gt; sum_avg;
-
-void do_sum_avg(int values[], int n, int& sum, float&amp; avg)
-{
-  sum = 0;
-  for (int i = 0; i < n; i++)
-    sum += values[i];
-  avg = (float)sum / n;
-}
-
-sum_avg = &do_sum_avg;
-</pre>
-
-<p> Invoking a function object wrapper that does not actually contain a function object is a precondition violation, much like trying to call through a null function pointer. We can check for an empty function object wrapper by querying its <code><a href="reference.html#empty">empty</a>()</code> method or, more succinctly, by using it in a boolean context: if it evaluates true, it contains a function object target, i.e.,
-<pre>
-if (f)
-  std::cout << f(5, 3) << std::endl;
-else
-  std::cout << "f has no target, so it is unsafe to call" << std::endl;
-</pre>
-
-<p> We can clear out a function target using the <code><a href="reference.html#functionN_clear">clear</a>()</code> member function.
-
-<h3>Free functions</h3>
-<p> Free function pointers can be considered singleton function objects with const function call operators, and can therefore be directly used with the function object wrappers:
-<pre>
-  float mul_ints(int x, int y) { return ((float)x) * y; }
-  f = &amp;mul_ints;
-</pre>
-
-<p> Note that the <code>&amp;</code> isn't really necessary unless you happen to be using Microsoft Visual C++ version 6.
-
-<h3>Member functions</h3>
-<a name="member_func">
-<p> In many systems, callbacks often call to member functions of a particular
-object. This is often referred to as "argument binding", and is beyond the scope of Boost.Function. The use of member functions directly, however, is supported, so the following code is valid:
-<pre>
-  struct X {
-    int foo(int);
-  };
-
-  boost::function&lt;int, X*, int&gt; f;
-  f = &amp;X::foo;
-  
-  X x;
-  f(&amp;x, 5);
-</pre>
-<p> Several libraries exist that support argument binding. Three such libraries are summarized below:
-<ul>
-  <li> <a href="../../bind/bind.html">Boost.Bind</a>. This library allows binding of arguments for any function object. It is lightweight and very portable.</li>
-
-  <li> The C++ Standard library. Using <code>std::bind1st</code> and <code>std::mem_fun</code> together one can bind the object of a pointer-to-member function for use with Boost.Function:
-<pre>
-  struct X {
-    int foo(int);
-  };
-
-  boost::function&lt;int, int&gt; f;
-  X x;
-  f = std::bind1st(std::mem_fun(&X::foo), &x);
-
-  f(5); // Call x.foo(5)</pre></li>
-
-  <li><a href="http://lambda.cs.utu.fi/">The Lambda library</a>. This library provides a powerful composition mechanism to construct function objects that uses very natural C++ syntax. Lambda requires a compiler that is reasonably conformant to the C++ standard. Note that it is not a Boost library.</li>
-</ul>
-
-<h3>References to Functions</h3>
-<p> In some cases it is expensive (or semantically incorrect) to have
-Boost.Function clone a function object. In such cases, it is possible
-to request that Boost.Function keep only a reference to the actual
-function object. This is done using the <a
-href="../../bind/ref.html"><code>ref</code></a> and <a
-href="../../bind/ref.html"><code>cref</code></a> functions to wrap a
-reference to a function object:
-
-<pre>
-  stateful_type a_function_object;
-  boost::function&lt;int, int&gt; f;
-  f = ref(a_function_object);
-
-  boost::function&lt;int, int&gt; f2(f);
-</pre>
-
-Here, <code>f</code> will not make a copy of
-<code>a_function_object</code>, nor will <code>f2</code> when it is
-targeted to <code>f</code>'s reference to
-<code>a_function_object</code>. Additionally, when using references to
-function objects, Boost.Function will not throw exceptions during
-    assignment or construction.
- 
-<h2><a name="family">The <code>function</code> family</a></h2>
-<p> The header &lt;<a href="../../../boost/function.hpp">boost/function.hpp</a>&gt; defines the primary entry point to the function object wrappers, the class template <code>boost::function</code>. This class template is essentially a thin wrapper around a set of similar numbered function object wrappers, <code>boost::function0</code>, <code>boost::function1</code>, etc., where the number indicates the number of arguments passed to the function object target. The declaration of <code>f</code> above could also be written as:
-<pre>
-boost::function2&lt;float, int, int&gt; f;
-</pre>
-
-<p> The numbered class templates contain most of the implementation and are each distinct class templates. They may be helpful if used in shared libraries, where the number of arguments supported by Boost.Function may change between revisions. Additionally, some compilers (e.g., Microsoft Visual C++ 6.0) have been known to be incapable of compiling <code>boost::function</code> in some instances but are able to handle the numbered variants.
-
-<h2><a name="advanced">Advanced usage</a></h2>
-<p> The <code>boost::function</code> family supports additional customization by means of policies, mixins, and allocators. The specific usage of each of these will be explained in later sections, but they share a common problem: how to replace each default with your own version. 
-
-<p> With <code>boost::function</code> it is not so clear, because support for an arbitrary number of parameters means that it is impossible to specify just the last parameter, but not 5 of the parameters in between. Therefore, <code>boost::function</code> doubles as a generative interface for the underlying numbered class templates that uses named template parameters. For instance, to specify both a policy and an allocator for a function object wrapper <code>f</code> taking an <code>int</code> and returning an <code>int</code>, use:
-<pre>
-  function&lt;int, int&gt;::policy&lt;MyPolicy&gt;::allocator&lt;MyAllocator&gt;::type f;
-</pre>
-
-<p> The named template parameters <code>policy</code>, <code>mixin</code> and <code>allocator</code> each take one template parameter (the replacement class) and may be nested as above to generate a function object wrapper. The <code>::type</code> at the end accesses the actual type that fits the given properties.
-
-<h3><a name="policies">Policies</a></h3>
-<p> Policies define what happens directly before and directly after an invocation of a function object target is made. A policy must have two member functions, <code>precall</code> and <code>postcall</code>, each of which must be able to accept a <code>const</code> function object wrapper pointer. The following policy will print "before" prior to execution and "after" afterwards:
-
-<pre>
-struct print_policy {
-  void precall(const boost::function_base*) { std::cout << "before"; }
-  void postcall(const boost::function_base*) { std::cout << "after"; }
-};
-</pre>
-
-<p> A new instance of the policy class will be created prior to calling the function object target and will be preserved until after the call has returned. Therefore, for any invocation the <code>precall</code> and <code>postcall</code> will be executed on the same policy class instance; however, policy class instances will not be kept between target invocations.
-
-<p> Policies are further <a href="../../../more/generic_programming.html#policy">described</a> in the Boost discussion on <a href="../../../more/generic_programming.html">generic programming techniques</a>.
-
-<h3><a name="mixins">Mixins</a></h3>
-<p> The function object wrappers allow any class to be "mixed in" as a base class. This allows extra members and/or functionality to be included by the user. This can be used, for instance, to overcome the limitations of policies by storing data between invocations in a base class instead of in a <code>static</code> member of a policy class. 
-
-<h3><a name="allocators">Allocators</a></h3>
-<p> The function object wrappers allow the user to specify a new allocator to handle the cloning of function object targets (when the wrappers are copied). The allocators used are the same as the C++ standard library allocators. The wrappers assume the allocators are stateless, and will create a new instance each time they are used (because they are rebound very often). This shares the semantics of most standard library implementations, and is explicitly allowed by the C++ standard.
-
-<h3><a name="synchronizing">Example: Synchronized callbacks</a></h3>
-<p> Synchronization of callbacks in a multithreaded environment is extremely important. Using mixins and policies, a Boost.Function object may implement its own synchronization policy that ensures that only one thread can be in the callback function at any given point in time.
-
-<p> We will use the prototype Boost.Threads library for its <code>recursive_mutex</code>. Since the mutex is on a per-callback basis, we will add a mutex to the <code>boost::function</code> by mixin it in with this mixin class:
-<pre>
-class SynchronizedMixin {
-  mutable boost::recursive_mutex mutex;
-};
-</pre>
-
-<p> Next, we create a policy that obtains a lock before the target is called (via the <code>precall</code> function) and releases the lock after the target has been called (via the <code>postcall</code> function):
-
-<pre>
-class SynchronizedPolicy {
-  std::auto_ptr&lt;boost::recursive_mutex::lock&gt; lock;
-
-  void precall(const SynchronizedMixin* f) 
-  {
-    lock.reset(new boost::recursive_mutex::lock(f->mutex));
-  }
-
-  void postcall(const SynchronizedMixin* f)
-  {
-    lock.reset();
-  }
-};
-</pre>
-
-<p>The use of <code>std::auto_ptr</code> ensures that the lock will be destroyed (and therefore released) if an exception is thrown by the target function. Now we can use the policy and mixin together to create a synchronized callback:
-
-<pre>
-boost::function2&lt;float, int, int, SynchronizedPolicy, SynchronizedMixin&gt; f;
-</pre>
-
-    <hr>
-    <address><a href="mailto:gregod@cs.rpi.edu">Douglas Gregor</a></address>
-<!-- Created: Fri Jul 13 12:47:11 EDT 2001 -->
-<!-- hhmts start -->
-Last modified: Fri Dec 14 19:58:14 EST 2001
-<!-- hhmts end -->
-  </body>
-</html>
--- a/example/bind1st.cpp
+++ b/example/bind1st.cpp
@ -1,38 +0,0 @@
-// Boost.Function library examples
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#include <iostream>
-#include <boost/function.hpp>
-#include <functional>
-
-struct X {
-  X(int val) : value(val) {}
-
-  int foo(int x) { return x * value; }
-
-  int value;
-};
-
-
-int
-main()
-{
-  boost::function<int, int> f;
-  X x(7);
-  f = std::bind1st(std::mem_fun(&X::foo), &x);
-
-  std::cout << f(5) << std::endl; // Call x.foo(5)
-  return 0;
-}
--- a/example/int_div.cpp
+++ b/example/int_div.cpp
@ -1,32 +0,0 @@
-// Boost.Function library examples
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#include <iostream>
-#include <boost/function.hpp>
-
-struct int_div { 
-  float operator()(int x, int y) const { return ((float)x)/y; }; 
-};
-
-int
-main()
-{
-  boost::function<float, int, int> f;
-  f = int_div();
-
-  std::cout << f(5, 3) << std::endl; // 1.66667
-
-  return 0;
-}
--- a/example/sum_avg.cpp
+++ b/example/sum_avg.cpp
@ -1,44 +0,0 @@
-// Boost.Function library examples
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#include <iostream>
-#include <boost/function.hpp>
-
-void do_sum_avg(int values[], int n, int& sum, float& avg)
-{
-  sum = 0;
-  for (int i = 0; i < n; i++)
-    sum += values[i];
-  avg = (float)sum / n;
-}
-
-int
-main()
-{
-  // The second parameter should be int[], but some compilers (e.g., GCC)
-  // complain about this 
-  boost::function<void, int*, int, int&, float&> sum_avg;
-
-  sum_avg = &do_sum_avg;
-
-  int values[5] = { 1, 1, 2, 3, 5 };
-  int sum;
-  float avg;
-  sum_avg(values, 5, sum, avg);
-
-  std::cout << "sum = " << sum << std::endl;
-  std::cout << "avg = " << avg << std::endl;
-  return 0;
-}
--- a/include/boost/function.hpp
+++ b/include/boost/function.hpp
@ -1,517 +1,64 @@
 // Boost.Function library

-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
- 
-// For more information, see http://www.boost.org
- 
+//  Copyright Douglas Gregor 2001-2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org/libs/function
+
 // William Kempf, Jesse Jones and Karl Nelson were all very helpful in the
 // design of this library.

-#ifndef BOOST_FUNCTION_HPP
-#define BOOST_FUNCTION_HPP
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/detail/workaround.hpp>

-#include <boost/function/function_base.hpp>
-#include <boost/function/function0.hpp>
-#include <boost/function/function1.hpp>
-#include <boost/function/function2.hpp>
-#include <boost/function/function3.hpp>
-#include <boost/function/function4.hpp>
-#include <boost/function/function5.hpp>
-#include <boost/function/function6.hpp>
-#include <boost/function/function7.hpp>
-#include <boost/function/function8.hpp>
-#include <boost/function/function9.hpp>
-#include <boost/function/function10.hpp>
+#ifndef BOOST_FUNCTION_MAX_ARGS
+#  define BOOST_FUNCTION_MAX_ARGS 10
+#endif // BOOST_FUNCTION_MAX_ARGS

-namespace boost {
-  namespace detail {
-    namespace function {
-      // Choose the appropriate underlying implementation
-      template<int Args> struct real_get_function_impl {};
+// Include the prologue here so that the use of file-level iteration
+// in anything that may be included by function_template.hpp doesn't break
+#include <boost/function/detail/prologue.hpp>

-      template<>
-      struct real_get_function_impl<0>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function0<R, Policy, Mixin, Allocator> type;
-        };
-      };
-
-      template<>
-      struct real_get_function_impl<1>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function1<R, T1, Policy, Mixin, Allocator> type;
-        };
-      };
-
-      template<>
-      struct real_get_function_impl<2>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function2<R, T1, T2, Policy, Mixin, Allocator> type;
-        };
-      };
-
-      template<>
-      struct real_get_function_impl<3>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function3<R, T1, T2, T3, Policy, Mixin, Allocator> type;
-        };
-      };
-
-      template<>
-      struct real_get_function_impl<4>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function4<R, T1, T2, T3, T4, Policy, Mixin, Allocator> type;
-        };
-      };
-
-      template<>
-      struct real_get_function_impl<5>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function5<R, T1, T2, T3, T4, T5, Policy, Mixin, Allocator> 
-          type;
-        };
-      };
-
-      template<>
-      struct real_get_function_impl<6>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function6<R, T1, T2, T3, T4, T5, T6, Policy, Mixin, Allocator>
-          type;
-        };
-      };
-
-      template<>
-      struct real_get_function_impl<7>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function7<R, T1, T2, T3, T4, T5, T6, T7, Policy, Mixin, 
-                            Allocator> type;
-        };
-      };
-
-      template<>
-      struct real_get_function_impl<8>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function8<R, T1, T2, T3, T4, T5, T6, T7, T8, Policy, Mixin, 
-                            Allocator> type;
-        };
-      };
-
-      template<>
-      struct real_get_function_impl<9>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function9<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, Policy, 
-                            Mixin, Allocator> type;
-        };
-      };
-
-      template<>
-      struct real_get_function_impl<10>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function10<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, 
-                             Policy, Mixin, Allocator> type;
-        };
-      };
-
-      template<
-        typename R, 
-        typename T1, 
-        typename T2, 
-        typename T3, 
-        typename T4,
-        typename T5, 
-        typename T6, 
-        typename T7, 
-        typename T8, 
-        typename T9,
-        typename T10,
-        typename Policy = empty_function_policy,
-        typename Mixin = empty_function_mixin,
-        typename Allocator = std::allocator<function_base> 
-      >
-      struct get_function_impl
-      {
-        typedef typename real_get_function_impl<
-          (count_used_args<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value)
-          >::template params<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, 
-                             Policy, Mixin, Allocator>::type
-        type;
-      };
-
-  template<
-    typename R, 
-    typename T1, 
-    typename T2, 
-    typename T3, 
-    typename T4,
-    typename T5, 
-    typename T6, 
-    typename T7, 
-    typename T8, 
-    typename T9,
-    typename T10,
-    typename MyPolicy = empty_function_policy,
-    typename MyMixin = empty_function_mixin,
-    typename MyAllocator = std::allocator<function_base> 
-  >
-  struct function_traits_builder
-  {
-    typedef typename get_function_impl<R, T1, T2, T3, T4, T5, T6, T7, 
-                                       T8, T9, T10, MyPolicy, MyMixin, 
-                                       MyAllocator>::type
-      type;
-
-    typedef MyPolicy    policy_type;
-    typedef MyMixin     mixin_type;
-    typedef MyAllocator allocator_type;
-
-#ifndef BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
-    template<typename Policy>
-    struct policy : 
-        public function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7, T8, T9,
-                                       T10, Policy, mixin_type, 
-                                       allocator_type> {};
-
-    template<typename Mixin>
-    struct mixin : 
-        public function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7, T8, T9,
-                                       T10, policy_type, Mixin, 
-                                       allocator_type> {};
-
-    template<typename Allocator>
-    struct allocator : 
-        public function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7, T8, T9,
-                                       T10, policy_type, mixin_type, 
-                                       Allocator> {};
+// Visual Age C++ doesn't handle the file iteration well
+#if BOOST_WORKAROUND(__IBMCPP__, >= 500)
+#  if BOOST_FUNCTION_MAX_ARGS >= 0
+#    include <boost/function/function0.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 1
+#    include <boost/function/function1.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 2
+#    include <boost/function/function2.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 3
+#    include <boost/function/function3.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 4
+#    include <boost/function/function4.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 5
+#    include <boost/function/function5.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 6
+#    include <boost/function/function6.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 7
+#    include <boost/function/function7.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 8
+#    include <boost/function/function8.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 9
+#    include <boost/function/function9.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 10
+#    include <boost/function/function10.hpp>
+#  endif
 #else
-    template<typename Policy>
-    struct policy 
-    {
-      typedef typename function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7,
-                                               T8, T9, T10, Policy, 
-                                               mixin_type, 
-                                               allocator_type>::type
-        type;
-    };
-
-    template<typename Mixin>
-    struct mixin
-    {
-      typedef typename function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7,
-                                               T8, T9, T10, policy_type, Mixin,
-                                               allocator_type>::type
-        type;
-    };
-
-    template<typename Allocator>
-    struct allocator
-    {
-      typedef typename function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7,
-                                               T8, T9, T10, policy_type, 
-                                               mixin_type, Allocator>::type
-        type;
-    };
-#endif
-  };
-
-    } // end namespace function
-  } // end namespace detail
-
-  template<
-    typename R, 
-    typename T1 = detail::function::unusable, 
-    typename T2 = detail::function::unusable,
-    typename T3 = detail::function::unusable,
-    typename T4 = detail::function::unusable,
-    typename T5 = detail::function::unusable,
-    typename T6 = detail::function::unusable,
-    typename T7 = detail::function::unusable,
-    typename T8 = detail::function::unusable,
-    typename T9 = detail::function::unusable,
-    typename T10 = detail::function::unusable
-  >
-  class function :
-    public detail::function::get_function_impl<R, T1, T2, T3, T4, T5, T6, T7, 
-                                               T8, T9, T10>::type,
-    public detail::function::function_traits_builder<R, T1, T2, T3, T4, T5, T6,
-                                                     T7, T8, T9, T10>
-  {
-    typedef typename detail::function::get_function_impl<R, T1, T2, T3, T4, T5,
-                                                         T6, T7, T8, T9, T10
-                                                         >::type 
-      base_type;
-
-  public:
-    typedef typename base_type::policy_type policy_type;
-    typedef typename base_type::mixin_type mixin_type;
-    typedef typename base_type::allocator_type allocator_type;              
-    typedef function self_type;                                     
-                                                                            
-    function() : base_type() {}                                     
-                                                                            
-    template<typename Functor>                                              
-    function(Functor BOOST_FUNCTION_TARGET_FIX(const &) f) : base_type(f) {}
-                      
-    function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
-         
-    template<typename Functor>
-    self_type& operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
-    {
-      self_type(f).swap(*this);
-      return *this;
-    }
-
-    self_type& operator=(const base_type& f)
-    {
-      self_type(f).swap(*this);
-      return *this;
-    }
-
-    self_type& operator=(const self_type& f)
-    {   
-      self_type(f).swap(*this);
-      return *this;
-    }
-
-    template<typename Functor>
-    void set(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
-    {
-      self_type(f).swap(*this);
-    }
-
-    void set(const base_type& f)
-    {
-      self_type(f).swap(*this);
-    }
-
-    void set(const self_type& f)                             
-    {
-      self_type(f).swap(*this);
-    }   
-  };
-
-  template<typename R,
-           typename T1, 
-           typename T2,
-           typename T3,
-           typename T4,
-           typename T5,
-           typename T6,
-           typename T7,
-           typename T8,
-           typename T9,
-           typename T10>
-  inline void swap(function<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& f1,
-                   function<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& f2)
-  {
-    f1.swap(f2);
-  }
-}
-
+// What is the '3' for?
+#  define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_FUNCTION_MAX_ARGS,<boost/function/detail/function_iterate.hpp>))
+#  include BOOST_PP_ITERATE()
+#  undef BOOST_PP_ITERATION_PARAMS_1
 #endif
--- a/include/boost/function/detail/function_iterate.hpp
+++ b/include/boost/function/detail/function_iterate.hpp
@ -0,0 +1,16 @@
+// Boost.Function library
+
+//  Copyright Douglas Gregor 2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+#if !defined(BOOST_PP_IS_ITERATING)
+# error Boost.Function - do not include this file!
+#endif
+
+#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS
+
--- a/include/boost/function/detail/gen_maybe_include.pl
+++ b/include/boost/function/detail/gen_maybe_include.pl
@ -0,0 +1,37 @@
+#!/usr/bin/perl -w
+#
+# Boost.Function library
+#
+# Copyright (C) 2001-2003 Douglas Gregor (gregod@cs.rpi.edu)
+#
+# Permission to copy, use, sell and distribute this software is granted
+# provided this copyright notice appears in all copies.
+# Permission to modify the code and to distribute modified code is granted
+# provided this copyright notice appears in all copies, and a notice
+# that the code was modified is included with the copyright notice.
+#
+# This software is provided "as is" without express or implied warranty,
+# and with no claim as to its suitability for any purpose.
+#
+# For more information, see http://www.boost.org
+use English;
+
+$max_args = $ARGV[0];
+
+open (OUT, ">maybe_include.hpp") or die("Cannot write to maybe_include.hpp");
+for($on_arg = 0; $on_arg <= $max_args; ++$on_arg) {
+    if ($on_arg == 0) {
+	print OUT "#if";
+    }
+    else {
+	print OUT "#elif";
+    }
+    print OUT " BOOST_FUNCTION_NUM_ARGS == $on_arg\n";
+    print OUT "#  ifndef BOOST_FUNCTION_$on_arg\n";
+    print OUT "#    define BOOST_FUNCTION_$on_arg\n";
+    print OUT "#    include <boost/function/function_template.hpp>\n";
+    print OUT "#  endif\n";
+}
+print OUT "#else\n";
+print OUT "#  error Cannot handle Boost.Function objects that accept more than $max_args arguments!\n";
+print OUT "#endif\n";
--- a/include/boost/function/detail/maybe_include.hpp
+++ b/include/boost/function/detail/maybe_include.hpp
@ -0,0 +1,267 @@
+// Boost.Function library
+
+//  Copyright Douglas Gregor 2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+
+#if BOOST_FUNCTION_NUM_ARGS == 0
+#  ifndef BOOST_FUNCTION_0
+#    define BOOST_FUNCTION_0
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 1
+#  ifndef BOOST_FUNCTION_1
+#    define BOOST_FUNCTION_1
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 2
+#  ifndef BOOST_FUNCTION_2
+#    define BOOST_FUNCTION_2
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 3
+#  ifndef BOOST_FUNCTION_3
+#    define BOOST_FUNCTION_3
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 4
+#  ifndef BOOST_FUNCTION_4
+#    define BOOST_FUNCTION_4
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 5
+#  ifndef BOOST_FUNCTION_5
+#    define BOOST_FUNCTION_5
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 6
+#  ifndef BOOST_FUNCTION_6
+#    define BOOST_FUNCTION_6
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 7
+#  ifndef BOOST_FUNCTION_7
+#    define BOOST_FUNCTION_7
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 8
+#  ifndef BOOST_FUNCTION_8
+#    define BOOST_FUNCTION_8
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 9
+#  ifndef BOOST_FUNCTION_9
+#    define BOOST_FUNCTION_9
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 10
+#  ifndef BOOST_FUNCTION_10
+#    define BOOST_FUNCTION_10
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 11
+#  ifndef BOOST_FUNCTION_11
+#    define BOOST_FUNCTION_11
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 12
+#  ifndef BOOST_FUNCTION_12
+#    define BOOST_FUNCTION_12
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 13
+#  ifndef BOOST_FUNCTION_13
+#    define BOOST_FUNCTION_13
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 14
+#  ifndef BOOST_FUNCTION_14
+#    define BOOST_FUNCTION_14
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 15
+#  ifndef BOOST_FUNCTION_15
+#    define BOOST_FUNCTION_15
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 16
+#  ifndef BOOST_FUNCTION_16
+#    define BOOST_FUNCTION_16
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 17
+#  ifndef BOOST_FUNCTION_17
+#    define BOOST_FUNCTION_17
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 18
+#  ifndef BOOST_FUNCTION_18
+#    define BOOST_FUNCTION_18
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 19
+#  ifndef BOOST_FUNCTION_19
+#    define BOOST_FUNCTION_19
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 20
+#  ifndef BOOST_FUNCTION_20
+#    define BOOST_FUNCTION_20
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 21
+#  ifndef BOOST_FUNCTION_21
+#    define BOOST_FUNCTION_21
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 22
+#  ifndef BOOST_FUNCTION_22
+#    define BOOST_FUNCTION_22
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 23
+#  ifndef BOOST_FUNCTION_23
+#    define BOOST_FUNCTION_23
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 24
+#  ifndef BOOST_FUNCTION_24
+#    define BOOST_FUNCTION_24
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 25
+#  ifndef BOOST_FUNCTION_25
+#    define BOOST_FUNCTION_25
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 26
+#  ifndef BOOST_FUNCTION_26
+#    define BOOST_FUNCTION_26
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 27
+#  ifndef BOOST_FUNCTION_27
+#    define BOOST_FUNCTION_27
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 28
+#  ifndef BOOST_FUNCTION_28
+#    define BOOST_FUNCTION_28
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 29
+#  ifndef BOOST_FUNCTION_29
+#    define BOOST_FUNCTION_29
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 30
+#  ifndef BOOST_FUNCTION_30
+#    define BOOST_FUNCTION_30
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 31
+#  ifndef BOOST_FUNCTION_31
+#    define BOOST_FUNCTION_31
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 32
+#  ifndef BOOST_FUNCTION_32
+#    define BOOST_FUNCTION_32
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 33
+#  ifndef BOOST_FUNCTION_33
+#    define BOOST_FUNCTION_33
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 34
+#  ifndef BOOST_FUNCTION_34
+#    define BOOST_FUNCTION_34
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 35
+#  ifndef BOOST_FUNCTION_35
+#    define BOOST_FUNCTION_35
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 36
+#  ifndef BOOST_FUNCTION_36
+#    define BOOST_FUNCTION_36
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 37
+#  ifndef BOOST_FUNCTION_37
+#    define BOOST_FUNCTION_37
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 38
+#  ifndef BOOST_FUNCTION_38
+#    define BOOST_FUNCTION_38
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 39
+#  ifndef BOOST_FUNCTION_39
+#    define BOOST_FUNCTION_39
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 40
+#  ifndef BOOST_FUNCTION_40
+#    define BOOST_FUNCTION_40
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 41
+#  ifndef BOOST_FUNCTION_41
+#    define BOOST_FUNCTION_41
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 42
+#  ifndef BOOST_FUNCTION_42
+#    define BOOST_FUNCTION_42
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 43
+#  ifndef BOOST_FUNCTION_43
+#    define BOOST_FUNCTION_43
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 44
+#  ifndef BOOST_FUNCTION_44
+#    define BOOST_FUNCTION_44
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 45
+#  ifndef BOOST_FUNCTION_45
+#    define BOOST_FUNCTION_45
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 46
+#  ifndef BOOST_FUNCTION_46
+#    define BOOST_FUNCTION_46
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 47
+#  ifndef BOOST_FUNCTION_47
+#    define BOOST_FUNCTION_47
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 48
+#  ifndef BOOST_FUNCTION_48
+#    define BOOST_FUNCTION_48
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 49
+#  ifndef BOOST_FUNCTION_49
+#    define BOOST_FUNCTION_49
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 50
+#  ifndef BOOST_FUNCTION_50
+#    define BOOST_FUNCTION_50
+#    include <boost/function/function_template.hpp>
+#  endif
+#else
+#  error Cannot handle Boost.Function objects that accept more than 50 arguments!
+#endif
--- a/include/boost/function/detail/prologue.hpp
+++ b/include/boost/function/detail/prologue.hpp
@ -0,0 +1,24 @@
+// Boost.Function library
+
+//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+
+#ifndef BOOST_FUNCTION_PROLOGUE_HPP
+#define BOOST_FUNCTION_PROLOGUE_HPP
+#  include <cassert>
+#  include <algorithm>
+#  include <boost/throw_exception.hpp>
+#  include <boost/config.hpp>
+#  include <boost/function/function_base.hpp>
+#  include <boost/mem_fn.hpp>
+#  include <boost/type_traits/is_integral.hpp>
+#  include <boost/preprocessor/enum.hpp>
+#  include <boost/preprocessor/enum_params.hpp>
+#  include <boost/preprocessor/cat.hpp>
+#  include <boost/preprocessor/repeat.hpp>
+#  include <boost/preprocessor/inc.hpp>
+#endif // BOOST_FUNCTION_PROLOGUE_HPP
--- a/include/boost/function/function0.hpp
+++ b/include/boost/function/function0.hpp
@ -1,37 +1,12 @@
 // Boost.Function library
-//
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
- 
+
+//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION_FUNCTION0_HEADER
-#define BOOST_FUNCTION_FUNCTION0_HEADER
-
 #define BOOST_FUNCTION_NUM_ARGS 0
-#define BOOST_FUNCTION_TEMPLATE_PARMS 
-#define BOOST_FUNCTION_TEMPLATE_ARGS 
-#define BOOST_FUNCTION_PARMS 
-#define BOOST_FUNCTION_ARGS 
-#define BOOST_FUNCTION_NOT_0_PARMS 
-#define BOOST_FUNCTION_NOT_0_ARGS 
-
-#include <boost/function/function_template.hpp>
-
-#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_NOT_0_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-
-#endif // BOOST_FUNCTION_FUNCTION0_HEADER
--- a/include/boost/function/function1.hpp
+++ b/include/boost/function/function1.hpp
@ -1,37 +1,12 @@
 // Boost.Function library
-//
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
- 
+
+//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION_FUNCTION1_HEADER
-#define BOOST_FUNCTION_FUNCTION1_HEADER
-
 #define BOOST_FUNCTION_NUM_ARGS 1
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0
-#define BOOST_FUNCTION_TEMPLATE_ARGS T0
-#define BOOST_FUNCTION_PARMS T0 a0
-#define BOOST_FUNCTION_ARGS a0
-#define BOOST_FUNCTION_NOT_0_PARMS 
-#define BOOST_FUNCTION_NOT_0_ARGS 
-
-#include <boost/function/function_template.hpp>
-
-#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_NOT_0_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-
-#endif // BOOST_FUNCTION_FUNCTION1_HEADER
--- a/include/boost/function/function10.hpp
+++ b/include/boost/function/function10.hpp
@ -1,37 +1,12 @@
 // Boost.Function library
-//
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
- 
+
+//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION_FUNCTION10_HEADER
-#define BOOST_FUNCTION_FUNCTION10_HEADER
-
 #define BOOST_FUNCTION_NUM_ARGS 10
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9
-#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
-#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8, T9 a9
-#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4, a5, a6, a7, a8, a9
-#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8, T9 a9
-#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4, a5, a6, a7, a8, a9
-
-#include <boost/function/function_template.hpp>
-
-#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_NOT_0_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-
-#endif // BOOST_FUNCTION_FUNCTION10_HEADER
--- a/include/boost/function/function2.hpp
+++ b/include/boost/function/function2.hpp
@ -1,37 +1,12 @@
 // Boost.Function library
-//
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
- 
+
+//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION_FUNCTION2_HEADER
-#define BOOST_FUNCTION_FUNCTION2_HEADER
-
 #define BOOST_FUNCTION_NUM_ARGS 2
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1
-#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1
-#define BOOST_FUNCTION_PARMS T0 a0, T1 a1
-#define BOOST_FUNCTION_ARGS a0, a1
-#define BOOST_FUNCTION_NOT_0_PARMS T1 a1
-#define BOOST_FUNCTION_NOT_0_ARGS a1
-
-#include <boost/function/function_template.hpp>
-
-#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_NOT_0_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-
-#endif // BOOST_FUNCTION_FUNCTION2_HEADER
--- a/include/boost/function/function3.hpp
+++ b/include/boost/function/function3.hpp
@ -1,37 +1,12 @@
 // Boost.Function library
-//
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
- 
+
+//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION_FUNCTION3_HEADER
-#define BOOST_FUNCTION_FUNCTION3_HEADER
-
 #define BOOST_FUNCTION_NUM_ARGS 3
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2
-#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2
-#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2
-#define BOOST_FUNCTION_ARGS a0, a1, a2
-#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2
-#define BOOST_FUNCTION_NOT_0_ARGS a1, a2
-
-#include <boost/function/function_template.hpp>
-
-#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_NOT_0_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-
-#endif // BOOST_FUNCTION_FUNCTION3_HEADER
--- a/include/boost/function/function4.hpp
+++ b/include/boost/function/function4.hpp
@ -1,37 +1,12 @@
 // Boost.Function library
-//
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
- 
+
+//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION_FUNCTION4_HEADER
-#define BOOST_FUNCTION_FUNCTION4_HEADER
-
 #define BOOST_FUNCTION_NUM_ARGS 4
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3
-#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3
-#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3
-#define BOOST_FUNCTION_ARGS a0, a1, a2, a3
-#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3
-#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3
-
-#include <boost/function/function_template.hpp>
-
-#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_NOT_0_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-
-#endif // BOOST_FUNCTION_FUNCTION4_HEADER
--- a/include/boost/function/function5.hpp
+++ b/include/boost/function/function5.hpp
@ -1,37 +1,12 @@
 // Boost.Function library
-//
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
- 
+
+//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION_FUNCTION5_HEADER
-#define BOOST_FUNCTION_FUNCTION5_HEADER
-
 #define BOOST_FUNCTION_NUM_ARGS 5
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4
-#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3, T4
-#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3, T4 a4
-#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4
-#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4
-#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4
-
-#include <boost/function/function_template.hpp>
-
-#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_NOT_0_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-
-#endif // BOOST_FUNCTION_FUNCTION5_HEADER
--- a/include/boost/function/function6.hpp
+++ b/include/boost/function/function6.hpp
@ -1,37 +1,12 @@
 // Boost.Function library
-//
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
- 
+
+//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION_FUNCTION6_HEADER
-#define BOOST_FUNCTION_FUNCTION6_HEADER
-
 #define BOOST_FUNCTION_NUM_ARGS 6
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4, typename T5
-#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3, T4, T5
-#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5
-#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4, a5
-#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5
-#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4, a5
-
-#include <boost/function/function_template.hpp>
-
-#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_NOT_0_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-
-#endif // BOOST_FUNCTION_FUNCTION6_HEADER
--- a/include/boost/function/function7.hpp
+++ b/include/boost/function/function7.hpp
@ -1,37 +1,12 @@
 // Boost.Function library
-//
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
- 
+
+//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION_FUNCTION7_HEADER
-#define BOOST_FUNCTION_FUNCTION7_HEADER
-
 #define BOOST_FUNCTION_NUM_ARGS 7
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6
-#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3, T4, T5, T6
-#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6
-#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4, a5, a6
-#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6
-#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4, a5, a6
-
-#include <boost/function/function_template.hpp>
-
-#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_NOT_0_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-
-#endif // BOOST_FUNCTION_FUNCTION7_HEADER
--- a/include/boost/function/function8.hpp
+++ b/include/boost/function/function8.hpp
@ -1,37 +1,12 @@
 // Boost.Function library
-//
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
- 
+
+//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION_FUNCTION8_HEADER
-#define BOOST_FUNCTION_FUNCTION8_HEADER
-
 #define BOOST_FUNCTION_NUM_ARGS 8
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7
-#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3, T4, T5, T6, T7
-#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7
-#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4, a5, a6, a7
-#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7
-#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4, a5, a6, a7
-
-#include <boost/function/function_template.hpp>
-
-#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_NOT_0_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-
-#endif // BOOST_FUNCTION_FUNCTION8_HEADER
--- a/include/boost/function/function9.hpp
+++ b/include/boost/function/function9.hpp
@ -1,37 +1,12 @@
 // Boost.Function library
-//
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
- 
+
+//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION_FUNCTION9_HEADER
-#define BOOST_FUNCTION_FUNCTION9_HEADER
-
 #define BOOST_FUNCTION_NUM_ARGS 9
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8
-#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3, T4, T5, T6, T7, T8
-#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8
-#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4, a5, a6, a7, a8
-#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8
-#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4, a5, a6, a7, a8
-
-#include <boost/function/function_template.hpp>
-
-#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_NOT_0_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-
-#endif // BOOST_FUNCTION_FUNCTION9_HEADER
--- a/include/boost/function/function_base.hpp
+++ b/include/boost/function/function_base.hpp
@ -1,107 +1,153 @@
 // Boost.Function library

-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
- 
+//  Copyright Douglas Gregor 2001-2004. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
 // For more information, see http://www.boost.org

 #ifndef BOOST_FUNCTION_BASE_HEADER
 #define BOOST_FUNCTION_BASE_HEADER

-#include <string>
 #include <stdexcept>
+#include <string>
 #include <memory>
 #include <new>
 #include <typeinfo>
 #include <boost/config.hpp>
-#include <boost/type_traits.hpp>
+#include <boost/assert.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/composite_traits.hpp>
+#include <boost/type_traits/is_stateless.hpp>
 #include <boost/ref.hpp>
+#include <boost/pending/ct_if.hpp>
+#include <boost/detail/workaround.hpp>
+#ifndef BOOST_NO_SFINAE
+#  include "boost/utility/enable_if.hpp"
+#else
+#  include "boost/mpl/bool.hpp"
+#endif
+#include <boost/function_equal.hpp>

-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406
+// Borrowed from Boost.Python library: determines the cases where we
+// need to use std::type_info::name to compare instead of operator==.
+# if (defined(__GNUC__) && __GNUC__ >= 3) \
+ || defined(_AIX) \
+ || (   defined(__sgi) && defined(__host_mips))
+#  include <cstring>
+#  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) \
+     (std::strcmp((X).name(),(Y).name()) == 0)
+# else
+#  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
+#endif
+
+#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
 #  define BOOST_FUNCTION_TARGET_FIX(x) x
 #else
 #  define BOOST_FUNCTION_TARGET_FIX(x)
 #endif // not MSVC

+#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
+// Work around a compiler bug.
+// boost::python::objects::function has to be seen by the compiler before the
+// boost::function class template.
+namespace boost { namespace python { namespace objects {
+  class function;
+}}}
+#endif
+
+#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                    \
+ || defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
+ || !(BOOST_STRICT_CONFIG || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
+#  define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
+#endif
+
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+#  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)              \
+      typename ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
+                            (::boost::is_integral<Functor>::value)>::value), \
+                           Type>::type
+#else
+// BCC doesn't recognize this depends on a template argument and complains
+// about the use of 'typename'
+#  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)     \
+      ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
+                   (::boost::is_integral<Functor>::value)>::value), \
+                       Type>::type
+#endif
+
+#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
+namespace boost {
+
+#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
+// The library shipping with MIPSpro 7.3.1.3m has a broken allocator<void>
+class function_base;
+
+template<typename Signature,
+         typename Allocator = std::allocator<function_base> >
+class function;
+#else
+template<typename Signature, typename Allocator = std::allocator<void> >
+class function;
+#endif
+
+template<typename Signature, typename Allocator>
+inline void swap(function<Signature, Allocator>& f1,
+                 function<Signature, Allocator>& f2)
+{
+  f1.swap(f2);
+}
+
+} // end namespace boost
+#endif // have partial specialization
+
 namespace boost {
  namespace detail {
    namespace function {
-      /*
-       * The IF implementation is temporary code. When a Boost metaprogramming
-       * library is introduced, Boost.Function will use it instead. 
-       */
-      namespace intimate {
-        struct SelectThen 
-        {       
-          template<typename Then, typename Else>
-          struct Result
-          {       
-            typedef Then type;
-          };
-        };
- 
-        struct SelectElse
-        {
-          template<typename Then, typename Else>
-          struct Result
-          { 
-            typedef Else type;
-          };
-        };
- 
-        template<bool Condition>
-        struct Selector
-        {
-          typedef SelectThen type;
-        };
- 
-        template<>
-        struct Selector<false>
-        {
-          typedef SelectElse type;
-        };
-      } // end namespace intimate 
- 
-      template<bool Condition, typename Then, typename Else>
-      struct IF
-      {
-        typedef typename intimate::Selector<Condition>::type select;
-        typedef typename select::template Result<Then,Else>::type type;
-      };
-
      /**
       * A union of a function pointer and a void pointer. This is necessary
-       * because 5.2.10/6 allows reinterpret_cast<> to safely cast between 
+       * because 5.2.10/6 allows reinterpret_cast<> to safely cast between
       * function pointer types and 5.2.9/10 allows static_cast<> to safely
       * cast between a void pointer and an object pointer. But it is not legal
       * to cast between a function pointer and a void* (in either direction),
       * so function requires a union of the two. */
-      union any_pointer 
+      union any_pointer
      {
        void* obj_ptr;
        const void* const_obj_ptr;
        void (*func_ptr)();
-
-        explicit any_pointer(void* p) : obj_ptr(p) {}
-        explicit any_pointer(const void* p) : const_obj_ptr(p) {}
-        explicit any_pointer(void (*p)()) : func_ptr(p) {}
+        char data[1];
      };

+      inline any_pointer make_any_pointer(void* o)
+      {
+        any_pointer p;
+        p.obj_ptr = o;
+        return p;
+      }
+
+      inline any_pointer make_any_pointer(const void* o)
+      {
+        any_pointer p;
+        p.const_obj_ptr = o;
+        return p;
+      }
+
+      inline any_pointer make_any_pointer(void (*f)())
+      {
+        any_pointer p;
+        p.func_ptr = f;
+        return p;
+      }
+
      /**
       * The unusable class is a placeholder for unused function arguments
       * It is also completely unusable except that it constructable from
       * anything. This helps compilers without partial specialization to
       * handle Boost.Function objects returning void.
       */
-      struct unusable 
+      struct unusable
      {
        unusable() {}
        template<typename T> unusable(const T&) {}
@ -109,20 +155,21 @@ namespace boost {

      /* Determine the return type. This supports compilers that do not support
       * void returns or partial specialization by silently changing the return
-       * type to "unusable". 
+       * type to "unusable".
       */
      template<typename T> struct function_return_type { typedef T type; };

-      template<> 
-      struct function_return_type<void> 
+      template<>
+      struct function_return_type<void>
      {
        typedef unusable type;
      };

      // The operation type to perform on the given functor/function pointer
-      enum functor_manager_operation_type { 
-        clone_functor_tag, 
-        destroy_functor_tag
+      enum functor_manager_operation_type {
+        clone_functor_tag,
+        destroy_functor_tag,
+        check_functor_type_tag
      };

      // Tags used to decide between different types of functions
@ -135,38 +182,55 @@ namespace boost {
      template<typename F>
      class get_function_tag
      {
-        typedef typename IF<(is_pointer<F>::value),
+        typedef typename ct_if<(is_pointer<F>::value),
                            function_ptr_tag,
                            function_obj_tag>::type ptr_or_obj_tag;

-        typedef typename IF<(is_member_pointer<F>::value),
+        typedef typename ct_if<(is_member_pointer<F>::value),
                            member_ptr_tag,
                            ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;

-        typedef typename IF<(is_reference_wrapper<F>::value),
+        typedef typename ct_if<(is_reference_wrapper<F>::value),
                             function_obj_ref_tag,
                             ptr_or_obj_or_mem_tag>::type or_ref_tag;

      public:
-        typedef typename IF<(is_stateless<F>::value),
+        typedef typename ct_if<(is_stateless<F>::value),
                            stateless_function_obj_tag,
                            or_ref_tag>::type type;
      };

      // The trivial manager does nothing but return the same pointer (if we
      // are cloning) or return the null pointer (if we are deleting).
-      inline any_pointer trivial_manager(any_pointer f, 
-                                  functor_manager_operation_type op)
+      template<typename F>
+      struct trivial_manager
      {
-        if (op == clone_functor_tag)
-          return f;
-        else
-          return any_pointer(reinterpret_cast<void*>(0));
-      }
+        static inline any_pointer
+        get(any_pointer f, functor_manager_operation_type op)
+        {
+          switch (op) {
+          case clone_functor_tag: return f;
+
+          case destroy_functor_tag:
+            return make_any_pointer(reinterpret_cast<void*>(0));
+
+          case check_functor_type_tag:
+            {
+              std::type_info* t = static_cast<std::type_info*>(f.obj_ptr);
+              return BOOST_FUNCTION_COMPARE_TYPE_ID(typeid(F), *t)?
+                f
+                : make_any_pointer(reinterpret_cast<void*>(0));
+            }
+          }
+
+          // Clears up a warning with GCC 3.2.3
+          return make_any_pointer(reinterpret_cast<void*>(0));
+        }
+      };

      /**
       * The functor_manager class contains a static function "manage" which
-       * can clone or destroy the given function/function object pointer. 
+       * can clone or destroy the given function/function object pointer.
       */
      template<typename Functor, typename Allocator>
      struct functor_manager
@ -176,24 +240,25 @@ namespace boost {

        // For function pointers, the manager is trivial
        static inline any_pointer
-        manager(any_pointer function_ptr, functor_manager_operation_type op,
+        manager(any_pointer function_ptr,
+                functor_manager_operation_type op,
                function_ptr_tag)
        {
          if (op == clone_functor_tag)
            return function_ptr;
          else
-            return any_pointer(static_cast<void (*)()>(0));
+            return make_any_pointer(static_cast<void (*)()>(0));
        }

-        // For function object pointers, we clone the pointer to each 
+        // For function object pointers, we clone the pointer to each
        // function has its own version.
        static inline any_pointer
-        manager(any_pointer function_obj_ptr, 
+        manager(any_pointer function_obj_ptr,
                functor_manager_operation_type op,
                function_obj_tag)
        {
 #ifndef BOOST_NO_STD_ALLOCATOR
-        typedef typename Allocator::template rebind<functor_type>::other 
+        typedef typename Allocator::template rebind<functor_type>::other
          allocator_type;
        typedef typename allocator_type::pointer pointer_type;
 #else
@ -205,7 +270,7 @@ namespace boost {
 #  endif // BOOST_NO_STD_ALLOCATOR

          if (op == clone_functor_tag) {
-            functor_type* f = 
+            functor_type* f =
              static_cast<functor_type*>(function_obj_ptr.obj_ptr);

            // Clone the functor
@ -218,11 +283,11 @@ namespace boost {
 #  else
            functor_type* new_f = new functor_type(*f);
 #  endif // BOOST_NO_STD_ALLOCATOR
-            return any_pointer(static_cast<void*>(new_f));
+            return make_any_pointer(static_cast<void*>(new_f));
          }
          else {
            /* Cast from the void pointer to the functor pointer type */
-            functor_type* f = 
+            functor_type* f =
              reinterpret_cast<functor_type*>(function_obj_ptr.obj_ptr);

 #  ifndef BOOST_NO_STD_ALLOCATOR
@ -237,7 +302,7 @@ namespace boost {
            delete f;
 #  endif // BOOST_NO_STD_ALLOCATOR

-            return any_pointer(static_cast<void*>(0));
+            return make_any_pointer(static_cast<void*>(0));
          }
        }
      public:
@ -246,199 +311,388 @@ namespace boost {
        static any_pointer
        manage(any_pointer functor_ptr, functor_manager_operation_type op)
        {
-          typedef typename get_function_tag<functor_type>::type tag_type;
-          return manager(functor_ptr, op, tag_type());
+          if (op == check_functor_type_tag) {
+            std::type_info* type =
+              static_cast<std::type_info*>(functor_ptr.obj_ptr);
+            return (BOOST_FUNCTION_COMPARE_TYPE_ID(typeid(Functor), *type)?
+                    functor_ptr
+                    : make_any_pointer(reinterpret_cast<void*>(0)));
+          }
+          else {
+            typedef typename get_function_tag<functor_type>::type tag_type;
+            return manager(functor_ptr, op, tag_type());
+          }
        }
      };

-      // value=1 if the given type is not "unusable"
-      template<typename T>
-      struct count_if_used
-      {
-        BOOST_STATIC_CONSTANT(int, value = 1);
-      };
-    
-      // value=0 for unusable types
-      template<>
-      struct count_if_used<unusable>
-      {
-        BOOST_STATIC_CONSTANT(int, value = 0);
-      };
-    
-      // Count the number of arguments (from the given set) which are not 
-      // "unusable" (therefore, count those arguments that are used).
-      template<typename T1, typename T2, typename T3, typename T4, 
-               typename T5, typename T6, typename T7, typename T8, 
-               typename T9, typename T10>
-      struct count_used_args
-      {
-        BOOST_STATIC_CONSTANT(int, value = 
-                              (count_if_used<T1>::value + 
-                               count_if_used<T2>::value +
-                               count_if_used<T3>::value + 
-                               count_if_used<T4>::value +
-                               count_if_used<T5>::value + 
-                               count_if_used<T6>::value +
-                               count_if_used<T7>::value + 
-                               count_if_used<T8>::value +
-                               count_if_used<T9>::value +
-                               count_if_used<T10>::value));
-      };
+      // A type that is only used for comparisons against zero
+      struct useless_clear_type {};
+
+#ifdef BOOST_NO_SFINAE
+      // These routines perform comparisons between a Boost.Function
+      // object and an arbitrary function object (when the last
+      // parameter is mpl::bool_<false>) or against zero (when the
+      // last parameter is mpl::bool_<true>). They are only necessary
+      // for compilers that don't support SFINAE.
+      template<typename Function, typename Functor>
+        bool
+        compare_equal(const Function& f, const Functor&, int, mpl::bool_<true>)
+        { return f.empty(); }
+
+      template<typename Function, typename Functor>
+        bool
+        compare_not_equal(const Function& f, const Functor&, int,
+                          mpl::bool_<true>)
+        { return !f.empty(); }
+
+      template<typename Function, typename Functor>
+        bool
+        compare_equal(const Function& f, const Functor& g, long,
+                      mpl::bool_<false>)
+        {
+          if (const Functor* fp = f.template target<Functor>())
+            return function_equal(*fp, g);
+          else return false;
+        }
+
+      template<typename Function, typename Functor>
+        bool
+        compare_equal(const Function& f, const reference_wrapper<Functor>& g,
+                      int, mpl::bool_<false>)
+        {
+          if (const Functor* fp = f.template target<Functor>())
+            return fp == g.get_pointer();
+          else return false;
+        }
+
+      template<typename Function, typename Functor>
+        bool
+        compare_not_equal(const Function& f, const Functor& g, long,
+                          mpl::bool_<false>)
+        {
+          if (const Functor* fp = f.template target<Functor>())
+            return !function_equal(*fp, g);
+          else return true;
+        }
+
+      template<typename Function, typename Functor>
+        bool
+        compare_not_equal(const Function& f,
+                          const reference_wrapper<Functor>& g, int,
+                          mpl::bool_<false>)
+        {
+          if (const Functor* fp = f.template target<Functor>())
+            return fp != g.get_pointer();
+          else return true;
+        }
+#endif // BOOST_NO_SFINAE
    } // end namespace function
  } // end namespace detail

-  /**
-   * The function_base class contains the basic elements needed for the
-   * function1, function2, function3, etc. classes. It is common to all
-   * functions (and as such can be used to tell if we have one of the
-   * functionN objects). 
-   */
-  class function_base 
+/**
+ * The function_base class contains the basic elements needed for the
+ * function1, function2, function3, etc. classes. It is common to all
+ * functions (and as such can be used to tell if we have one of the
+ * functionN objects).
+ */
+class function_base
+{
+public:
+  function_base() : manager(0)
  {
-  public:
-    function_base() : manager(0), functor(static_cast<void*>(0)) {}
-    
-    // Is this function empty?
-    bool empty() const { return !manager; }
-    
-  public: // should be protected, but GCC 2.95.3 will fail to allow access
-    detail::function::any_pointer (*manager)(
-                           detail::function::any_pointer, 
-                           detail::function::functor_manager_operation_type);
-    detail::function::any_pointer functor;
+    functor.obj_ptr = 0;
+  }

-  private:
-    struct dummy {
-      void nonnull() {};
-    };
+  // Is this function empty?
+  bool empty() const { return !manager; }

-    typedef void (dummy::*safe_bool)();
+  template<typename Functor>
+    Functor* target()
+    {
+      if (!manager) return 0;

-  public:
-    operator safe_bool () const 
-      { return (this->empty())? 0 : &dummy::nonnull; }
-
-    safe_bool operator!() const
-      { return (this->empty())? &dummy::nonnull : 0; }
-  };
-
-  /* Poison comparison between Boost.Function objects (because it is 
-   * meaningless). The comparisons would otherwise be allowed because of the
-   * conversion required to allow syntax such as:
-   *   boost::function<int, int> f;
-   *   if (f) { f(5); }
-   */
-  void operator==(const function_base&, const function_base&);
-  void operator!=(const function_base&, const function_base&);
-
-  namespace detail {
-    namespace function {
-      /**
-       * Determine if the given target is empty.
-       */
-
-      // Fallback - assume target is not empty
-      inline bool has_empty_target(...) 
-      { 
-        return false; 
-      }
-    
-      // If the target is a 'function', query the empty() method
-      inline bool has_empty_target(const function_base* af) 
-      { 
-        return af->empty();
+      detail::function::any_pointer result =
+        manager(detail::function::make_any_pointer(&typeid(Functor)),
+                detail::function::check_functor_type_tag);
+      if (!result.obj_ptr) return 0;
+      else {
+        typedef typename detail::function::get_function_tag<Functor>::type tag;
+        return get_functor_pointer<Functor>(tag(), 0);
      }
+    }

-      // If the target is a 'function', query the empty() method
-      inline bool has_empty_target(const function_base& af) 
-      { 
-        return af.empty();
-      }
-    
-      // A function pointer is empty if it is null
-      template<typename R>
-      inline bool has_empty_target(R (*f)())
-      {
-        return f == 0;
-      }
-    
-      template<typename R, typename T1>
-      inline bool has_empty_target(R (*f)(T1))
-      {
-        return f == 0;
-      }
-    
-      template<typename R, typename T1, typename T2>
-      inline bool has_empty_target(R (*f)(T1, T2))
-      {
-        return f == 0;
-      }
-    
-      template<typename R, typename T1, typename T2, typename T3>
-      inline bool has_empty_target(R (*f)(T1, T2, T3))
-      {
-        return f == 0;
-      }
+  template<typename Functor>

-      template<typename R, typename T1, typename T2, typename T3, typename T4>
-      inline bool has_empty_target(R (*f)(T1, T2, T3, T4))
-      {
-        return f == 0;
+#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+    const Functor* target( Functor * = 0 ) const
+#else
+    const Functor* target() const
+#endif
+    {
+      if (!manager) return 0;
+
+      detail::function::any_pointer result =
+        manager(detail::function::make_any_pointer(&typeid(Functor)),
+                detail::function::check_functor_type_tag);
+      if (!result.obj_ptr) return 0;
+      else {
+        typedef typename detail::function::get_function_tag<Functor>::type tag;
+
+#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+        return get_functor_pointer(tag(), 0, (Functor*)0);
+#else
+        return get_functor_pointer<Functor>(tag(), 0);
+#endif
      }
+    }

-      template<typename R, typename T1, typename T2, typename T3, typename T4, 
-               typename T5>
-      inline bool has_empty_target(R (*f)(T1, T2, T3, T4, T5))
-      {
-        return f == 0;
+  template<typename F>
+    bool contains(const F& f) const
+    {
+#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+      if (const F* fp = this->target( (F*)0 )) {
+#else
+      if (const F* fp = this->template target<F>()) {
+#endif
+        return function_equal(*fp, f);
+      } else {
+        return false;
      }
+    }

-      template<typename R, typename T1, typename T2, typename T3, typename T4, 
-               typename T5, typename T6>
-      inline bool has_empty_target(R (*f)(T1, T2, T3, T4, T5, T6))
-      {
-        return f == 0;
-      }
+#if defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3
+  // GCC 3.3 and newer cannot copy with the global operator==, due to
+  // problems with instantiation of function return types before it
+  // has been verified that the argument types match up.
+  template<typename Functor>
+    BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+    operator==(Functor g) const
+    {
+      if (const Functor* fp = target<Functor>())
+        return function_equal(*fp, g);
+      else return false;
+    }

-      template<typename R, typename T1, typename T2, typename T3, typename T4, 
-               typename T5, typename T6, typename T7>
-      inline bool has_empty_target(R (*f)(T1, T2, T3, T4, T5, T6, T7))
-      {
-        return f == 0;
-      }
+  template<typename Functor>
+    BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+    operator!=(Functor g) const
+    {
+      if (const Functor* fp = target<Functor>())
+        return !function_equal(*fp, g);
+      else return true;
+    }
+#endif

-      template<typename R, typename T1, typename T2, typename T3, typename T4, 
-               typename T5, typename T6, typename T7, typename T8>
-      inline bool has_empty_target(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8))
-      {
-        return f == 0;
-      }
+public: // should be protected, but GCC 2.95.3 will fail to allow access
+  detail::function::any_pointer (*manager)(
+    detail::function::any_pointer,
+    detail::function::functor_manager_operation_type);
+  detail::function::any_pointer functor;

-      template<typename R, typename T1, typename T2, typename T3, typename T4, 
-               typename T5, typename T6, typename T7, typename T8, typename T9>
-      inline bool has_empty_target(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8, T9))
-      {
-        return f == 0;
-      }
-    } // end namespace function
-  } // end namespace detail
+private:
+  template<typename Functor>
+#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+    Functor* get_functor_pointer(detail::function::function_ptr_tag, int, Functor * = 0)
+#else
+    Functor* get_functor_pointer(detail::function::function_ptr_tag, int)
+#endif
+    { return reinterpret_cast<Functor*>(&functor.func_ptr); }

-  // The default function policy is to do nothing before and after the call.
-  struct empty_function_policy
-  {
-    inline void precall(const function_base*) {}
-    inline void postcall(const function_base*) {}
-  };
+  template<typename Functor, typename Tag>
+#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+    Functor* get_functor_pointer(Tag, long, Functor * = 0)
+#else
+    Functor* get_functor_pointer(Tag, long)
+#endif
+    { return static_cast<Functor*>(functor.obj_ptr); }

-  // The default function mixin does nothing. The assignment and copy-construction operators
-  // are all defined because MSVC defines broken versions.
-  struct empty_function_mixin {
-    empty_function_mixin() {};
-    empty_function_mixin(const empty_function_mixin&) {};
+  template<typename Functor>
+    const Functor*
+#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+    get_functor_pointer(detail::function::function_ptr_tag, int, Functor * = 0) const
+#else
+    get_functor_pointer(detail::function::function_ptr_tag, int) const
+#endif
+    { return reinterpret_cast<const Functor*>(&functor.func_ptr); }

-    empty_function_mixin& operator=(const empty_function_mixin&) 
-    {return *this; }
-  };
+  template<typename Functor, typename Tag>
+#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+    const Functor* get_functor_pointer(Tag, long, Functor * = 0) const
+#else
+    const Functor* get_functor_pointer(Tag, long) const
+#endif
+    { return static_cast<const Functor*>(functor.const_obj_ptr); }
+};
+
+/**
+ * The bad_function_call exception class is thrown when a boost::function
+ * object is invoked
+ */
+class bad_function_call : public std::runtime_error
+{
+public:
+  bad_function_call() : std::runtime_error("call to empty boost::function") {}
+};
+
+#ifndef BOOST_NO_SFINAE
+inline bool operator==(const function_base& f,
+                       detail::function::useless_clear_type*)
+{
+  return f.empty();
 }

+inline bool operator!=(const function_base& f,
+                       detail::function::useless_clear_type*)
+{
+  return !f.empty();
+}
+
+inline bool operator==(detail::function::useless_clear_type*,
+                       const function_base& f)
+{
+  return f.empty();
+}
+
+inline bool operator!=(detail::function::useless_clear_type*,
+                       const function_base& f)
+{
+  return !f.empty();
+}
+#endif
+
+#ifdef BOOST_NO_SFINAE
+// Comparisons between boost::function objects and arbitrary function objects
+template<typename Functor>
+  inline bool operator==(const function_base& f, Functor g)
+  {
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    return detail::function::compare_equal(f, g, 0, integral());
+  }
+
+template<typename Functor>
+  inline bool operator==(Functor g, const function_base& f)
+  {
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    return detail::function::compare_equal(f, g, 0, integral());
+  }
+
+template<typename Functor>
+  inline bool operator!=(const function_base& f, Functor g)
+  {
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    return detail::function::compare_not_equal(f, g, 0, integral());
+  }
+
+template<typename Functor>
+  inline bool operator!=(Functor g, const function_base& f)
+  {
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    return detail::function::compare_not_equal(f, g, 0, integral());
+  }
+#else
+
+#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
+// Comparisons between boost::function objects and arbitrary function
+// objects. GCC 3.3 and before has an obnoxious bug that prevents this
+// from working.
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator==(const function_base& f, Functor g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return function_equal(*fp, g);
+    else return false;
+  }
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator==(Functor g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return function_equal(g, *fp);
+    else return false;
+  }
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator!=(const function_base& f, Functor g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return !function_equal(*fp, g);
+    else return true;
+  }
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator!=(Functor g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return !function_equal(g, *fp);
+    else return true;
+  }
+#  endif
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator==(const function_base& f, reference_wrapper<Functor> g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return fp == g.get_pointer();
+    else return false;
+  }
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator==(reference_wrapper<Functor> g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return g.get_pointer() == fp;
+    else return false;
+  }
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator!=(const function_base& f, reference_wrapper<Functor> g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return fp != g.get_pointer();
+    else return true;
+  }
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator!=(reference_wrapper<Functor> g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return g.get_pointer() != fp;
+    else return true;
+  }
+
+#endif // Compiler supporting SFINAE
+
+namespace detail {
+  namespace function {
+    inline bool has_empty_target(const function_base* f)
+    {
+      return f->empty();
+    }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
+    inline bool has_empty_target(const void*)
+    {
+      return false;
+    }
+#else
+    inline bool has_empty_target(...)
+    {
+      return false;
+    }
+#endif
+  } // end namespace function
+} // end namespace detail
+} // end namespace boost
+
+#undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
+#undef BOOST_FUNCTION_COMPARE_TYPE_ID
+
 #endif // BOOST_FUNCTION_BASE_HEADER
--- a/include/boost/function/function_template.hpp
+++ b/include/boost/function/function_template.hpp
@ -1,29 +1,30 @@
 // Boost.Function library

-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
+//  Copyright Douglas Gregor 2001-2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)

 // For more information, see http://www.boost.org

 // Note: this header is a header template and must NOT have multiple-inclusion
-// protection. 
+// protection.
+#include <boost/function/detail/prologue.hpp>

-#ifndef BOOST_FUNCTION_FUNCTION_TEMPLATE_HPP
-#define BOOST_FUNCTION_FUNCTION_TEMPLATE_HPP
-#  include <cassert>
-#  include <algorithm>
-#  include <boost/config.hpp>
-#  include <boost/function/function_base.hpp>
-#  include <boost/mem_fn.hpp>
-#endif // BOOST_FUNCTION_FUNCTION_TEMPLATE_HPP
+#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
+
+#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
+
+#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)
+
+#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
+
+#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)
+
+#define BOOST_FUNCTION_ARG_TYPE(J,I,D) \
+  typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(arg, BOOST_PP_CAT(BOOST_PP_INC(I),_type));
+
+#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)

 // Type of the default allocator
 #ifndef BOOST_NO_STD_ALLOCATOR
@ -34,18 +35,17 @@

 // Comma if nonzero number of arguments
 #if BOOST_FUNCTION_NUM_ARGS == 0
-#  define BOOST_FUNCTION_COMMA 
+#  define BOOST_FUNCTION_COMMA
 #else
 #  define BOOST_FUNCTION_COMMA ,
 #endif // BOOST_FUNCTION_NUM_ARGS > 0

 // Class names used in this version of the code
 #define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_BASE BOOST_JOIN(function_base,BOOST_FUNCTION_NUM_ARGS)
 #define BOOST_FUNCTION_FUNCTION_INVOKER \
  BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)
 #define BOOST_FUNCTION_VOID_FUNCTION_INVOKER \
-  BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS) 
+  BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)
 #define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER \
  BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
 #define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER \
@ -61,6 +61,14 @@
 #define BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER \
  BOOST_JOIN(get_stateless_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

+#ifndef BOOST_NO_VOID_RETURNS
+#  define BOOST_FUNCTION_VOID_RETURN_TYPE void
+#  define BOOST_FUNCTION_RETURN(X) X
+#else
+#  define BOOST_FUNCTION_VOID_RETURN_TYPE boost::detail::function::unusable
+#  define BOOST_FUNCTION_RETURN(X) X; return BOOST_FUNCTION_VOID_RETURN_TYPE ()
+#endif
+
 namespace boost {
  namespace detail {
    namespace function {
@ -86,13 +94,13 @@ namespace boost {
        >
      struct BOOST_FUNCTION_VOID_FUNCTION_INVOKER
      {
-        static unusable invoke(any_pointer function_ptr BOOST_FUNCTION_COMMA
-                               BOOST_FUNCTION_PARMS)
+        static BOOST_FUNCTION_VOID_RETURN_TYPE
+        invoke(any_pointer function_ptr BOOST_FUNCTION_COMMA
+               BOOST_FUNCTION_PARMS)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
-          f(BOOST_FUNCTION_ARGS);
-          return unusable();
+          BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
        }
      };

@ -119,14 +127,13 @@ namespace boost {
      >
      struct BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
      {
-        static unusable invoke(any_pointer function_obj_ptr 
-                               BOOST_FUNCTION_COMMA
-                               BOOST_FUNCTION_PARMS)
+        static BOOST_FUNCTION_VOID_RETURN_TYPE
+        invoke(any_pointer function_obj_ptr BOOST_FUNCTION_COMMA
+               BOOST_FUNCTION_PARMS)

        {
          FunctionObj* f = (FunctionObj*)(function_obj_ptr.obj_ptr);
-          (*f)(BOOST_FUNCTION_ARGS);
-          return unusable();
+          BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
        }
      };

@ -151,13 +158,12 @@ namespace boost {
      >
      struct BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER
      {
-        static unusable invoke(any_pointer BOOST_FUNCTION_COMMA 
-                               BOOST_FUNCTION_PARMS)
+        static BOOST_FUNCTION_VOID_RETURN_TYPE
+        invoke(any_pointer BOOST_FUNCTION_COMMA BOOST_FUNCTION_PARMS)

        {
          FunctionObj f = FunctionObj();
-          f(BOOST_FUNCTION_ARGS);
-          return unusable();
+          BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
        }
      };

@ -168,7 +174,7 @@ namespace boost {
      >
      struct BOOST_FUNCTION_GET_FUNCTION_INVOKER
      {
-        typedef typename IF<(is_void<R>::value),
+        typedef typename ct_if<(is_void<R>::value),
                            BOOST_FUNCTION_VOID_FUNCTION_INVOKER<
                            FunctionPtr,
                            R BOOST_FUNCTION_COMMA
@ -189,7 +195,7 @@ namespace boost {
       >
      struct BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
      {
-        typedef typename IF<(is_void<R>::value),
+        typedef typename ct_if<(is_void<R>::value),
                            BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<
                            FunctionObj,
                            R BOOST_FUNCTION_COMMA
@ -210,7 +216,7 @@ namespace boost {
       >
      struct BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER
      {
-        typedef typename IF<(is_void<R>::value),
+        typedef typename ct_if<(is_void<R>::value),
                            BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER<
                            FunctionObj,
                            R BOOST_FUNCTION_COMMA
@ -230,18 +236,31 @@ namespace boost {
  template<
    typename R BOOST_FUNCTION_COMMA
    BOOST_FUNCTION_TEMPLATE_PARMS,
-    typename Policy    = empty_function_policy,
-    typename Mixin     = empty_function_mixin,
    typename Allocator = BOOST_FUNCTION_DEFAULT_ALLOCATOR
  >
-  class BOOST_FUNCTION_FUNCTION : public function_base, public Mixin
+  class BOOST_FUNCTION_FUNCTION : public function_base
  {
-    typedef typename detail::function::function_return_type<R>::type 
-      internal_result_type;
+  public:
+#ifndef BOOST_NO_VOID_RETURNS
+    typedef R         result_type;
+#else
+    typedef  typename boost::detail::function::function_return_type<R>::type
+      result_type;
+#endif // BOOST_NO_VOID_RETURNS
+
+  private:
+    struct clear_type {};

  public:
    BOOST_STATIC_CONSTANT(int, args = BOOST_FUNCTION_NUM_ARGS);
-    
+
+    // add signature for boost::lambda
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+
 #if BOOST_FUNCTION_NUM_ARGS == 1
    typedef T0 argument_type;
 #elif BOOST_FUNCTION_NUM_ARGS == 2
@ -249,84 +268,98 @@ namespace boost {
    typedef T1 second_argument_type;
 #endif

-#ifndef BOOST_NO_VOID_RETURNS
-    typedef R         result_type;
-#else
-    typedef internal_result_type result_type;
-#endif // BOOST_NO_VOID_RETURNS
-    typedef Policy    policy_type;
-    typedef Mixin     mixin_type;
+    BOOST_STATIC_CONSTANT(int, arity = BOOST_FUNCTION_NUM_ARGS);
+    BOOST_FUNCTION_ARG_TYPES
+
    typedef Allocator allocator_type;
    typedef BOOST_FUNCTION_FUNCTION self_type;

-    BOOST_FUNCTION_FUNCTION() : function_base(), Mixin(), invoker(0) {}
-
-    explicit BOOST_FUNCTION_FUNCTION(const Mixin& m) : 
-      function_base(), Mixin(m), invoker(0) 
-    {
-    }
+    BOOST_FUNCTION_FUNCTION() : function_base()
+                              , invoker(0) {}

    // MSVC chokes if the following two constructors are collapsed into
    // one with a default parameter.
    template<typename Functor>
-    BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f) :
-      function_base(), Mixin(), invoker(0)
+    BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f
+#ifndef BOOST_NO_SFINAE
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+#endif // BOOST_NO_SFINAE
+                            ) :
+      function_base(),
+      invoker(0)
    {
      this->assign_to(f);
    }

-    template<typename Functor>
-    BOOST_FUNCTION_FUNCTION(Functor f, const Mixin& m) :
-      function_base(), Mixin(m), invoker(0)
+#ifndef BOOST_NO_SFINAE
+    BOOST_FUNCTION_FUNCTION(clear_type*) : function_base(), invoker(0) {}
+#else
+    BOOST_FUNCTION_FUNCTION(int zero) : function_base(), invoker(0)
    {
-      this->assign_to(f);
+      BOOST_ASSERT(zero == 0);
    }
+#endif

    BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) :
-      function_base(), Mixin(static_cast<const Mixin&>(f)), invoker(0)
+      function_base(),
+      invoker(0)
    {
      this->assign_to_own(f);
    }

    ~BOOST_FUNCTION_FUNCTION() { clear(); }

+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+    // MSVC 6.0 and prior require all definitions to be inline, but
+    // these definitions can become very costly.
    result_type operator()(BOOST_FUNCTION_PARMS) const
    {
-      assert(!this->empty());
+      if (this->empty())
+        boost::throw_exception(bad_function_call());

-      policy_type policy;
-      policy.precall(this);
-
-      internal_result_type result = invoker(function_base::functor 
-                                            BOOST_FUNCTION_COMMA
-                                            BOOST_FUNCTION_ARGS);
-
-      policy.postcall(this);
-#ifndef BOOST_NO_VOID_RETURNS
-      return static_cast<result_type>(result);
-#else
-      return result;
-#endif // BOOST_NO_VOID_RETURNS
+      return invoker(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
    }
+#else
+    result_type operator()(BOOST_FUNCTION_PARMS) const;
+#endif

    // The distinction between when to use BOOST_FUNCTION_FUNCTION and
    // when to use self_type is obnoxious. MSVC cannot handle self_type as
    // the return type of these assignment operators, but Borland C++ cannot
-    // handle BOOST_FUNCTION_FUNCTION as the type of the temporary to 
+    // handle BOOST_FUNCTION_FUNCTION as the type of the temporary to
    // construct.
    template<typename Functor>
-    BOOST_FUNCTION_FUNCTION& 
+#ifndef BOOST_NO_SFINAE
+    typename enable_if_c<
+               (boost::type_traits::ice_not<
+                 (is_integral<Functor>::value)>::value),
+               BOOST_FUNCTION_FUNCTION&>::type
+#else
+    BOOST_FUNCTION_FUNCTION&
+#endif
    operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
    {
-      self_type(f, static_cast<const Mixin&>(*this)).swap(*this);
+      self_type(f).swap(*this);
      return *this;
    }

-    template<typename Functor>
-    void set(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
+#ifndef BOOST_NO_SFINAE
+    BOOST_FUNCTION_FUNCTION& operator=(clear_type*)
    {
-      self_type(f, static_cast<const Mixin&>(*this)).swap(*this);
+      this->clear();
+      return *this;
    }
+#else
+    BOOST_FUNCTION_FUNCTION& operator=(int zero)
+    {
+      BOOST_ASSERT(zero == 0);
+      this->clear();
+      return *this;
+    }
+#endif

    // Assignment from another BOOST_FUNCTION_FUNCTION
    BOOST_FUNCTION_FUNCTION& operator=(const BOOST_FUNCTION_FUNCTION& f)
@ -338,179 +371,327 @@ namespace boost {
      return *this;
    }

-    // Assignment from another BOOST_FUNCTION_FUNCTION
-    void set(const BOOST_FUNCTION_FUNCTION& f)
-    {
-      if (&f == this)
-        return;
-
-      self_type(f).swap(*this);
-    }
-
    void swap(BOOST_FUNCTION_FUNCTION& other)
    {
      if (&other == this)
        return;

-      std::swap(function_base::manager, other.manager);
-      std::swap(function_base::functor, other.functor);
+      std::swap(this->manager, other.manager);
+      std::swap(this->functor, other.functor);
      std::swap(invoker, other.invoker);
-      std::swap(static_cast<Mixin&>(*this), static_cast<Mixin&>(other));
    }

    // Clear out a target, if there is one
    void clear()
    {
-      if (function_base::manager)
-        function_base::functor = function_base::manager(function_base::functor, detail::function::destroy_functor_tag);
-    
-      function_base::manager = 0;
+      if (this->manager) {
+        function_base::functor =
+          this->manager(this->functor, 
+                        boost::detail::function::destroy_functor_tag);
+      }
+
+      this->manager = 0;
      invoker = 0;
    }

+#if (defined __SUNPRO_CC) && (__SUNPRO_CC <= 0x530) && !(defined BOOST_NO_COMPILER_CONFIG)
+    // Sun C++ 5.3 can't handle the safe_bool idiom, so don't use it
+    operator bool () const { return !this->empty(); }
+#else
+  private:
+    struct dummy {
+      void nonnull() {};
+    };
+
+    typedef void (dummy::*safe_bool)();
+
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+
+    bool operator!() const
+      { return this->empty(); }
+#endif
+
  private:
    void assign_to_own(const BOOST_FUNCTION_FUNCTION& f)
    {
      if (!f.empty()) {
        invoker = f.invoker;
-        function_base::manager = f.manager;
-        function_base::functor = f.manager(f.functor, detail::function::clone_functor_tag);
-      }          
+        this->manager = f.manager;
+        this->functor =
+          f.manager(f.functor, boost::detail::function::clone_functor_tag);
+      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
-      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      this->assign_to(f, tag());
    }

    template<typename FunctionPtr>
-    void assign_to(FunctionPtr f, detail::function::function_ptr_tag)
+    void assign_to(FunctionPtr f, boost::detail::function::function_ptr_tag)
    {
      clear();
-        
+
      if (f) {
-        typedef typename detail::function::BOOST_FUNCTION_GET_FUNCTION_INVOKER<
+        typedef typename boost::detail::function::BOOST_FUNCTION_GET_FUNCTION_INVOKER<
                           FunctionPtr,
                           R BOOST_FUNCTION_COMMA
                           BOOST_FUNCTION_TEMPLATE_ARGS
                         >::type
-          invoker_type;
-    
-        invoker = &invoker_type::invoke;
-        function_base::manager = &detail::function::functor_manager<FunctionPtr, 
-                                                     Allocator>::manage;
-        function_base::functor = function_base::manager(detail::function::any_pointer(
+          actual_invoker_type;
+
+        invoker = &actual_invoker_type::invoke;
+        this->manager =
+          &boost::detail::function::functor_manager<FunctionPtr, Allocator>::manage;
+        this->functor =
+          this->manager(boost::detail::function::make_any_pointer(
                            // should be a reinterpret cast, but some compilers
                            // insist on giving cv-qualifiers to free functions
                            (void (*)())(f)
                          ),
-                          detail::function::clone_functor_tag);
+                          boost::detail::function::clone_functor_tag);
      }
-    }  
+    }

 #if BOOST_FUNCTION_NUM_ARGS > 0
    template<typename MemberPtr>
-    void assign_to(MemberPtr f, detail::function::member_ptr_tag)
+    void assign_to(MemberPtr f, boost::detail::function::member_ptr_tag)
    {
      this->assign_to(mem_fn(f));
    }
 #endif // BOOST_FUNCTION_NUM_ARGS > 0
-        
+
    template<typename FunctionObj>
-    void assign_to(FunctionObj f, detail::function::function_obj_tag)
+    void assign_to(FunctionObj f, boost::detail::function::function_obj_tag)
    {
-      if (!detail::function::has_empty_target(&f)) {
-        typedef 
-          typename detail::function::BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
+      if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+        typedef
+          typename boost::detail::function::BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
                                       FunctionObj,
                                       R BOOST_FUNCTION_COMMA
                                       BOOST_FUNCTION_TEMPLATE_ARGS
                                     >::type
-          invoker_type;
-    
-        invoker = &invoker_type::invoke;
-        function_base::manager = &detail::function::functor_manager<FunctionObj, 
-                                                     Allocator>::manage;
-        function_base::functor = 
-          function_base::manager(detail::function::any_pointer(const_cast<FunctionObj*>(&f)),
-                  detail::function::clone_functor_tag);
+          actual_invoker_type;
+
+        invoker = &actual_invoker_type::invoke;
+        this->manager = &boost::detail::function::functor_manager<
+                                    FunctionObj, Allocator>::manage;
+#ifndef BOOST_NO_STD_ALLOCATOR
+        typedef typename Allocator::template rebind<FunctionObj>::other
+          rebound_allocator_type;
+        typedef typename rebound_allocator_type::pointer pointer_type;
+        rebound_allocator_type allocator;
+        pointer_type copy = allocator.allocate(1);
+        allocator.construct(copy, f);
+
+        // Get back to the original pointer type
+        FunctionObj* new_f = static_cast<FunctionObj*>(copy);
+#else
+        FunctionObj* new_f = new FunctionObj(f);
+#endif // BOOST_NO_STD_ALLOCATOR
+        this->functor =
+          boost::detail::function::make_any_pointer(static_cast<void*>(new_f));
      }
    }
-    
+
    template<typename FunctionObj>
-    void assign_to(const reference_wrapper<FunctionObj>& f, 
-                   detail::function::function_obj_ref_tag)
+    void assign_to(const reference_wrapper<FunctionObj>& f,
+                   boost::detail::function::function_obj_ref_tag)
    {
-      if (!detail::function::has_empty_target(&f.get())) {
-        typedef 
-          typename detail::function::BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
+      if (!boost::detail::function::has_empty_target(f.get_pointer())) {
+        typedef
+          typename boost::detail::function::BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
                                       FunctionObj,
                                       R BOOST_FUNCTION_COMMA
                                       BOOST_FUNCTION_TEMPLATE_ARGS
                                     >::type
-          invoker_type;
-    
-        invoker = &invoker_type::invoke;
-        function_base::manager = &detail::function::trivial_manager;
-        function_base::functor = 
-          function_base::manager(detail::function::any_pointer(
-                    const_cast<FunctionObj*>(&f.get())),
-                  detail::function::clone_functor_tag);
+          actual_invoker_type;
+
+        invoker = &actual_invoker_type::invoke;
+        this->manager = &boost::detail::function::trivial_manager<FunctionObj>::get;
+        this->functor =
+          this->manager(
+            boost::detail::function::make_any_pointer(
+              const_cast<FunctionObj*>(f.get_pointer())),
+            boost::detail::function::clone_functor_tag);
      }
    }
-    
+
    template<typename FunctionObj>
-    void assign_to(FunctionObj, detail::function::stateless_function_obj_tag)
+    void assign_to(FunctionObj, boost::detail::function::stateless_function_obj_tag)
    {
-      typedef 
-          typename detail::function::
+      typedef
+          typename boost::detail::function::
                     BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER<
                       FunctionObj,
                       R BOOST_FUNCTION_COMMA
                       BOOST_FUNCTION_TEMPLATE_ARGS
                     >::type
-          invoker_type;
-      invoker = &invoker_type::invoke;
-      function_base::manager = &detail::function::trivial_manager;
-      function_base::functor = detail::function::any_pointer(this);
+          actual_invoker_type;
+      invoker = &actual_invoker_type::invoke;
+      this->manager = &boost::detail::function::trivial_manager<FunctionObj>::get;
+      this->functor = boost::detail::function::make_any_pointer(this);
    }

-    typedef internal_result_type (*invoker_type)(detail::function::any_pointer
-                                                 BOOST_FUNCTION_COMMA
-                                                 BOOST_FUNCTION_TEMPLATE_ARGS);
-    
+    typedef result_type (*invoker_type)(boost::detail::function::any_pointer
+                                        BOOST_FUNCTION_COMMA
+                                        BOOST_FUNCTION_TEMPLATE_ARGS);
+
    invoker_type invoker;
  };

  template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
-           typename Policy, typename Mixin, typename Allocator>
+           typename Allocator>
  inline void swap(BOOST_FUNCTION_FUNCTION<
                     R BOOST_FUNCTION_COMMA
                     BOOST_FUNCTION_TEMPLATE_ARGS ,
-                     Policy,
-                     Mixin,
                     Allocator
                   >& f1,
                   BOOST_FUNCTION_FUNCTION<
-                     R BOOST_FUNCTION_COMMA 
+                     R BOOST_FUNCTION_COMMA
                     BOOST_FUNCTION_TEMPLATE_ARGS,
-                     Policy,
-                     Mixin,
                     Allocator
                   >& f2)
  {
    f1.swap(f2);
  }
-}
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+  template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+           typename Allocator>
+  typename BOOST_FUNCTION_FUNCTION<
+      R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS, 
+      Allocator>::result_type
+   BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS,
+
+                           Allocator>
+  ::operator()(BOOST_FUNCTION_PARMS) const
+  {
+    if (this->empty())
+      boost::throw_exception(bad_function_call());
+    
+    return invoker(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
+  }
+#endif
+
+// Poison comparisons between boost::function objects of the same type.
+template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
+         typename Allocator>
+  void operator==(const BOOST_FUNCTION_FUNCTION<
+                          R BOOST_FUNCTION_COMMA
+                          BOOST_FUNCTION_TEMPLATE_ARGS ,
+                          Allocator>&,
+                  const BOOST_FUNCTION_FUNCTION<
+                          R BOOST_FUNCTION_COMMA
+                          BOOST_FUNCTION_TEMPLATE_ARGS ,
+                  Allocator>&);
+template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
+         typename Allocator>
+  void operator!=(const BOOST_FUNCTION_FUNCTION<
+                          R BOOST_FUNCTION_COMMA
+                          BOOST_FUNCTION_TEMPLATE_ARGS ,
+                          Allocator>&,
+                  const BOOST_FUNCTION_FUNCTION<
+                          R BOOST_FUNCTION_COMMA
+                          BOOST_FUNCTION_TEMPLATE_ARGS ,
+                  Allocator>&);
+
+#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
+
+#if BOOST_FUNCTION_NUM_ARGS == 0
+#define BOOST_FUNCTION_PARTIAL_SPEC R (void)
+#else
+#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))
+#endif
+
+template<typename R BOOST_FUNCTION_COMMA
+         BOOST_FUNCTION_TEMPLATE_PARMS,
+         typename Allocator>
+class function<BOOST_FUNCTION_PARTIAL_SPEC, Allocator>
+  : public BOOST_FUNCTION_FUNCTION<R, BOOST_FUNCTION_TEMPLATE_ARGS
+                                   BOOST_FUNCTION_COMMA Allocator>
+{
+  typedef BOOST_FUNCTION_FUNCTION<R, BOOST_FUNCTION_TEMPLATE_ARGS
+                                  BOOST_FUNCTION_COMMA Allocator> base_type;
+  typedef function self_type;
+
+  struct clear_type {};
+
+public:
+  typedef typename base_type::allocator_type allocator_type;
+
+  function() : base_type() {}
+
+  template<typename Functor>
+  function(Functor f
+#ifndef BOOST_NO_SFINAE
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+#endif
+           ) :
+    base_type(f)
+  {
+  }
+
+#ifndef BOOST_NO_SFINAE
+  function(clear_type*) : base_type() {}
+#endif
+
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+  template<typename Functor>
+#ifndef BOOST_NO_SFINAE
+  typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                         (is_integral<Functor>::value)>::value),
+                      self_type&>::type
+#else
+  self_type&
+#endif
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+#ifndef BOOST_NO_SFINAE
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+#endif
+
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+};
+
+#undef BOOST_FUNCTION_PARTIAL_SPEC
+#endif // have partial specialization
+
+} // end namespace boost

 // Cleanup after ourselves...
 #undef BOOST_FUNCTION_DEFAULT_ALLOCATOR
 #undef BOOST_FUNCTION_COMMA
 #undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
 #undef BOOST_FUNCTION_FUNCTION_INVOKER
 #undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
 #undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
@ -521,4 +702,12 @@ namespace boost {
 #undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
 #undef BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER
 #undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
-
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_PARM
+#undef BOOST_FUNCTION_ARGS
+#undef BOOST_FUNCTION_ARG_TYPE
+#undef BOOST_FUNCTION_ARG_TYPES
+#undef BOOST_FUNCTION_VOID_RETURN_TYPE
+#undef BOOST_FUNCTION_RETURN
--- a/include/boost/function/gen_function_N.pl
+++ b/include/boost/function/gen_function_N.pl
@ -2,16 +2,10 @@
 #
 # Boost.Function library
 #
-# Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-#
-# Permission to copy, use, sell and distribute this software is granted
-# provided this copyright notice appears in all copies.
-# Permission to modify the code and to distribute modified code is granted
-# provided this copyright notice appears in all copies, and a notice
-# that the code was modified is included with the copyright notice.
-#
-# This software is provided "as is" without express or implied warranty,
-# and with no claim as to its suitability for any purpose.
+# Copyright Douglas Gregor 2001-2003. Use, modification and
+# distribution is subject to the Boost Software License, Version
+# 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
 #
 # For more information, see http://www.boost.org
 use English;
@ -25,87 +19,8 @@ if ($#ARGV < 0) {
 $totalNumArgs = $ARGV[0];
 for ($numArgs = 0; $numArgs <= $totalNumArgs; ++$numArgs) {
  open OUT, ">function$numArgs.hpp";
-  print OUT "// Boost.Function library\n";
-  print OUT "//\n";
-  print OUT "// Copyright (C) 2001 Doug Gregor (gregod\@cs.rpi.edu)\n";
-  print OUT "//\n";
-  print OUT "// Permission to copy, use, sell and distribute this software is granted\n";
-  print OUT "// provided this copyright notice appears in all copies.\n";
-  print OUT "// Permission to modify the code and to distribute modified code is granted\n";
-  print OUT "// provided this copyright notice appears in all copies, and a notice\n";
-  print OUT "// that the code was modified is included with the copyright notice.\n";
-  print OUT "//\n";
-  print OUT "// This software is provided \"as is\" without express or implied warranty,\n";
-  print OUT "// and with no claim as to its suitability for any purpose.\n";
-  print OUT " \n";
-  print OUT "// For more information, see http://www.boost.org\n";
-  print OUT "\n";
-  print OUT "#ifndef BOOST_FUNCTION_FUNCTION" . $numArgs . "_HEADER\n";
-  print OUT "#define BOOST_FUNCTION_FUNCTION" , $numArgs . "_HEADER\n";
-  print OUT "\n";
  print OUT "#define BOOST_FUNCTION_NUM_ARGS $numArgs\n";
-
-  $templateParms = "";
-  for ($i = 0; $i < $numArgs; ++$i) {
-    if ($i > 0) {
-      $templateParms .= ", ";
-    }
-    $templateParms .= "typename T$i";
-  }
-  print OUT "#define BOOST_FUNCTION_TEMPLATE_PARMS $templateParms\n";
-
-  $_ = $templateParms;
-  s/typename //g;
-  $templateArgs = $_;
-  print OUT "#define BOOST_FUNCTION_TEMPLATE_ARGS $templateArgs\n";
-
-  $parms = "";
-  for ($i = 0; $i < $numArgs; ++$i) {
-    if ($i > 0) {
-      $parms .= ", ";
-    }
-    $parms .= "T$i a$i";
-  }
-  print OUT "#define BOOST_FUNCTION_PARMS $parms\n";
-
-  $args = "";
-  for ($i = 0; $i < $numArgs; ++$i) {
-    if ($i > 0) {
-      $args .= ", ";
-    }
-    $args .= "a$i";
-  }
-  print OUT "#define BOOST_FUNCTION_ARGS $args\n";
-
-  $not0Parms = "";
-  for ($i = 1; $i < $numArgs; ++$i) {
-    if ($i > 1) {
-      $not0Parms .= ", ";
-    }
-    $not0Parms .= "T$i a$i";
-  }
-  print OUT "#define BOOST_FUNCTION_NOT_0_PARMS $not0Parms\n";
-
-  $not0Args = "";
-  for ($i = 1; $i < $numArgs; ++$i) {
-    if ($i > 1) {
-      $not0Args .= ", ";
-    }
-    $not0Args .= "a$i";
-  }
-  print OUT "#define BOOST_FUNCTION_NOT_0_ARGS $not0Args\n";
-
-  print OUT "\n";
-  print OUT "#include <boost/function/function_template.hpp>\n";
-  print OUT "\n";
-  print OUT "#undef BOOST_FUNCTION_NOT_0_ARGS\n";
-  print OUT "#undef BOOST_FUNCTION_NOT_0_PARMS\n";
-  print OUT "#undef BOOST_FUNCTION_ARGS\n";
-  print OUT "#undef BOOST_FUNCTION_PARMS\n";
-  print OUT "#undef BOOST_FUNCTION_TEMPLATE_ARGS\n";
-  print OUT "#undef BOOST_FUNCTION_TEMPLATE_PARMS\n";
+  print OUT "#include <boost/function/detail/maybe_include.hpp>\n";
  print OUT "#undef BOOST_FUNCTION_NUM_ARGS\n";
-  print OUT "\n";
-  print OUT "#endif // BOOST_FUNCTION_FUNCTION" . $numArgs . "_HEADER\n";
  close OUT;
 }
--- a/include/boost/function_equal.hpp
+++ b/include/boost/function_equal.hpp
@ -0,0 +1,28 @@
+//  Copyright Douglas Gregor 2004.
+//  Copyright 2005 Peter Dimov
+
+//  Use, modification and distribution is subject to
+//  the Boost Software License, Version 1.0.
+//  (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+#ifndef BOOST_FUNCTION_EQUAL_HPP
+#define BOOST_FUNCTION_EQUAL_HPP
+
+namespace boost {
+
+template<typename F, typename G>
+  bool function_equal_impl(const F& f, const G& g, long)
+  { return f == g; }
+
+// function_equal_impl needs to be unqualified to pick
+// user overloads on two-phase compilers
+
+template<typename F, typename G>
+  bool function_equal(const F& f, const G& g)
+  { return function_equal_impl(f, g, 0); }
+
+} // end namespace boost
+
+#endif // BOOST_FUNCTION_EQUAL_HPP
--- a/index.html
+++ b/index.html
@ -1,89 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-  <head>
-    <title>Boost.Function</title>
-  </head>
-
-  <body bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080">
-
-  <h1><IMG SRC="../../c++boost.gif" WIDTH="276" HEIGHT="86">Header &lt;<a HREF="../../boost/function.hpp">boost/function.hpp</a>&gt;</h1>
-
-<p> The header &lt;<a HREF="../../boost/function.hpp">boost/function.hpp</a>&gt; includes a family of class templates that are function object wrappers. The notion is similar to a generalized callback. It shares features with function pointers in that both define a call interface (e.g., a function taking two integer arguments and returning a floating-point value) through which some implementation can be called, and the implementation that is invoked may change throughout the course of the program.
-
-<p> Generally, any place in which a function pointer would be used to defer a call or make a callback, Boost.Function can be used instead to allow the user greater flexibility in the implementation of the target. Targets can be any 'compatible' function object (or function pointer), meaning that the arguments to the interface designated by Boost.Function can be converted to the arguments of the target function object.
-
-<ul>
-  <li><a href="doc/tutorial.html">Tutorial</a></li>
-  <li><a href="doc/reference.html">Reference manual</a></li>
-  <li><a href="#vspointers">Boost.Function vs. Function Pointers</a></li>
-  <li><a href="#performance">Performance</a></li>
-  <li><a href="#portability">Portability</a></li>
-  <li><a href="#design">Design rationale</a></li>
-  <li><a href="#acknowledgements">Acknowledgements</a></li>
-  <li><a href="doc/faq.html">Frequently Asked Questions</a></li>
-</ul>
-
-<h2><a name="vspointers">Boost.Function vs. Function Pointers</a></h2>
-<p>Boost.Function has several advantages over function pointers, namely:
-
-<ul>
-   <li>Boost.Function allows arbitrary compatible function objects to be targets (instead of requiring an exact function signature).</li>
-   <li>Boost.Function may be used with argument-binding and other function object construction libraries.</li>
-   <li>Boost.Function has predictible debug behavior when an empty function object is called. </li>
-   <li>Boost.Function can be adapted to perform operations before and after each call, allowing, for instance, synchronization primitives to be made part of the function type.</li>
-</ul>
-
-And, of course, function pointers have several advantages over Boost.Function:
-
-<ul>
-    <li> Function pointers are smaller (the size of one pointer instead of three) </li>
-    <li> Function pointers are faster (Boost.Function may require two calls through function pointers) </li>
-    <li> Function pointers are backward-compatible with C libraries.</li>
-    <li> More readable error messages. </li>
-</ul>
-
-
-<p> The above two lists were adapted from comments made by Darin Adler.
-
-<h2><a name="performance">Performance</a></h2>
-<h3>Function object wrapper size</h3>
-<p> Function object wrappers will be the size of two function pointers plus one function pointer or data pointer (whichever is larger). On common 32-bit platforms, this amounts to 12 bytes per wrapper. Additionally, the function object target will be allocated on the heap.
-
-<h3>Copying efficiency</h3>
-<p> Copying function object wrappers may require allocating memory for a copy of the function object target. The default allocator may be replaced with a faster custom allocator or one may choose to allow the function object wrappers to only store function object targets by reference (using <a href="../bind/ref.html"><code>ref</code></a>) if the cost of this cloning becomes prohibitive.
-
-<h3>Invocation efficiency</h3>
-<p> With a properly inlining compiler, an invocation of a function object requires one call through a function pointer. If the call is to a free function pointer, an additional call must be made to that function pointer (unless the compiler has very powerful interprocedural analysis).
-
-<h2><a name="portability">Portability</a></h2>
-<p> The function object wrappers have been designed to be as portable as possible, and to support many compilers even when they do not support the C++ standard well. The following compilers have passed all of the test cases included with <code>boost::function</code>.
-<ul>
-  <li>GCC 2.95.3</li>
-  <li>GCC 3.0</li>
-  <li>SGI MIPSpro 7.3.0</li>
-  <li>Borland C++ 5.5.1</li>
-  <li>Comeau C++ 4.2.45.2</li>
-  <li>Metrowerks Codewarrior 6.1</li>
-</ul>
-
-<p> The following compilers work with <code>boost::function</code>, but have some problems:
-<ul>
-  <li>Microsoft Visual C++ 6.0 (service pack 5): allocators not supported, some problems with <code>boost::function</code> class template (numbered variants seem to work)</li>
-  <li>Intel C++ 5.0: allocators not supported</li>
-</ul>
-
-<p> If your compiler is not listed, there is a small set of tests to stress the capabilities of the <code>boost::function</code> library. A standards-compliant compiler should compile the code without any modifications, but if you find you run into problems please submit a bug report.
-
-<h2><a name="design">Design rationale</a></h2>
-<h3>Combatting virtual function bloat</h3>
-<p> The use of virtual functions tends to cause 'code bloat' on many compilers. When a class contains a virtual function, it is necessary to emit an additional function that classifies the type of the object. It has been our experience that these auxiliary functions increase the size of the executable significantly when many <code>boost::function</code> objects are used. 
-
-<p> In Boost.Function, an alternative but equivalent approach was taken using free functions instead of virtual functions. The Boost.Function object essentially holds two pointers to make a valid target call: a void pointer to the function object it contains and a void pointer to an "invoker" that can call the function object, given the function pointer. This invoker function performs the argument and return value conversions Boost.Function provides. A third pointer points to a free function called the "manager", which handles the cloning and destruction of function objects. The scheme is typesafe because the only functions that actually handle the function object, the invoker and the manager, are instantiated given the type of the function object, so they can safely cast the incoming void pointer (the function object pointer) to the appropriate type.
-
-<h2><a name="acknowledgements">Acknowledgements</a></h2>
-<p> Many people were involved in the construction of this library. William Kempf, Jesse Jones and Karl Nelson were all extremely helpful in isolating an interface and scope for the library. John Maddock managed the formal review, and many reviewers gave excellent comments on interface, implementation, and documentation. 
-
-    <hr>
-    <address><a href="mailto:gregod@cs.rpi.edu">Doug Gregor</a></address>
-  </body>
-</html>
--- a/test/allocator_test.cpp
+++ b/test/allocator_test.cpp
@ -1,88 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <cassert>
-#include <functional>
-#include <boost/function.hpp>
-
-using namespace std;
-using namespace boost;
-
-static int alloc_count = 0;
-static int dealloc_count = 0;
-
-template<typename T>
-struct counting_allocator : public std::allocator<T>
-{
-  template<typename U>
-  struct rebind
-  {
-    typedef counting_allocator<U> other;
-  };
-
-  
-  T* allocate(std::size_t n)
-  {
-    alloc_count++;
-    return std::allocator<T>::allocate(n);
-  }
-
-  void deallocate(T* p, std::size_t n)
-  {
-    dealloc_count++;
-    std::allocator<T>::deallocate(p, n);
-  }
-};
-
-static int do_minus(int x, int y) { return x-y; }
-
-struct DoNothing
-{
-  void operator()() const {}
-};
-
-static void do_nothing() {}
-
-int
-test_main(int, char*[])
-{
-  function<int, int, int>::allocator< counting_allocator<int> >::type f; 
-  f = plus<int>();
-  f.clear();
-  BOOST_TEST(alloc_count == 1);
-  BOOST_TEST(dealloc_count == 1);
-
-  alloc_count = 0;
-  dealloc_count = 0;
-  f = &do_minus;
-  f.clear();
-
-  function<void>::allocator< counting_allocator<int> >::type fv;
-  alloc_count = 0;
-  dealloc_count = 0;
-  fv = DoNothing();
-  fv.clear();
-  BOOST_TEST(alloc_count == 1);
-  BOOST_TEST(dealloc_count == 1);
-  
-  alloc_count = 0;
-  dealloc_count = 0;
-  fv = &do_nothing;
-  fv.clear();
-
-  return 0;
-}
--- a/test/function_n_test.cpp
+++ b/test/function_n_test.cpp
@ -1,645 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <boost/function.hpp>
-#include <functional>
-#include <cassert>
-#include <string>
-
-using namespace boost;
-using std::string;
-using std::negate;
-
-int global_int;
-
-struct write_five_obj { void operator()() const { global_int = 5; } };
-struct write_three_obj { int operator()() const { global_int = 3; return 7; }};
-static void write_five() { global_int = 5; }
-static void write_three() { global_int = 3; }
-struct generate_five_obj { int operator()() const { return 5; } };
-struct generate_three_obj { int operator()() const { return 3; } };
-static int generate_five() { return 5; }
-static int generate_three() { return 3; }
-static string identity_str(const string& s) { return s; }
-static string string_cat(const string& s1, const string& s2) { return s1+s2; }
-static int sum_ints(int x, int y) { return x+y; }
-
-struct write_const_1_nonconst_2
-{
-  void operator()() { global_int = 2; }
-  void operator()() const { global_int = 1; }
-};
-
-struct add_to_obj
-{
-  add_to_obj(int v) : value(v) {}
-
-  int operator()(int x) const { return value + x; }
-
-  int value;
-};
-
-static void
-test_zero_args()
-{
-  typedef function0<void> func_void_type;
-
-  write_five_obj five;
-  write_three_obj three;
-
-  // Default construction
-  func_void_type v1;
-  BOOST_TEST(v1.empty());
-
-  // Assignment to an empty function 
-  v1 = five;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation of a function
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 5);
-
-  // clear() method
-  v1.clear();
-  BOOST_TEST(v1.empty());
-
-  // Assignment to an empty function
-  v1 = three;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation and self-assignment
-  global_int = 0;
-  v1 = v1;
-  v1();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v1 = five;
-
-  // Invocation and self-assignment
-  global_int = 0;
-  v1.set(v1);
-  v1();
-  BOOST_TEST(global_int == 5);
-
-  // clear()
-  v1.clear();
-  BOOST_TEST(v1.empty());
-
-  // Assignment to an empty function from a free function
-  v1 = write_five;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v1 = &write_three;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment
-  v1 = five;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v1 = write_three;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 3);
-
-  // Construction from another function (that is empty)
-  v1.clear();
-  func_void_type v2(v1);
-  BOOST_TEST(!v2);
-
-  // Assignment to an empty function
-  v2 = three;
-  BOOST_TEST(!v2.empty());
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v2.set(five);
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 5);
-
-  v2.clear();
-  BOOST_TEST(v2.empty());
-
-  // Assignment to an empty function from a free function
-  v2.set(&write_five);
-  BOOST_TEST(v2);
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v2 = &write_three;
-  BOOST_TEST(!v2.empty());
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 3);
-
-  // Swapping
-  v1 = five;
-  swap(v1, v2);
-  v2();
-  BOOST_TEST(global_int == 5);
-  v1();
-  BOOST_TEST(global_int == 3);
-  swap(v1, v2);
-  v1.clear();
-
-  // Assignment
-  v2 = five;
-  BOOST_TEST(!v2.empty());
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v2 = &write_three;
-  BOOST_TEST(!v2.empty());
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a function from an empty function
-  v2 = v1;
-  BOOST_TEST(v2.empty()); 
-  
-  // Assignment to a function from a function with a functor
-  v1 = three;
-  v2 = v1;
-  BOOST_TEST(!v1.empty());
-  BOOST_TEST(!v2.empty());
-
-  // Invocation
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 3);
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 3);
-
-  // Assign to a function from a function with a function
-  v2 = &write_five;
-  v1 = v2;
-  BOOST_TEST(!v1.empty());
-  BOOST_TEST(!v2.empty());
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 5);
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 5);
-
-  // Construct a function given another function containing a function
-  func_void_type v3(v1);
-
-  // Invocation of a function
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 5);
-  
-  // clear() method
-  v3.clear();
-  BOOST_TEST(!v3);
-
-  // Assignment to an empty function
-  v3 = three;
-  BOOST_TEST(!v3.empty());
-
-  // Invocation
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v3 = five;
-
-  // Invocation
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 5);
-
-  // clear()
-  v3.clear();
-  BOOST_TEST(v3.empty());
-
-  // Assignment to an empty function from a free function
-  v3 = &write_five;
-  BOOST_TEST(!v3.empty());
-
-  // Invocation
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v3 = &write_three;
-  BOOST_TEST(!v3.empty());
-
-  // Invocation
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment
-  v3 = five;
-  BOOST_TEST(!v3.empty());
-
-  // Invocation
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 5);
-
-  // Construction of a function from a function containing a functor
-  func_void_type v4(v3);
-
-  // Invocation of a function
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 5);
-  
-  // clear() method
-  v4.clear();
-  BOOST_TEST(v4.empty());
-
-  // Assignment to an empty function
-  v4 = three;
-  BOOST_TEST(!v4.empty());
-
-  // Invocation
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v4 = five;
-
-  // Invocation
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 5);
-
-  // clear()
-  v4.clear();
-  BOOST_TEST(v4.empty());
-
-  // Assignment to an empty function from a free function
-  v4 = &write_five;
-  BOOST_TEST(!v4.empty());
-
-  // Invocation
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v4 = &write_three;
-  BOOST_TEST(!v4.empty());
-
-  // Invocation
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment
-  v4 = five;
-  BOOST_TEST(!v4.empty());
-
-  // Invocation
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 5);
-
-  // Construction of a function from a functor
-  func_void_type v5(five);
-
-  // Invocation of a function
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 5);
-  
-  // clear() method
-  v5.clear();
-  BOOST_TEST(v5.empty());
-
-  // Assignment to an empty function
-  v5 = three;
-  BOOST_TEST(!v5.empty());
-
-  // Invocation
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v5 = five;
-
-  // Invocation
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 5);
-
-  // clear()
-  v5.clear();
-  BOOST_TEST(v5.empty());
-
-  // Assignment to an empty function from a free function
-  v5 = &write_five;
-  BOOST_TEST(!v5.empty());
-
-  // Invocation
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v5 = &write_three;
-  BOOST_TEST(!v5.empty());
-
-  // Invocation
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment
-  v5 = five;
-  BOOST_TEST(!v5.empty());
-
-  // Invocation
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 5);  
-
-  // Construction of a function from a function
-  func_void_type v6(&write_five);
-
-  // Invocation of a function
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 5);
-
-  // clear() method
-  v6.clear();
-  BOOST_TEST(v6.empty());
-
-  // Assignment to an empty function
-  v6 = three;
-  BOOST_TEST(!v6.empty());
-
-  // Invocation
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v6 = five;
-
-  // Invocation
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 5);
-
-  // clear()
-  v6.clear();
-  BOOST_TEST(v6.empty());
-
-  // Assignment to an empty function from a free function
-  v6 = &write_five;
-  BOOST_TEST(!v6.empty());
-
-  // Invocation
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v6 = &write_three;
-  BOOST_TEST(!v6.empty());
-
-  // Invocation
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment
-  v6 = five;
-  BOOST_TEST(!v6.empty());
-
-  // Invocation
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 5);  
-
-  // Const vs. non-const
-  write_const_1_nonconst_2 one_or_two;
-  const function0<void> v7(one_or_two);
-  function <void> v8(one_or_two);
-
-  global_int = 0;
-  v7();
-  BOOST_TEST(global_int == 2);
-  
-  global_int = 0;
-  v8();
-  BOOST_TEST(global_int == 2);
-
-  // Test return values
-  typedef function0<int> func_int_type;
-  generate_five_obj gen_five;
-  generate_three_obj gen_three;
-
-  func_int_type i0(gen_five);
-
-  BOOST_TEST(i0() == 5);
-  i0 = gen_three;
-  BOOST_TEST(i0() == 3);
-  i0 = &generate_five;
-  BOOST_TEST(i0() == 5);
-  i0 = &generate_three;
-  BOOST_TEST(i0() == 3);
-  BOOST_TEST(i0);
-  i0.clear();
-  BOOST_TEST(!i0);
-
-  // Test return values with compatible types
-  typedef function0<long> func_long_type;
-  func_long_type i1(gen_five);
-
-  BOOST_TEST(i1() == 5);
-  i1 = gen_three;
-  BOOST_TEST(i1() == 3);
-  i1 = &generate_five;
-  BOOST_TEST(i1() == 5);
-  i1 = &generate_three;
-  BOOST_TEST(i1() == 3);
-  BOOST_TEST(i1);
-  i1.clear();
-  BOOST_TEST(!i1);
-}
-
-static void
-test_one_arg()
-{
-  negate<int> neg;
-
-  function1<int, int> f1(neg);
-  BOOST_TEST(f1(5) == -5);
-
-  function1<string, string> id(&identity_str);
-  BOOST_TEST(id("str") == "str");
-
-  function1<std::string, const char*> id2(&identity_str);
-  BOOST_TEST(id2("foo") == "foo");
-
-  add_to_obj add_to(5);
-  function1<int, int> f2(add_to);
-  BOOST_TEST(f2(3) == 8);
-
-  const function1<int, int> cf2(add_to);
-  BOOST_TEST(cf2(3) == 8);
-}
-
-static void
-test_two_args()
-{
-  function2<string, const string&, const string&> cat(&string_cat);
-  BOOST_TEST(cat("str", "ing") == "string");  
-
-  function2<int, short, short> sum(&sum_ints);
-  BOOST_TEST(sum(2, 3) == 5);
-}
-
-static void
-test_emptiness()
-{
-  function0<float> f1;
-  BOOST_TEST(f1.empty());
-
-  function0<float> f2;
-  f2 = f1;
-  BOOST_TEST(f2.empty());
-
-  function0<double> f3;
-  f3 = f2;
-  BOOST_TEST(f3.empty());
-}
-
-struct X {
-  X(int v) : value(v) {}
-
-  int twice() const { return 2*value; }
-  int plus(int v) { return value + v; }
-
-  int value;
-};
-
-static void
-test_member_functions()
-{
-
-  boost::function1<int, X*> f1(&X::twice);
-  
-  X one(1);
-  X five(5);
-
-  BOOST_TEST(f1(&one) == 2);
-  BOOST_TEST(f1(&five) == 10);
-
-  boost::function1<int, X*> f1_2;
-  f1_2 = &X::twice;
-
-  BOOST_TEST(f1_2(&one) == 2);
-  BOOST_TEST(f1_2(&five) == 10);
-
-  boost::function2<int, X&, int> f2(&X::plus);
-  BOOST_TEST(f2(one, 3) == 4);
-  BOOST_TEST(f2(five, 4) == 9);
-}
-
-struct add_with_throw_on_copy {
-  int operator()(int x, int y) const { return x+y; }
-
-  add_with_throw_on_copy() {}
-
-  add_with_throw_on_copy(const add_with_throw_on_copy&)
-  {
-    throw std::runtime_error("But this CAN'T throw");
-  }
-
-  add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
-  {
-    throw std::runtime_error("But this CAN'T throw");
-  }
-};
-
-static void
-test_ref()
-{
-  add_with_throw_on_copy atc;
-  try {
-    boost::function2<int, int, int> f(ref(atc));
-    BOOST_TEST(f(1, 3) == 4);
-  }
-  catch(std::runtime_error e) {
-    BOOST_ERROR("Nonthrowing constructor threw an exception");
-  }
-}
-
-int test_main(int, char* [])
-{
-  test_zero_args();
-  test_one_arg();
-  test_two_args();
-  test_emptiness();
-  test_member_functions();
-  test_ref();
-  return 0;
-}
--- a/test/function_test.cpp
+++ b/test/function_test.cpp
@ -1,645 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <boost/function.hpp>
-#include <functional>
-#include <cassert>
-#include <string>
-
-using namespace boost;
-using std::string;
-using std::negate;
-
-int global_int;
-
-struct write_five_obj { void operator()() const { global_int = 5; } };
-struct write_three_obj { int operator()() const { global_int = 3; return 7; }};
-static void write_five() { global_int = 5; }
-static void write_three() { global_int = 3; }
-struct generate_five_obj { int operator()() const { return 5; } };
-struct generate_three_obj { int operator()() const { return 3; } };
-static int generate_five() { return 5; }
-static int generate_three() { return 3; }
-static string identity_str(const string& s) { return s; }
-static string string_cat(const string& s1, const string& s2) { return s1+s2; }
-static int sum_ints(int x, int y) { return x+y; }
-
-struct write_const_1_nonconst_2
-{
-  void operator()() { global_int = 2; }
-  void operator()() const { global_int = 1; }
-};
-
-struct add_to_obj
-{
-  add_to_obj(int v) : value(v) {}
-
-  int operator()(int x) const { return value + x; }
-
-  int value;
-};
-
-static void
-test_zero_args()
-{
-  typedef function<void> func_void_type;
-
-  write_five_obj five;
-  write_three_obj three;
-
-  // Default construction
-  func_void_type v1;
-  BOOST_TEST(v1.empty());
-
-  // Assignment to an empty function 
-  v1 = five;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation of a function
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 5);
-
-  // clear() method
-  v1.clear();
-  BOOST_TEST(v1.empty());
-
-  // Assignment to an empty function
-  v1 = three;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation and self-assignment
-  global_int = 0;
-  v1 = v1;
-  v1();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v1 = five;
-
-  // Invocation and self-assignment
-  global_int = 0;
-  v1.set(v1);
-  v1();
-  BOOST_TEST(global_int == 5);
-
-  // clear()
-  v1.clear();
-  BOOST_TEST(v1.empty());
-
-  // Assignment to an empty function from a free function
-  v1 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v1 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment
-  v1 = five;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v1 = &write_three;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 3);
-
-  // Construction from another function (that is empty)
-  v1.clear();
-  func_void_type v2(v1);
-  BOOST_TEST(!v2);
-
-  // Assignment to an empty function
-  v2 = three;
-  BOOST_TEST(!v2.empty());
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v2.set(five);
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 5);
-
-  v2.clear();
-  BOOST_TEST(v2.empty());
-
-  // Assignment to an empty function from a free function
-  v2.set(BOOST_FUNCTION_TARGET_FIX(&) write_five);
-  BOOST_TEST(v2);
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v2 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
-  BOOST_TEST(!v2.empty());
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 3);
-
-  // Swapping
-  v1 = five;
-  swap(v1, v2);
-  v2();
-  BOOST_TEST(global_int == 5);
-  v1();
-  BOOST_TEST(global_int == 3);
-  swap(v1, v2);
-  v1.clear();
-
-  // Assignment
-  v2 = five;
-  BOOST_TEST(!v2.empty());
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v2 = &write_three;
-  BOOST_TEST(!v2.empty());
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a function from an empty function
-  v2 = v1;
-  BOOST_TEST(v2.empty()); 
-  
-  // Assignment to a function from a function with a functor
-  v1 = three;
-  v2 = v1;
-  BOOST_TEST(!v1.empty());
-  BOOST_TEST(!v2.empty());
-
-  // Invocation
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 3);
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 3);
-
-  // Assign to a function from a function with a function
-  v2 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
-  v1 = v2;
-  BOOST_TEST(!v1.empty());
-  BOOST_TEST(!v2.empty());
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 5);
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 5);
-
-  // Construct a function given another function containing a function
-  func_void_type v3(v1);
-
-  // Invocation of a function
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 5);
-  
-  // clear() method
-  v3.clear();
-  BOOST_TEST(!v3);
-
-  // Assignment to an empty function
-  v3 = three;
-  BOOST_TEST(!v3.empty());
-
-  // Invocation
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v3 = five;
-
-  // Invocation
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 5);
-
-  // clear()
-  v3.clear();
-  BOOST_TEST(v3.empty());
-
-  // Assignment to an empty function from a free function
-  v3 = &write_five;
-  BOOST_TEST(!v3.empty());
-
-  // Invocation
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v3 = &write_three;
-  BOOST_TEST(!v3.empty());
-
-  // Invocation
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment
-  v3 = five;
-  BOOST_TEST(!v3.empty());
-
-  // Invocation
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 5);
-
-  // Construction of a function from a function containing a functor
-  func_void_type v4(v3);
-
-  // Invocation of a function
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 5);
-  
-  // clear() method
-  v4.clear();
-  BOOST_TEST(v4.empty());
-
-  // Assignment to an empty function
-  v4 = three;
-  BOOST_TEST(!v4.empty());
-
-  // Invocation
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v4 = five;
-
-  // Invocation
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 5);
-
-  // clear()
-  v4.clear();
-  BOOST_TEST(v4.empty());
-
-  // Assignment to an empty function from a free function
-  v4 = &write_five;
-  BOOST_TEST(!v4.empty());
-
-  // Invocation
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v4 = &write_three;
-  BOOST_TEST(!v4.empty());
-
-  // Invocation
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment
-  v4 = five;
-  BOOST_TEST(!v4.empty());
-
-  // Invocation
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 5);
-
-  // Construction of a function from a functor
-  func_void_type v5(five);
-
-  // Invocation of a function
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 5);
-  
-  // clear() method
-  v5.clear();
-  BOOST_TEST(v5.empty());
-
-  // Assignment to an empty function
-  v5 = three;
-  BOOST_TEST(!v5.empty());
-
-  // Invocation
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v5 = five;
-
-  // Invocation
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 5);
-
-  // clear()
-  v5.clear();
-  BOOST_TEST(v5.empty());
-
-  // Assignment to an empty function from a free function
-  v5 = &write_five;
-  BOOST_TEST(!v5.empty());
-
-  // Invocation
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v5 = &write_three;
-  BOOST_TEST(!v5.empty());
-
-  // Invocation
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment
-  v5 = five;
-  BOOST_TEST(!v5.empty());
-
-  // Invocation
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 5);  
-
-  // Construction of a function from a function
-  func_void_type v6(&write_five);
-
-  // Invocation of a function
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 5);
-
-  // clear() method
-  v6.clear();
-  BOOST_TEST(v6.empty());
-
-  // Assignment to an empty function
-  v6 = three;
-  BOOST_TEST(!v6.empty());
-
-  // Invocation
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v6 = five;
-
-  // Invocation
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 5);
-
-  // clear()
-  v6.clear();
-  BOOST_TEST(v6.empty());
-
-  // Assignment to an empty function from a free function
-  v6 = &write_five;
-  BOOST_TEST(!v6.empty());
-
-  // Invocation
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v6 = &write_three;
-  BOOST_TEST(!v6.empty());
-
-  // Invocation
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment
-  v6 = five;
-  BOOST_TEST(!v6.empty());
-
-  // Invocation
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 5);  
-
-  // Const vs. non-const
-  write_const_1_nonconst_2 one_or_two;
-  const function<void> v7(one_or_two);
-  function <void> v8(one_or_two);
-
-  global_int = 0;
-  v7();
-  BOOST_TEST(global_int == 2);
-  
-  global_int = 0;
-  v8();
-  BOOST_TEST(global_int == 2);
-
-  // Test return values
-  typedef function<int> func_int_type;
-  generate_five_obj gen_five;
-  generate_three_obj gen_three;
-
-  func_int_type i0(gen_five);
-
-  BOOST_TEST(i0() == 5);
-  i0 = gen_three;
-  BOOST_TEST(i0() == 3);
-  i0 = &generate_five;
-  BOOST_TEST(i0() == 5);
-  i0 = &generate_three;
-  BOOST_TEST(i0() == 3);
-  BOOST_TEST(i0);
-  i0.clear();
-  BOOST_TEST(!i0);
-
-  // Test return values with compatible types
-  typedef function<long> func_long_type;
-  func_long_type i1(gen_five);
-
-  BOOST_TEST(i1() == 5);
-  i1 = gen_three;
-  BOOST_TEST(i1() == 3);
-  i1 = &generate_five;
-  BOOST_TEST(i1() == 5);
-  i1 = &generate_three;
-  BOOST_TEST(i1() == 3);
-  BOOST_TEST(i1);
-  i1.clear();
-  BOOST_TEST(!i1);
-}
-
-static void
-test_one_arg()
-{
-  negate<int> neg;
-
-  function<int, int> f1(neg);
-  BOOST_TEST(f1(5) == -5);
-
-  function<string, string> id(&identity_str);
-  BOOST_TEST(id("str") == "str");
-
-  function<std::string, const char*> id2(&identity_str);
-  BOOST_TEST(id2("foo") == "foo");
-
-  add_to_obj add_to(5);
-  function<int, int> f2(add_to);
-  BOOST_TEST(f2(3) == 8);
-
-  const function<int, int> cf2(add_to);
-  BOOST_TEST(cf2(3) == 8);
-}
-
-static void
-test_two_args()
-{
-  function<string, const string&, const string&> cat(&string_cat);
-  BOOST_TEST(cat("str", "ing") == "string");  
-
-  function<int, short, short> sum(&sum_ints);
-  BOOST_TEST(sum(2, 3) == 5);
-}
-
-static void
-test_emptiness()
-{
-  function<float> f1;
-  BOOST_TEST(f1.empty());
-
-  function<float> f2;
-  f2 = f1;
-  BOOST_TEST(f2.empty());
-
-  function<double> f3;
-  f3 = f2;
-  BOOST_TEST(f3.empty());
-}
-
-struct X {
-  X(int v) : value(v) {}
-
-  int twice() const { return 2*value; }
-  int plus(int v) { return value + v; }
-
-  int value;
-};
-
-static void
-test_member_functions()
-{
-  boost::function<int, X*> f1(&X::twice);
-  
-  X one(1);
-  X five(5);
-
-  BOOST_TEST(f1(&one) == 2);
-  BOOST_TEST(f1(&five) == 10);
-
-  boost::function<int, X*> f1_2;
-  f1_2 = &X::twice;
-
-  BOOST_TEST(f1_2(&one) == 2);
-  BOOST_TEST(f1_2(&five) == 10);
-
-  boost::function<int, X&, int> f2(&X::plus);
-  BOOST_TEST(f2(one, 3) == 4);
-  BOOST_TEST(f2(five, 4) == 9);
-}
-
-struct add_with_throw_on_copy {
-  int operator()(int x, int y) const { return x+y; }
-
-  add_with_throw_on_copy() {}
-
-  add_with_throw_on_copy(const add_with_throw_on_copy&)
-  {
-    throw std::runtime_error("But this CAN'T throw");
-  }
-
-  add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
-  {
-    throw std::runtime_error("But this CAN'T throw");
-  }
-};
-
-static void
-test_ref()
-{
-  add_with_throw_on_copy atc;
-  try {
-    boost::function<int, int, int> f(ref(atc));
-    BOOST_TEST(f(1, 3) == 4);
-  }
-  catch(std::runtime_error e) {
-    BOOST_ERROR("Nonthrowing constructor threw an exception");
-  }
-}
-
-int test_main(int, char* [])
-{
-  test_zero_args();
-  test_one_arg();
-  test_two_args();
-  test_emptiness();
-  test_member_functions();
-  test_ref();
-
-  return 0;
-}
--- a/test/function_test_fail1.cpp
+++ b/test/function_test_fail1.cpp
@ -1,35 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <boost/function.hpp>
-
-using namespace std;
-using namespace boost;
-
-int
-test_main(int, char*[])
-{
-  function<int> f1;
-  function<int> f2;
-
-  if (f1 == f2) {
-  }
-
-  BOOST_CRITICAL_ERROR("This should not have compiled.");
-
-  return 0;
-}
--- a/test/function_test_fail2.cpp
+++ b/test/function_test_fail2.cpp
@ -1,34 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <boost/function.hpp>
-
-using namespace std;
-using namespace boost;
-
-static int bad_fn(float f) { return static_cast<int>(f); }
-
-int
-test_main(int, char*[])
-{
-  function<int> f1;
-  f1 = bad_fn;
-
-  BOOST_CRITICAL_ERROR("This should not have compiled.");
-
-  return 0;
-}
--- a/test/mixin_test.cpp
+++ b/test/mixin_test.cpp
@ -1,60 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <cassert>
-#include <functional>
-#include <boost/function.hpp>
-
-struct id_mixin
-{       
-  id_mixin(const id_mixin& rhs) : id(rhs.id) {}
-  id_mixin& operator=(const id_mixin& rhs){id = rhs.id; return *this;}
-  id_mixin(int i = 0){ id = i;}
-  int id;
-};
-
-static int do_plus(int x, int y) { return x+y; }
-
-typedef boost::function<int,int,int>::mixin<id_mixin>::type func;
-
-int test_main(int, char*[])
-{
-  func f(id_mixin(3));  
-  f = std::plus<int>();
-  BOOST_TEST(f.id == 3);
-  
-  f = &do_plus;
-  BOOST_TEST(f.id == 3);
-
-  f.clear();
-  f.id = 7;    
-  BOOST_TEST(f.id == 7);
-    
-  func g(f);
-  BOOST_TEST(g.id == 7);
-
-  f.id = 21;    
-  BOOST_TEST(f.id == 21);
-          
-  boost::swap(f,g);  
-  BOOST_TEST(f.id == 7);
-  BOOST_TEST(g.id == 21);
-
-  g = f;          
-  BOOST_TEST(g.id == 7);  
-  return 0;
-}
--- a/test/policy_test.cpp
+++ b/test/policy_test.cpp
@ -1,47 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <cassert>
-#include <iostream>
-#include <functional>
-#include <boost/function.hpp>
-
-using namespace std;
-using namespace boost;
-
-struct counting_policy
-{
-  static int count;
-
-  void precall(const function_base*) { count++; }
-  void postcall(const function_base*) { count+=2; }
-};
-
-int counting_policy::count = 0;
-
-int
-test_main(int, char*[])
-{
-  function<int, int, int>::policy<counting_policy>::type f; 
-
-  f = plus<int>();
-
-  BOOST_TEST(5 == f(2,3));
-  BOOST_TEST(counting_policy::count==3);
-
-  return 0;
-}
--- a/test/regression.cfg
+++ b/test/regression.cfg
@ -1,14 +0,0 @@
-// Boost.Function regression test configuration file
-
-// From the boost/status directory, run
-// ./regression --tests ../libs/function/test/regression.cfg -o function.html
-
-
-run libs/function/test/allocator_test.cpp
-run libs/function/test/function_n_test.cpp
-run libs/function/test/function_test.cpp
-compile-fail libs/function/test/function_test_fail1.cpp
-compile-fail libs/function/test/function_test_fail2.cpp
-run libs/function/test/mixin_test.cpp
-run libs/function/test/policy_test.cpp
-run libs/function/test/stateless_test.cpp
--- a/test/stateless_test.cpp
+++ b/test/stateless_test.cpp
@ -1,47 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <boost/function.hpp>
-#include <stdexcept>
-
-struct stateless_integer_add {
-  int operator()(int x, int y) const { return x+y; }
-
-  void* operator new(std::size_t, stateless_integer_add*)
-  {
-    throw std::runtime_error("Cannot allocate a stateless_integer_add");
-  }
-
-  void operator delete(void*, stateless_integer_add*)
-  {
-  }
-};
-
-namespace boost {
-  template<>
-  struct is_stateless<stateless_integer_add> {
-    BOOST_STATIC_CONSTANT(bool, value = true);
-  };
-}
-
-int test_main(int, char*[])
-{
-  boost::function<int, int, int> f;
-  f = stateless_integer_add();
-
-  return 0;
-}