This commit was manufactured by cvs2svn to create branch

'thread_rewrite'. [SVN r30953]
Enhance and clean up tests.
2026-01-20 04:42:28 +00:00 · 2005-09-13 14:20:32 +00:00 · 2005-09-11 14:50:37 +00:00 · 2005-09-10 05:53:28 +00:00 · 2005-08-25 16:27:28 +00:00 · 2005-08-25 15:03:19 +00:00
242 changed files with 19393 additions and 5251 deletions
--- a/57
+++ b/57
@@ -1,57 +0,0 @@
-subproject libs/python ;
-
-# bring in the rules for python
-SEARCH on <module@>python.jam = $(BOOST_BUILD_PATH) ;
-include <module@>python.jam ;
-
-PYTHON_PROPERTIES 
-  += <metrowerks><*><cxxflags>"-inline deferred" 
-  <cxx><*><include>$(BOOST_ROOT)/boost/compatibility/cpp_c_headers
-  ;
-
-local export-bpl ;
-
-if $(NT)
-{
-    # Stick this in the property set to deal with gcc
-    export-bpl = export-bpl-logic ;
-
-    rule export-bpl-logic ( toolset variant : properties * )
-    {
-        if $(toolset) != gcc
-        {
-            properties += <define>BOOST_PYTHON_EXPORT=__declspec(dllexport) ;
-        }
-        else
-        {
-            properties += <define>BOOST_PYTHON_EXPORT= ;
-        }
-        return $(properties) ;
-    }
-}
-
-dll bpl
-  : 
-  src/converter/body.cpp
-  src/converter/handle.cpp
-  src/converter/registry.cpp
-  src/converter/wrapper.cpp
-  src/converter/unwrap.cpp
-  src/converter/unwrapper.cpp
-  src/converter/type_id.cpp
-  src/object/class.cpp
-  src/object/function.cpp
-  :
-  $(PYTHON_PROPERTIES)
-    $(export-bpl)
-      # <define>BOOST_PYTHON_TRACE
-  ;
-
-extension m1 : test/m1.cpp <lib>bpl       # <define>BOOST_PYTHON_TRACE
-  : <gcc><*><define>BOOST_PYTHON_EXPORT=
-: debug-python ;
-extension m2 : test/m2.cpp <lib>bpl       # <define>BOOST_PYTHON_TRACE
-  : <gcc><*><define>BOOST_PYTHON_EXPORT=
-: debug-python ;
-
-boost-python-runtest try : test/newtest.py <lib>m1 <lib>m2 : : debug-python ;
--- a/doc/new-conversions.html
+++ b/doc/new-conversions.html
@@ -1,308 +0,0 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-<title>A New Type Conversion Mechanism for Boost.Python</title>
-</head>
-
-<body bgcolor="#FFFFFF" text="#000000">
-
-<p><img border="0" src="../../../c++boost.gif" width="277" height="86"
-alt="boost logo"></p>
-
-<h1>A New Type Conversion Mechanism for Boost.Python</h1>
-
-<p>By <a href="../../../people/dave_abrahams.htm">David Abrahams</a>.
-
-<h2>Introduction</h2>
-
-This document describes a redesign of the mechanism for automatically
-converting objects between C++ and Python. The current implementation
-uses two functions for any type <tt>T</tt>:
-
-<blockquote><pre>
-U from_python(PyObject*, type&lt;T&gt;);
-void to_python(V);
-</pre></blockquote>
-
-where U is convertible to T and T is convertible to V. These functions
-are at the heart of C++/Python interoperability in Boost.Python, so
-why would we want to change them? There are many reasons:
-
-<h3>Bugs</h3>
-<p>Firstly, the current mechanism relies on a common C++ compiler
-bug. This is not just embarrassing: as compilers get to be more
-conformant, the library stops working. The issue, in detail, is the
-use of inline friend functions in templates to generate
-conversions. It is a very powerful, and legal technique as long as
-it's used correctly:
-
-<blockquote><pre>
-template &lt;class Derived&gt;
-struct add_some_functions
-{
-     friend <i>return-type</i> some_function1(..., Derived <i>cv-*-&amp;-opt</i>, ...);
-     friend <i>return-type</i> some_function2(..., Derived <i>cv-*-&amp;-opt</i>, ...);
-};
-
-template &lt;class T&gt;
-struct some_template : add_some_functions&lt;some_template&lt;T&gt; &gt;
-{
-};
-</pre></blockquote>
-
-The <tt>add_some_functions</tt> template generates free functions
-which operate on <tt>Derived</tt>, or on related types. Strictly
-speaking the related types are not just cv-qualified <tt>Derived</tt>
-values, pointers and/or references. Section 3.4.2 in the standard
-describes exactly which types you must use as parameters to these
-functions if you want the functions to be found
-(there is also a less-technical description in section 11.5.1 of
-C++PL3 <a href="#ref_1">[1]</a>). Suffice it to say that
-with the current design, the <tt>from_python</tt> and
-<tt>to_python</tt> functions are not supposed to be callable under any
-conditions!
-
-<h3>Compilation and Linking Time</h3>
-
-The conversion functions generated for each wrapped class using the
-above technique are not function templates, but regular functions. The
-upshot is that they must <i>all</i> be generated regardless of whether
-they are actually used. Generating all of those functions can slow
-down module compilation, and resolving the references can slow down
-linking.
-
-<h3>Efficiency</h3>
-
-The conversion functions are primarily used in (member) function
-wrappers to convert the arguments and return values. Being functions,
-converters have no interface which allows us to ask &quot;will the
-conversion succeed?&quot; without calling the function. Since the
-return value of the function must be the object to be passed as an
-argument, Boost.Python currently uses C++ exception-handling to detect
-an unsuccessful conversion. It's not a particularly good use of
-exception-handling, since the failure is not handled very far from
-where it occurred. More importantly, it means that C++ exceptions are
-thrown during overload resolution as we seek an overload that matches
-the arguments passed. Depending on the implementation, this approach
-can result in significant slowdowns.
-
-<p>It is also unclear that the current library generates a minimal
-amount of code for any type conversion. Many of the conversion
-functions are nontrivial, and partly because of compiler limitations,
-they are declared <tt>inline</tt>. Also, we could have done a better
-job separating the type-specific conversion code from the code which
-is type-independent.
-
-<h3>Cross-module Support</h3>
-
-The current strategy requires every module to contain the definition
-of conversions it uses. In general, a new module can never supply
-conversion code which is used by another module. Ralf Grosse-Kunstleve
-designed a clever system which imports conversions directly from one
-library into another using some explicit declarations, but it has some
-disadvantages also:
-
-<ol>
-<li>The system Ullrich Koethe designed for implicit conversion between
-wrapped classes related through inheritance does not currently work if
-the classes are defined in separate modules.
-
-<li>The writer of the importing module is required to know the name of
-the module supplying the imported conversions.
-
-<li>There can be only one way to extract any given C++ type from a
-Python object in a given module.
-</ol>
-
-The first item might be addressed by moving Boost.Python into a shared
-library, but the other two cannot. Ralf turned the limitation in item
-two into a feature: the required module is loaded implicitly when a
-conversion it defines is invoked. We will probably want to provide
-that functionality anyway, but it's not clear that we should require
-the declaration of all such conversions. The final item is a more
-serious limitation. If, for example, new numeric types are defined in
-separate modules, and these types can all be converted to
-<tt>double</tt>s, we have to choose just one conversion method.
-
-<h3>Ease-of-use</h3>
-
-One persistent source of confusion for users of Boost.Python has been
-the fact that conversions for a class are not be visible at
-compile-time until the declaration of that class has been seen. When
-the user tries to expose a (member) function operating on or returning
-an instance of the class in question, compilation fails...even though
-the user goes on to expose the class in the same translation unit!
-
-<p>
-The new system lifts all compile-time checks for the existence of
-particular type conversions and replaces them with runtime checks, in
-true Pythonic style. While this might seem cavalier, the compile-time
-checks are actually not much use in the current system if many classes
-are wrapped in separate modules, since the checks are based only on
-the user's declaration that the conversions exist.
-
-<h2>The New Design</h2>
-
-<h3>Motivation</h3>
-
-The new design was heavily influenced by a desire to generate as
-little code as possible in extension modules. Some of Boost.Python's
-clients are enormous projects where link time is proportional to the
-amount of object code, and there are many Python extension modules. As
-such, we try to keep type-specific conversion code out of modules
-other than the one the converters are defined in, and rely as much as
-possible on centralized control through a shared library.
-
-<h3>The Basics</h3>
-
-The library contains a <tt>registry</tt> which maps runtime type
-identifiers (actually an extension of <tt>std::type_info</tt> which
-preserves references and constness) to entries containing type
-converters. An <tt>entry</tt> can contain only one converter from C++ to Python
-(<tt>wrapper</tt>), but many converters from Python to C++
-(<tt>unwrapper</tt>s). <font color="#ff0000">What should happen if
-multiple modules try to register wrappers for the same type?</font>. Wrappers
-and unwrappers are known as <tt>body</tt> objects, and are accessed
-by the user and the library (in its function-wrapping code) through
-corresponding <tt>handle</tt> (<tt>wrap&lt;T&gt;</tt> and
-<tt>unwrap&lt;T&gt;</tt>) objects. The <tt>handle</tt> objects are
-extremely lightweight, and delegate <i>all</i> of their operations to
-the corresponding <tt>body</tt>.
-
-<p>
-When a <tt>handle</tt> object is constructed, it accesses the
-registry to find a corresponding <tt>body</tt> that can convert the
-handle's constructor argument. Actually the registry record for any
-type
-<tt>T</tt>used in a module is looked up only once and stored in a
-static <tt>registration&lt;T&gt;</tt> object for efficiency. For
-example, if the handle is an <tt>unwrap&lt;Foo&amp;&gt;</tt> object,
-the <tt>entry</tt> for <tt>Foo&amp;</tt> is looked up in the
-<tt>registry</tt>, and each <tt>unwrapper</tt> it contains is queried
-to determine if it can convert the
-<tt>PyObject*</tt> with which the <tt>unwrap</tt> was constructed. If
-a body object which can perform the conversion is found, a pointer to
-it is stored in the handle. A body object may at any point store
-additional data in the handle to speed up the conversion process.
-
-<p>
-Now that the handle has been constructed, the user can ask it whether
-the conversion can be performed. All handles can be tested as though
-they were convertible to <tt>bool</tt>; a <tt>true</tt> value
-indicates success. If the user forges ahead and tries to do the
-conversion without checking when no conversion is possible, an
-exception will be thrown as usual. The conversion itself is performed
-by the body object. 
-
-<h3>Handling complex conversions</h3>
-
-<p>Some conversions may require a dynamic allocation. For example,
-when a Python tuple is converted to a <tt>std::vector&lt;double&gt;
-const&amp;</tt>, we need some storage into which to construct the
-vector so that a reference to it can be formed. Furthermore, multiple
-conversions of the same type may need to be &quot;active&quot;
-simultaneously, so we can't keep a single copy of the storage
-anywhere. We could keep the storage in the <tt>body</tt> object, and
-have the body clone itself in case the storage is used, but in that
-case the storage in the body which lives in the registry is never
-used. If the storage was actually an object of the target type (the
-safest way in C++), we'd have to find a way to construct one for the
-body in the registry, since it may not have a default constructor.
-
-<p>
-The most obvious way out of this quagmire is to allocate the object using a
-<i>new-expression</i>, and store a pointer to it in the handle. Since
-the <tt>body</tt> object knows everything about the data it needs to
-allocate (if any), it is also given responsibility for destroying that
-data. When the <tt>handle</tt> is destroyed it asks the <tt>body</tt>
-object to tear down any data it may have stored there. In many ways,
-you can think of the <tt>body</tt> as a &quot;dynamically-determined
-vtable&quot; for the handle.
-
-<h3>Eliminating Redundancy</h3>
-
-If you look at the current Boost.Python code, you'll see that there
-are an enormous number of conversion functions generated for each
-wrapped class. For a given class <tt>T</tt>, functions are generated
-to extract the following types <tt>from_python</tt>:
-
-<blockquote><pre>
-T*
-T const*
-T const* const&amp;
-T* const&amp;
-T&amp;
-T const&amp;
-T
-std::auto_ptr&lt;T&gt;&amp;
-std::auto_ptr&lt;T&gt;
-std::auto_ptr&lt;T&gt; const&amp;
-boost::shared_ptr&lt;T&gt;&amp;
-boost::shared_ptr&lt;T&gt;
-boost::shared_ptr&lt;T&gt; const&amp;
-</pre></blockquote>
-
-Most of these are implemented in terms of just a few conversions, and
-<t>if you're lucky</t>, they will be inlined and cause no extra
-overhead. In the new system, however, a significant amount of data
-will be associated with each type that needs to be converted. We
-certainly don't want to register a separate unwrapper object for all
-of the above types.
-
-<p>Fortunately, much of the redundancy can be eliminated. For example,
-if we generate an unwrapper for <tt>T&</tt>, we don't need an
-unwrapper for <tt>T const&</tt> or <tt>T</tt>. Accordingly, the user's
-request to wrap/unwrap a given type is translated at compile-time into
-a request which helps to eliminate redundancy. The rules used to
-<tt>unwrap</tt> a type are:
-
-<ol>
-<li> Treat built-in types specially: when unwrapping a value or
-   constant reference to one of these, use a value for the target
-   type. It will bind to a const reference if neccessary, and more
-   importantly, avoids having to dynamically allocate room for
-   an lvalue of types which can be cheaply copied.
-<li>
- Reduce everything else to a reference to an un-cv-qualified type
-   where possible. Since cv-qualification is lost on Python
-   anyway, there's no point in trying to convert to a
-   <tt>const&amp;</tt>. <font color="#ff0000">What about conversions
-   to values like the tuple-&gt;vector example above? It seems to me
-   that we don't want to make a <tt>vector&lt;double&gt;&amp;</tt>
-   (non-const) converter available for that case. We may need to
-   rethink this slightly.</font>
-   </ol>
-
-<h3>Efficient Argument Conversion</h3>
-
-Since type conversions are primarily used in function wrappers, an
-optimization is provided for the case where a group of conversions are
-used together. Each <tt>handle</tt> class has a corresponding
-&quot;<tt>_more</tt>&quot; class which does the same job, but has a
-trivial destructor. Instead of asking each &quot;<tt>_more</tt>&quot;
-handle to destroy its own body, it is linked into an endogenous list
-managed by the first (ordinary) handle. The <tt>wrap</tt> and
-<tt>unwrap</tt> destructors are responsible for traversing that list
-and asking each <tt>body</tt> class to tear down its
-<tt>handle</tt>. This mechanism is also used to determine if all of
-the argument/return-value conversions can succeed with a single
-function call in the function wrapping code. <font color="#ff0000">We
-might need to handle return values in a separate step for Python
-callbacks, since the availablility of a conversion won't be known
-until the result object is retrieved.</font>
-
-<br>
-<hr>
-<h2>References</h2>
-
-<p><a name="ref_1">[1]</a>B. Stroustrup, The C++ Programming Language
-Special Edition Addison-Wesley, ISBN 0-201-70073-5.
-
-<hr>
-<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B %Y" startspan -->19 December 2001<!--webbot bot="Timestamp" endspan i-checksum="31283" --></p>
-<p>© Copyright David Abrahams, 2001</p>
-
-</body>
-
-</html>
--- a/doc/new-conversions.txt
+++ b/doc/new-conversions.txt
@@ -1,111 +0,0 @@
-This hierarchy contains converter handle classes.
-
-
-                +-------------+
-                | noncopyable |
-                +-------------+
-                      ^
-                      |            A common base class used so that
-             +--------+--------+   conversions can be linked into a
-             | conversion_base |   chain for efficient argument
-             +-----------------+   conversion
-                      ^
-                      |
-            +---------+-----------+
-            |                     |
-+-----------+----+         +------+-------+  only used for
-| unwrap_more<T> |         | wrap_more<T> |  chaining, and don't manage any
-+----------------+         +--------------+  resources.
-         ^                         ^
-         |                         |
-   +-----+-----+           +-------+-+  These converters are what users
-   | unwrap<T> |           | wrap<T> |  actually touch, but they do so
-   +-----------+           +---------+  through a type generator which
-                                        minimizes the number of converters
-                                        that must be generated, so they
-
-
-Each unwrap<T>, unwrap_more<T>, wrap<T>, wrap_more<T> converter holds
-a reference to an appropriate converter object
-
-This hierarchy contains converter body classes
-
-                                          Exposes use/release which
-                                          are needed in case the converter
-                           +-----------+  in the registry needs to be
-                           | converter |  cloned. That occurs when a
-                           +-----------+  unwrap target type is not
-                                 ^        contained within the Python object.
-                                 |
-              +------------------+-----+
-              |                        |
-     +--------+-------+ Exposes        |
-     | unwrapper_base | convertible()  |
-     +----------------+                |
-              ^                        |
-              |                        |
-     +--------+----+             +-----+-----+
-     | unwrapper<T>|             | wrapper<T>|
-     +-------------+             +-----------+
- Exposes T convert(PyObject*)    Exposes PyObject* convert(T)
-
-
-unwrap:
-
-    constructed with a PyObject*, whose reference count is
-    incremented.
-
-    find the registry entry for the target type
-
-    look in the collection of converters for one which claims to be
-    able to convert the PyObject to the target type.
-
-    stick a pointer to the unwrapper in the unwrap object
-
-    when unwrap is queried for convertibility, it checks to see
-    if it has a pointer to an unwrapper.
-
-    on conversion, the unwrapper is asked to allocate an
-    implementation if the unwrap object isn't already holding
-    one. The unwrap object "takes ownership" of the unwrapper's
-    implementation. No memory allocation will actually take place
-    unless this is a value conversion.
-
-    on destruction, the unwrapper is asked to free any implementation
-    held by the unwrap object. No memory deallocation actually
-    takes place unless this is a value conversion
-
-    on destruction, the reference count on the held PyObject is
-    decremented.
-
-    We need to make sure that by default, you can't instantiate
-    callback<> for reference and pointer return types: although the
-    unwrappers may exist, they may convert by-value, which would cause
-    the referent to be destroyed upon return.
-
-wrap:
-
-    find the registry entry for the source type
-
-    see if there is a converter. If found, stick a pointer to it in
-    the wrap object.
-
-    when queried for convertibility, it checks to see if it has a
-    pointer to a converter.
-
-    on conversion, a reference to the target PyObject is held by the
-    converter. Generally, the PyObject will have been created by the
-    converter, but in certain cases it may be a pre-existing object,
-    whose reference count will have been incremented.
-
-    when a wrap<T> x is used to return from a C++ function,
-    x.release() is returned so that x no longer holds a reference to
-    the PyObject when destroyed.
-
-    Otherwise, on destruction, any PyObject still held has its
-    reference-count decremented.
-
-
-When a converter is created by the user, the appropriate element must
-be added to the registry; when it is destroyed, it must be removed
-from the registry.
--- a/include/boost/python.hpp
+++ b/include/boost/python.hpp
@@ -0,0 +1,72 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/libs/python for documentation.
+
+#ifndef PYTHON_DWA2002810_HPP
+# define PYTHON_DWA2002810_HPP
+
+# include <boost/python/args.hpp>
+# include <boost/python/args_fwd.hpp>
+# include <boost/python/back_reference.hpp>
+# include <boost/python/bases.hpp>
+# include <boost/python/borrowed.hpp>
+# include <boost/python/call.hpp>
+# include <boost/python/call_method.hpp>
+# include <boost/python/class.hpp>
+# include <boost/python/copy_const_reference.hpp>
+# include <boost/python/copy_non_const_reference.hpp>
+# include <boost/python/data_members.hpp>
+# include <boost/python/def.hpp>
+# include <boost/python/default_call_policies.hpp>
+# include <boost/python/dict.hpp>
+# include <boost/python/enum.hpp>
+# include <boost/python/errors.hpp>
+# include <boost/python/exception_translator.hpp>
+# include <boost/python/exec.hpp>
+# include <boost/python/extract.hpp>
+# include <boost/python/handle.hpp>
+# include <boost/python/has_back_reference.hpp>
+# include <boost/python/implicit.hpp>
+# include <boost/python/init.hpp>
+# include <boost/python/import.hpp>
+# include <boost/python/instance_holder.hpp>
+# include <boost/python/iterator.hpp>
+# include <boost/python/list.hpp>
+# include <boost/python/long.hpp>
+# include <boost/python/lvalue_from_pytype.hpp>
+# include <boost/python/make_constructor.hpp>
+# include <boost/python/make_function.hpp>
+# include <boost/python/manage_new_object.hpp>
+# include <boost/python/module.hpp>
+# include <boost/python/numeric.hpp>
+# include <boost/python/object.hpp>
+# include <boost/python/object_protocol.hpp>
+# include <boost/python/object_protocol_core.hpp>
+# include <boost/python/opaque_pointer_converter.hpp>
+# include <boost/python/operators.hpp>
+# include <boost/python/other.hpp>
+# include <boost/python/overloads.hpp>
+# include <boost/python/pointee.hpp>
+# include <boost/python/pure_virtual.hpp>
+# include <boost/python/ptr.hpp>
+# include <boost/python/reference_existing_object.hpp>
+# include <boost/python/register_ptr_to_python.hpp>
+# include <boost/python/return_arg.hpp>
+# include <boost/python/return_internal_reference.hpp>
+# include <boost/python/return_opaque_pointer.hpp>
+# include <boost/python/return_value_policy.hpp>
+# include <boost/python/scope.hpp>
+# include <boost/python/self.hpp>
+# include <boost/python/slice_nil.hpp>
+# include <boost/python/str.hpp>
+# include <boost/python/to_python_converter.hpp>
+# include <boost/python/to_python_indirect.hpp>
+# include <boost/python/to_python_value.hpp>
+# include <boost/python/tuple.hpp>
+# include <boost/python/type_id.hpp>
+# include <boost/python/with_custodian_and_ward.hpp>
+
+#endif // PYTHON_DWA2002810_HPP
--- a/include/boost/python/arg_from_python.hpp
+++ b/include/boost/python/arg_from_python.hpp
@@ -0,0 +1,76 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef ARG_FROM_PYTHON_DWA2002128_HPP
+# define ARG_FROM_PYTHON_DWA2002128_HPP
+
+# include <boost/python/detail/prefix.hpp>
+# include <boost/python/converter/arg_from_python.hpp>
+# if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \
+    || BOOST_WORKAROUND(BOOST_INTEL_WIN, BOOST_TESTED_AT(800))
+# include <boost/type_traits/remove_cv.hpp>
+#endif
+
+namespace boost { namespace python { 
+
+template <class T>
+struct arg_from_python
+    : converter::select_arg_from_python<
+# if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \
+    || BOOST_WORKAROUND(BOOST_INTEL_WIN, BOOST_TESTED_AT(800))
+          typename boost::remove_cv<T>::type
+# else
+          T
+# endif 
+      >::type
+{
+    typedef typename converter::select_arg_from_python<
+# if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \
+    || BOOST_WORKAROUND(BOOST_INTEL_WIN, BOOST_TESTED_AT(800))
+          typename boost::remove_cv<T>::type
+# else
+          T
+# endif 
+        >::type base;
+    
+    arg_from_python(PyObject*);
+};
+
+// specialization for PyObject*
+template <>
+struct arg_from_python<PyObject*>
+{
+    typedef PyObject* result_type;
+    
+    arg_from_python(PyObject* p) : m_source(p) {}
+    bool convertible() const { return true; }
+    PyObject* operator()() const { return m_source; }
+ private:
+    PyObject* m_source;
+};
+
+template <>
+struct arg_from_python<PyObject* const&>
+{
+    typedef PyObject* const& result_type;
+    
+    arg_from_python(PyObject* p) : m_source(p) {}
+    bool convertible() const { return true; }
+    PyObject*const& operator()() const { return m_source; }
+ private:
+    PyObject* m_source;
+};
+
+//
+// implementations
+//
+template <class T>
+inline arg_from_python<T>::arg_from_python(PyObject* source)
+    : base(source)
+{
+}
+
+}} // namespace boost::python
+
+#endif // ARG_FROM_PYTHON_DWA2002128_HPP
--- a/include/boost/python/args.hpp
+++ b/include/boost/python/args.hpp
@@ -0,0 +1,175 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef KEYWORDS_DWA2002323_HPP
+# define KEYWORDS_DWA2002323_HPP
+
+# include <boost/python/detail/prefix.hpp>
+
+# include <boost/python/args_fwd.hpp>
+# include <boost/config.hpp>
+# include <boost/python/detail/preprocessor.hpp>
+# include <boost/python/detail/type_list.hpp>
+
+# include <boost/type_traits/is_reference.hpp>
+# include <boost/type_traits/remove_reference.hpp>
+# include <boost/type_traits/remove_cv.hpp>
+
+# include <boost/preprocessor/enum_params.hpp>
+# include <boost/preprocessor/repeat.hpp>
+# include <boost/preprocessor/facilities/intercept.hpp>
+# include <boost/preprocessor/iteration/local.hpp>
+
+# include <boost/python/detail/mpl_lambda.hpp>
+# include <boost/python/object_core.hpp>
+
+# include <boost/mpl/bool.hpp>
+
+# include <cstddef>
+# include <algorithm>
+
+namespace boost { namespace python {
+
+typedef detail::keywords<1> arg;
+typedef arg arg_; // gcc 2.96 workaround
+
+namespace detail
+{
+  template <std::size_t nkeywords>
+  struct keywords_base
+  {
+      BOOST_STATIC_CONSTANT(std::size_t, size = nkeywords);
+      
+      keyword_range range() const
+      {
+          return keyword_range(elements, elements + nkeywords);
+      }
+
+      keyword elements[nkeywords];
+
+      keywords<nkeywords+1>
+      operator,(python::arg const &k) const;
+
+      keywords<nkeywords + 1>
+      operator,(char const *name) const;
+  };
+  
+  template <std::size_t nkeywords>
+  struct keywords : keywords_base<nkeywords>
+  {
+  };
+
+  template <>
+  struct keywords<1> : keywords_base<1>
+  {
+      explicit keywords(char const *name)
+      {
+          elements[0].name = name;
+      }
+    
+      template <class T>
+      python::arg& operator=(T const& value)
+      {
+          object z(value);
+          elements[0].default_value = handle<>(python::borrowed(object(value).ptr()));
+          return *this;
+      }
+    
+      operator detail::keyword const&() const
+      {
+          return elements[0];
+      }
+  };
+
+  template <std::size_t nkeywords>
+  inline
+  keywords<nkeywords+1>
+  keywords_base<nkeywords>::operator,(python::arg const &k) const
+  {
+      keywords<nkeywords> const& l = *static_cast<keywords<nkeywords> const*>(this);
+      python::detail::keywords<nkeywords+1> res;
+      std::copy(l.elements, l.elements+nkeywords, res.elements);
+      res.elements[nkeywords] = k.elements[0];
+      return res;
+  }
+
+  template <std::size_t nkeywords>
+  inline
+  keywords<nkeywords + 1>
+  keywords_base<nkeywords>::operator,(char const *name) const
+  {
+      return this->operator,(python::arg(name));
+  }
+
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+  template<typename T>
+  struct is_keywords
+  {
+      BOOST_STATIC_CONSTANT(bool, value = false); 
+  };
+
+  template<std::size_t nkeywords>
+  struct is_keywords<keywords<nkeywords> >
+  {
+      BOOST_STATIC_CONSTANT(bool, value = true);
+  };
+  template <class T>
+  struct is_reference_to_keywords
+  {
+      BOOST_STATIC_CONSTANT(bool, is_ref = is_reference<T>::value);
+      typedef typename remove_reference<T>::type deref;
+      typedef typename remove_cv<deref>::type key_t;
+      BOOST_STATIC_CONSTANT(bool, is_key = is_keywords<key_t>::value);
+      BOOST_STATIC_CONSTANT(bool, value = (is_ref & is_key));
+      
+      typedef mpl::bool_<value> type;
+      BOOST_PYTHON_MPL_LAMBDA_SUPPORT(1,is_reference_to_keywords,(T))
+  };
+# else 
+  typedef char (&yes_keywords_t)[1];
+  typedef char (&no_keywords_t)[2];
+      
+  no_keywords_t is_keywords_test(...);
+
+  template<std::size_t nkeywords>
+  yes_keywords_t is_keywords_test(void (*)(keywords<nkeywords>&));
+
+  template<std::size_t nkeywords>
+  yes_keywords_t is_keywords_test(void (*)(keywords<nkeywords> const&));
+
+  template<typename T>
+  class is_reference_to_keywords
+  {
+   public:
+      BOOST_STATIC_CONSTANT(
+          bool, value = (
+              sizeof(detail::is_keywords_test( (void (*)(T))0 ))
+              == sizeof(detail::yes_keywords_t)));
+
+      typedef mpl::bool_<value> type;
+      BOOST_PYTHON_MPL_LAMBDA_SUPPORT(1,is_reference_to_keywords,(T))
+  };
+# endif 
+}
+
+inline detail::keywords<1> args(char const* name)
+{ 
+    return detail::keywords<1>(name);
+}
+
+#  define BOOST_PYTHON_ASSIGN_NAME(z, n, _) result.elements[n].name = name##n;
+#  define BOOST_PP_LOCAL_MACRO(n)                                               \
+inline detail::keywords<n> args(BOOST_PP_ENUM_PARAMS_Z(1, n, char const* name)) \
+{                                                                               \
+    detail::keywords<n> result;                                                 \
+    BOOST_PP_REPEAT_1(n, BOOST_PYTHON_ASSIGN_NAME, _)                           \
+    return result;                                                              \
+}
+#  define BOOST_PP_LOCAL_LIMITS (2, BOOST_PYTHON_MAX_ARITY)
+#  include BOOST_PP_LOCAL_ITERATE()
+
+}} // namespace boost::python
+
+
+# endif // KEYWORDS_DWA2002323_HPP
--- a/include/boost/python/args_fwd.hpp
+++ b/include/boost/python/args_fwd.hpp
@@ -0,0 +1,52 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef ARGS_FWD_DWA2002927_HPP
+# define ARGS_FWD_DWA2002927_HPP
+
+# include <boost/python/detail/prefix.hpp>
+
+# include <boost/python/handle.hpp>
+# include <boost/config.hpp>
+# include <cstddef>
+# include <utility>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  struct keyword
+  {
+      keyword(char const* name_=0)
+       : name(name_)
+      {}
+      
+      char const* name;
+      handle<> default_value;
+  };
+  
+  template <std::size_t nkeywords = 0> struct keywords;
+  
+  typedef std::pair<keyword const*, keyword const*> keyword_range;
+  
+  template <>
+  struct keywords<0>
+  {
+      BOOST_STATIC_CONSTANT(std::size_t, size = 0);
+      static keyword_range range() { return keyword_range(); }
+  };
+
+  namespace error
+  {
+    template <int keywords, int function_args>
+    struct more_keywords_than_function_arguments
+    {
+        typedef char too_many_keywords[keywords > function_args ? -1 : 1];
+    };
+  }
+}
+
+}} // namespace boost::python
+
+#endif // ARGS_FWD_DWA2002927_HPP
--- a/include/boost/python/back_reference.hpp
+++ b/include/boost/python/back_reference.hpp
@@ -0,0 +1,102 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BACK_REFERENCE_DWA2002510_HPP
+# define BACK_REFERENCE_DWA2002510_HPP
+
+# include <boost/python/detail/prefix.hpp>
+
+# include <boost/python/object_fwd.hpp>
+# include <boost/python/detail/dependent.hpp>
+# include <boost/python/detail/raw_pyobject.hpp>
+
+namespace boost { namespace python { 
+
+template <class T>
+struct back_reference
+{
+ private: // types
+    typedef typename detail::dependent<object,T>::type source_t;
+ public:
+    typedef T type;
+    
+    back_reference(PyObject*, T);
+    source_t const& source() const;
+    T get() const;
+ private:
+    source_t m_source;
+    T m_value;
+};
+
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template<typename T>
+class is_back_reference
+{
+ public:
+    BOOST_STATIC_CONSTANT(bool, value = false); 
+};
+
+template<typename T>
+class is_back_reference<back_reference<T> >
+{
+ public:
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+# else // no partial specialization
+
+}} // namespace boost::python
+
+#include <boost/type.hpp>
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  typedef char (&yes_back_reference_t)[1];
+  typedef char (&no_back_reference_t)[2];
+      
+  no_back_reference_t is_back_reference_test(...);
+
+  template<typename T>
+  yes_back_reference_t is_back_reference_test(boost::type< back_reference<T> >);
+}
+
+template<typename T>
+class is_back_reference
+{
+ public:
+    BOOST_STATIC_CONSTANT(
+        bool, value = (
+            sizeof(detail::is_back_reference_test(boost::type<T>()))
+            == sizeof(detail::yes_back_reference_t)));
+};
+
+# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+//
+// implementations
+//
+template <class T>
+back_reference<T>::back_reference(PyObject* p, T x)
+    : m_source(detail::borrowed_reference(p))
+      , m_value(x)
+{
+}
+
+template <class T>
+typename back_reference<T>::source_t const& back_reference<T>::source() const
+{
+    return m_source;
+}
+
+template <class T>
+T back_reference<T>::get() const
+{
+    return m_value;
+}
+
+}} // namespace boost::python
+
+#endif // BACK_REFERENCE_DWA2002510_HPP
--- a/include/boost/python/base_type_traits.hpp
+++ b/include/boost/python/base_type_traits.hpp
@@ -0,0 +1,43 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BASE_TYPE_TRAITS_DWA2002614_HPP
+# define BASE_TYPE_TRAITS_DWA2002614_HPP
+
+# include <boost/python/detail/prefix.hpp>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  struct unspecialized {};
+}
+
+// Derive from unspecialized so we can detect whether traits are
+// specialized
+template <class T> struct base_type_traits
+  : detail::unspecialized
+{};
+
+template <>
+struct base_type_traits<PyObject>
+{
+    typedef PyObject type;
+};
+
+template <>
+struct base_type_traits<PyTypeObject>
+{
+    typedef PyObject type;
+};
+
+template <>
+struct base_type_traits<PyMethodObject>
+{
+    typedef PyObject type;
+};
+
+}} // namespace boost::python
+
+#endif // BASE_TYPE_TRAITS_DWA2002614_HPP
--- a/include/boost/python/bases.hpp
+++ b/include/boost/python/bases.hpp
@@ -0,0 +1,68 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BASES_DWA2002321_HPP
+# define BASES_DWA2002321_HPP
+
+# include <boost/python/detail/prefix.hpp>
+# include <boost/type_traits/object_traits.hpp>
+# include <boost/python/detail/type_list.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/mpl/bool.hpp>
+# include <boost/preprocessor/enum_params_with_a_default.hpp>
+# include <boost/preprocessor/enum_params.hpp>
+
+namespace boost { namespace python { 
+
+# define BOOST_PYTHON_BASE_PARAMS BOOST_PP_ENUM_PARAMS_Z(1, BOOST_PYTHON_MAX_BASES, Base)
+
+  // A type list for specifying bases
+  template < BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PYTHON_MAX_BASES, typename Base, mpl::void_) >
+  struct bases : detail::type_list< BOOST_PYTHON_BASE_PARAMS >::type
+  {};
+
+  namespace detail
+  {
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    template <class T> struct specifies_bases
+        : mpl::false_
+    {
+    };
+    
+    template < BOOST_PP_ENUM_PARAMS_Z(1, BOOST_PYTHON_MAX_BASES, class Base) >
+    struct specifies_bases< bases< BOOST_PYTHON_BASE_PARAMS > >
+        : mpl::true_
+    {
+    };
+# else
+    template < BOOST_PP_ENUM_PARAMS(BOOST_PYTHON_MAX_BASES, class Base) >
+    static char is_bases_helper(bases< BOOST_PYTHON_BASE_PARAMS > const&);
+    
+    static char (& is_bases_helper(...) )[256];
+
+    template <class T>
+    struct specifies_bases
+    {
+     private:
+        static typename add_reference<T>::type make();
+        BOOST_STATIC_CONSTANT(bool, non_ref = !is_reference<T>::value);
+     public:
+        BOOST_STATIC_CONSTANT(bool, value = non_ref & (sizeof(is_bases_helper(make())) == 1));
+        typedef mpl::bool_<value> type;
+    };
+# endif
+    template <class T, class Prev = bases<> >
+    struct select_bases
+        : mpl::if_<
+                specifies_bases<T>
+                , T
+                , Prev
+          >
+    {
+    };
+  }
+# undef BOOST_PYTHON_BASE_PARAMS
+}} // namespace boost::python
+
+#endif // BASES_DWA2002321_HPP
--- a/include/boost/python/borrowed.hpp
+++ b/include/boost/python/borrowed.hpp
@@ -0,0 +1,21 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BORROWED_DWA2002614_HPP
+# define BORROWED_DWA2002614_HPP
+
+# include <boost/python/detail/prefix.hpp>
+# include <boost/python/detail/borrowed_ptr.hpp>
+
+namespace boost { namespace python { 
+
+template <class T>
+inline python::detail::borrowed<T>* borrowed(T* p)
+{
+    return (detail::borrowed<T>*)p;
+}
+    
+}} // namespace boost::python
+
+#endif // BORROWED_DWA2002614_HPP
--- a/include/boost/python/call.hpp
+++ b/include/boost/python/call.hpp
@@ -1,210 +1,79 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-//
-//  This work was funded in part by Lawrence Berkeley National Labs
-//
-//  This file generated for 5-argument member functions and 6-argument free
-//  functions by gen_call.py
+#if !defined(BOOST_PP_IS_ITERATING)

-#ifndef CALL_DWA20011214_HPP
-# define CALL_DWA20011214_HPP
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)

-# include <boost/python/detail/returning.hpp>
+# ifndef CALL_DWA2002411_HPP
+#  define CALL_DWA2002411_HPP

-namespace boost { namespace python { 
+# include <boost/python/detail/prefix.hpp>

-template <class R>
-PyObject* call(R (*f)(), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
+#  include <boost/type.hpp>

-template <class R, class A0>
-PyObject* call(R (*f)(A0), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
+#  include <boost/python/converter/arg_to_python.hpp>
+#  include <boost/python/converter/return_from_python.hpp>
+#  include <boost/python/detail/preprocessor.hpp>
+#  include <boost/python/detail/void_return.hpp>

-template <class R, class A0, class A1>
-PyObject* call(R (*f)(A0, A1), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
+#  include <boost/preprocessor/comma_if.hpp>
+#  include <boost/preprocessor/iterate.hpp>
+#  include <boost/preprocessor/repeat.hpp>
+#  include <boost/preprocessor/debug/line.hpp>
+#  include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#  include <boost/preprocessor/repetition/enum_binary_params.hpp>

-template <class R, class A0, class A1, class A2>
-PyObject* call(R (*f)(A0, A1, A2), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
+namespace boost { namespace python {

-template <class R, class A0, class A1, class A2, class A3>
-PyObject* call(R (*f)(A0, A1, A2, A3), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
+# define BOOST_PYTHON_FAST_ARG_TO_PYTHON_GET(z, n, _) \
+    , converter::arg_to_python<A##n>(a##n).get()

-template <class R, class A0, class A1, class A2, class A3, class A4>
-PyObject* call(R (*f)(A0, A1, A2, A3, A4), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-PyObject* call(R (*f)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-// Member functions
-template <class R, class A0>
-PyObject* call(R (A0::*f)(), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1>
-PyObject* call(R (A0::*f)(A1), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2>
-PyObject* call(R (A0::*f)(A1, A2), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3>
-PyObject* call(R (A0::*f)(A1, A2, A3), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-PyObject* call(R (A0::*f)(A1, A2, A3, A4), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-PyObject* call(R (A0::*f)(A1, A2, A3, A4, A5), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0>
-PyObject* call(R (A0::*f)() const, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1>
-PyObject* call(R (A0::*f)(A1) const, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2>
-PyObject* call(R (A0::*f)(A1, A2) const, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3>
-PyObject* call(R (A0::*f)(A1, A2, A3) const, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-PyObject* call(R (A0::*f)(A1, A2, A3, A4) const, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-PyObject* call(R (A0::*f)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0>
-PyObject* call(R (A0::*f)() volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1>
-PyObject* call(R (A0::*f)(A1) volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2>
-PyObject* call(R (A0::*f)(A1, A2) volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3>
-PyObject* call(R (A0::*f)(A1, A2, A3) volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-PyObject* call(R (A0::*f)(A1, A2, A3, A4) volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-PyObject* call(R (A0::*f)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0>
-PyObject* call(R (A0::*f)() const volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1>
-PyObject* call(R (A0::*f)(A1) const volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2>
-PyObject* call(R (A0::*f)(A1, A2) const volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3>
-PyObject* call(R (A0::*f)(A1, A2, A3) const volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-PyObject* call(R (A0::*f)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-PyObject* call(R (A0::*f)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
+#  define BOOST_PP_ITERATION_PARAMS_1 (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/call.hpp>))
+#  include BOOST_PP_ITERATE()

+#  undef BOOST_PYTHON_FAST_ARG_TO_PYTHON_GET

 }} // namespace boost::python

-#endif // CALL_DWA20011214_HPP
+# endif // CALL_DWA2002411_HPP

+#elif BOOST_PP_ITERATION_DEPTH() == 1
+# if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
+        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
+#  line BOOST_PP_LINE(__LINE__, call.hpp)
+# endif
+
+# define N BOOST_PP_ITERATION()
+
+template <
+    class R
+    BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class A)
+    >
+typename detail::returnable<R>::type
+call(PyObject* callable
+    BOOST_PP_COMMA_IF(N) BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, A, const& a)
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result = 
+        PyEval_CallFunction(
+            callable
+            , const_cast<char*>("(" BOOST_PP_REPEAT_1ST(N, BOOST_PYTHON_FIXED, "O") ")")
+            BOOST_PP_REPEAT_1ST(N, BOOST_PYTHON_FAST_ARG_TO_PYTHON_GET, nil)
+            );
+    
+    // This conversion *must not* be done in the same expression as
+    // the call, because, in the special case where the result is a
+    // reference a Python object which was created by converting a C++
+    // argument for passing to PyEval_CallFunction, its reference
+    // count will be 2 until the end of the full expression containing
+    // the conversion, and that interferes with dangling
+    // pointer/reference detection.
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+
+# undef N
+
+#endif
--- a/include/boost/python/call_method.hpp
+++ b/include/boost/python/call_method.hpp
@@ -0,0 +1,79 @@
+#if !defined(BOOST_PP_IS_ITERATING)
+
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+# ifndef CALL_METHOD_DWA2002411_HPP
+#  define CALL_METHOD_DWA2002411_HPP
+
+# include <boost/python/detail/prefix.hpp>
+
+#  include <boost/type.hpp>
+
+#  include <boost/python/converter/arg_to_python.hpp>
+#  include <boost/python/converter/return_from_python.hpp>
+#  include <boost/python/detail/preprocessor.hpp>
+#  include <boost/python/detail/void_return.hpp>
+
+#  include <boost/preprocessor/comma_if.hpp>
+#  include <boost/preprocessor/iterate.hpp>
+#  include <boost/preprocessor/repeat.hpp>
+#  include <boost/preprocessor/debug/line.hpp>
+#  include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#  include <boost/preprocessor/repetition/enum_binary_params.hpp>
+
+namespace boost { namespace python {
+
+# define BOOST_PYTHON_FAST_ARG_TO_PYTHON_GET(z, n, _) \
+    , converter::arg_to_python<A##n>(a##n).get()
+
+# define BOOST_PP_ITERATION_PARAMS_1 (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/call_method.hpp>))
+# include BOOST_PP_ITERATE()
+
+# undef BOOST_PYTHON_FAST_ARG_TO_PYTHON_GET
+
+}} // namespace boost::python
+
+# endif // CALL_METHOD_DWA2002411_HPP
+
+#elif BOOST_PP_ITERATION_DEPTH() == 1
+# if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
+        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
+#  line BOOST_PP_LINE(__LINE__, call_method.hpp)
+# endif 
+
+# define N BOOST_PP_ITERATION()
+
+template <
+    class R
+    BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class A)
+    >
+typename detail::returnable<R>::type
+call_method(PyObject* self, char const* name
+    BOOST_PP_COMMA_IF(N) BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, A, const& a)
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result = 
+        PyEval_CallMethod(
+            self
+            , const_cast<char*>(name)
+            , const_cast<char*>("(" BOOST_PP_REPEAT_1ST(N, BOOST_PYTHON_FIXED, "O") ")")
+            BOOST_PP_REPEAT_1ST(N, BOOST_PYTHON_FAST_ARG_TO_PYTHON_GET, nil)
+            );
+    
+    // This conversion *must not* be done in the same expression as
+    // the call, because, in the special case where the result is a
+    // reference a Python object which was created by converting a C++
+    // argument for passing to PyEval_CallFunction, its reference
+    // count will be 2 until the end of the full expression containing
+    // the conversion, and that interferes with dangling
+    // pointer/reference detection.
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+
+# undef N
+
+#endif // BOOST_PP_IS_ITERATING
--- a/include/boost/python/cast.hpp
+++ b/include/boost/python/cast.hpp
@@ -0,0 +1,106 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef CAST_DWA200269_HPP
+# define CAST_DWA200269_HPP
+
+# include <boost/python/detail/prefix.hpp>
+
+# include <boost/type_traits/same_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/type.hpp>
+# include <boost/python/base_type_traits.hpp>
+# include <boost/python/detail/convertible.hpp>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  template <class Source, class Target> inline Target* upcast_impl(Source*, Target*);
+  
+  template <class Source, class Target>
+  inline Target* upcast(Source* p, yes_convertible, no_convertible, Target*)
+  {
+      return p;
+  }
+
+  template <class Source, class Target>
+  inline Target* upcast(Source* p, no_convertible, no_convertible, Target*)
+  {
+      typedef typename base_type_traits<Source>::type base;
+      
+      return detail::upcast_impl((base*)p, (Target*)0);
+  }
+
+  template <bool is_same = true>
+  struct upcaster
+  {
+      template <class T>
+      static inline T* execute(T* x, T*) { return x; }
+  };
+  
+  template <>
+  struct upcaster<false>
+  {
+      template <class Source, class Target>
+      static inline Target* execute(Source* x, Target*)
+      {
+          return detail::upcast(
+              x, detail::convertible<Target*>::check(x)
+              , detail::convertible<Source*>::check((Target*)0)
+              , (Target*)0);
+      }
+  };
+
+
+  template <class Target, class Source>
+  inline Target* downcast(Source* p, yes_convertible)
+  {
+      return static_cast<Target*>(p);
+  }
+
+  template <class Target, class Source>
+  inline Target* downcast(Source* p, no_convertible, boost::type<Target>* = 0)
+  {
+      typedef typename base_type_traits<Source>::type base;
+      return (Target*)detail::downcast<base>(p, convertible<Source*>::check((base*)0));
+  }
+
+  template <class T>
+  inline void assert_castable(boost::type<T>* = 0)
+  {
+      typedef char must_be_a_complete_type[sizeof(T)];
+  }
+
+  template <class Source, class Target>
+  inline Target* upcast_impl(Source* x, Target*)
+  {
+      typedef typename add_cv<Source>::type src_t;
+      typedef typename add_cv<Target>::type target_t;
+      bool const same = is_same<src_t,target_t>::value;
+      
+      return detail::upcaster<same>::execute(x, (Target*)0);
+  }
+}
+
+template <class Target, class Source>
+inline Target* upcast(Source* x, Target* = 0)
+{
+    detail::assert_castable<Source>();
+    detail::assert_castable<Target>();
+    return detail::upcast_impl(x, (Target*)0);
+    
+}
+
+template <class Target, class Source>
+inline Target* downcast(Source* x, Target* = 0)
+{
+    detail::assert_castable<Source>();
+    detail::assert_castable<Target>();
+    return detail::downcast<Target>(x, detail::convertible<Source*>::check((Target*)0));
+}
+
+}} // namespace boost::python
+
+#endif // CAST_DWA200269_HPP
--- a/include/boost/python/class.hpp
+++ b/include/boost/python/class.hpp
@@ -0,0 +1,654 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef CLASS_DWA200216_HPP
+# define CLASS_DWA200216_HPP
+
+# include <boost/python/detail/prefix.hpp>
+
+# include <boost/noncopyable.hpp>
+
+# include <boost/python/class_fwd.hpp>
+# include <boost/python/object/class.hpp>
+
+# include <boost/python/object.hpp>
+# include <boost/python/type_id.hpp>
+# include <boost/python/data_members.hpp>
+# include <boost/python/make_function.hpp>
+# include <boost/python/signature.hpp>
+# include <boost/python/init.hpp>
+# include <boost/python/args_fwd.hpp>
+
+# include <boost/python/object/class_metadata.hpp>
+# include <boost/python/object/pickle_support.hpp>
+# include <boost/python/object/add_to_namespace.hpp>
+
+# include <boost/python/detail/overloads_fwd.hpp>
+# include <boost/python/detail/operator_id.hpp>
+# include <boost/python/detail/def_helper.hpp>
+# include <boost/python/detail/force_instantiate.hpp>
+# include <boost/python/detail/unwrap_type_id.hpp>
+# include <boost/python/detail/unwrap_wrapper.hpp>
+
+# include <boost/type_traits/is_same.hpp>
+# include <boost/type_traits/is_member_function_pointer.hpp>
+# include <boost/type_traits/is_polymorphic.hpp>
+
+# include <boost/mpl/size.hpp>
+# include <boost/mpl/for_each.hpp>
+# include <boost/mpl/bool.hpp>
+# include <boost/mpl/not.hpp>
+
+# include <boost/detail/workaround.hpp>
+
+# if BOOST_WORKAROUND(__MWERKS__, <= 0x3004)                        \
+    /* pro9 reintroduced the bug */                                 \
+    || (BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
+        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))   \
+    || BOOST_WORKAROUND(__GNUC__, < 3)
+
+#  define BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING 1
+
+# endif
+
+# ifdef BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING
+#  include <boost/mpl/and.hpp>
+#  include <boost/type_traits/is_member_pointer.hpp>
+# endif
+
+namespace boost { namespace python {
+
+template <class DerivedVisitor> class def_visitor;
+
+enum no_init_t { no_init };
+
+namespace detail
+{
+  // This function object is used with mpl::for_each to write the id
+  // of the type a pointer to which is passed as its 2nd compile-time
+  // argument. into the iterator pointed to by its runtime argument
+  struct write_type_id
+  {
+      write_type_id(type_info**p) : p(p) {}
+
+      // Here's the runtime behavior
+      template <class T>
+      void operator()(T*) const
+      {
+          *(*p)++ = type_id<T>();
+      }
+
+      type_info** p;
+  };
+
+  template <class T>
+  struct is_data_member_pointer
+      : mpl::and_<
+            is_member_pointer<T>
+          , mpl::not_<is_member_function_pointer<T> >
+        >
+  {};
+  
+# ifdef BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING
+#  define BOOST_PYTHON_DATA_MEMBER_HELPER(D) , detail::is_data_member_pointer<D>()
+#  define BOOST_PYTHON_YES_DATA_MEMBER , mpl::true_
+#  define BOOST_PYTHON_NO_DATA_MEMBER , mpl::false_
+# elif defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+#  define BOOST_PYTHON_DATA_MEMBER_HELPER(D) , 0
+#  define BOOST_PYTHON_YES_DATA_MEMBER , int
+#  define BOOST_PYTHON_NO_DATA_MEMBER , ...
+# else 
+#  define BOOST_PYTHON_DATA_MEMBER_HELPER(D)
+#  define BOOST_PYTHON_YES_DATA_MEMBER
+#  define BOOST_PYTHON_NO_DATA_MEMBER
+# endif
+  
+  namespace error
+  {
+    //
+    // A meta-assertion mechanism which prints nice error messages and
+    // backtraces on lots of compilers. Usage:
+    //
+    //      assertion<C>::failed
+    //
+    // where C is an MPL metafunction class
+    //
+    
+    template <class C> struct assertion_failed { };
+    template <class C> struct assertion_ok { typedef C failed; };
+
+    template <class C>
+    struct assertion
+        : mpl::if_<C, assertion_ok<C>, assertion_failed<C> >::type
+    {};
+
+    //
+    // Checks for validity of arguments used to define virtual
+    // functions with default implementations.
+    //
+    
+    template <class Default>
+    void not_a_derived_class_member(Default) {}
+    
+    template <class T, class Fn>
+    struct virtual_function_default
+    {
+        template <class Default>
+        static void
+        must_be_derived_class_member(Default const&)
+        {
+            typedef typename assertion<mpl::not_<is_same<Default,Fn> > >::failed test0;
+# if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
+            typedef typename assertion<is_polymorphic<T> >::failed test1;
+# endif 
+            typedef typename assertion<is_member_function_pointer<Fn> >::failed test2;
+            not_a_derived_class_member<Default>(Fn());
+        }
+    };
+  }
+}
+
+// This is the primary mechanism through which users will expose
+// C++ classes to Python.
+template <
+    class W // class being wrapped
+    , class X1 // = detail::not_specified
+    , class X2 // = detail::not_specified
+    , class X3 // = detail::not_specified
+    >
+class class_ : public objects::class_base
+{
+ public: // types
+    typedef objects::class_base base;
+    typedef class_<W,X1,X2,X3> self;
+    typedef typename objects::class_metadata<W,X1,X2,X3> metadata;
+    typedef W wrapped_type;
+    
+ private: // types
+
+    // A helper class which will contain an array of id objects to be
+    // passed to the base class constructor
+    struct id_vector
+    {
+        typedef typename metadata::bases bases;
+        
+        id_vector()
+        {
+            // Stick the derived class id into the first element of the array
+            ids[0] = detail::unwrap_type_id((W*)0, (W*)0);
+
+            // Write the rest of the elements into succeeding positions.
+            type_info* p = ids + 1;
+            mpl::for_each(detail::write_type_id(&p), (bases*)0, (add_pointer<mpl::_>*)0);
+        }
+
+        BOOST_STATIC_CONSTANT(
+            std::size_t, size = mpl::size<bases>::value + 1);
+        type_info ids[size];
+    };
+    friend struct id_vector;
+
+ public: // constructors
+    
+    // Construct with the class name, with or without docstring, and default __init__() function
+    class_(char const* name, char const* doc = 0);
+
+    // Construct with class name, no docstring, and an uncallable __init__ function
+    class_(char const* name, no_init_t);
+
+    // Construct with class name, docstring, and an uncallable __init__ function
+    class_(char const* name, char const* doc, no_init_t);
+
+    // Construct with class name and init<> function
+    template <class DerivedT>
+    inline class_(char const* name, init_base<DerivedT> const& i)
+        : base(name, id_vector::size, id_vector().ids)
+    {
+        this->initialize(i);
+    }
+
+    // Construct with class name, docstring and init<> function
+    template <class DerivedT>
+    inline class_(char const* name, char const* doc, init_base<DerivedT> const& i)
+        : base(name, id_vector::size, id_vector().ids, doc)
+    {
+        this->initialize(i);
+    }
+
+ public: // member functions
+    
+    // Generic visitation
+    template <class Derived>
+    self& def(def_visitor<Derived> const& visitor)
+    {
+        visitor.visit(*this);
+        return *this;
+    }
+
+    // Wrap a member function or a non-member function which can take
+    // a T, T cv&, or T cv* as its first parameter, a callable
+    // python object, or a generic visitor.
+    template <class F>
+    self& def(char const* name, F f)
+    {
+        this->def_impl(
+            detail::unwrap_wrapper((W*)0)
+          , name, f, detail::def_helper<char const*>(0), &f);
+        return *this;
+    }
+
+    template <class A1, class A2>
+    self& def(char const* name, A1 a1, A2 const& a2)
+    {
+        this->def_maybe_overloads(name, a1, a2, &a2);
+        return *this;
+    }
+
+    template <class Fn, class A1, class A2>
+    self& def(char const* name, Fn fn, A1 const& a1, A2 const& a2)
+    {
+        //  The arguments are definitely:
+        //      def(name, function, policy, doc_string)
+        //      def(name, function, doc_string, policy)
+
+        this->def_impl(
+            detail::unwrap_wrapper((W*)0)
+          , name, fn
+          , detail::def_helper<A1,A2>(a1,a2)
+          , &fn);
+
+        return *this;
+    }
+
+    template <class Fn, class A1, class A2, class A3>
+    self& def(char const* name, Fn fn, A1 const& a1, A2 const& a2, A3 const& a3)
+    {
+        this->def_impl(
+            detail::unwrap_wrapper((W*)0)
+          , name, fn
+          , detail::def_helper<A1,A2,A3>(a1,a2,a3)
+          , &fn);
+
+        return *this;
+    }
+
+    //
+    // Data member access
+    //
+    template <class D>
+    self& def_readonly(char const* name, D const& d, char const* doc=0)
+    {
+        return this->def_readonly_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D));
+    }
+
+    template <class D>
+    self& def_readwrite(char const* name, D const& d, char const* doc=0)
+    {
+        return this->def_readwrite_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D));
+    }
+    
+    template <class D>
+    self& def_readonly(char const* name, D& d, char const* doc=0)
+    {
+        return this->def_readonly_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D));
+    }
+
+    template <class D>
+    self& def_readwrite(char const* name, D& d, char const* doc=0)
+    {
+        return this->def_readwrite_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D));
+    }
+
+    // Property creation
+# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+    template <class Get>
+    self& add_property(char const* name, Get fget, char const* docstr = 0)
+    {
+        base::add_property(name, this->make_getter(fget), docstr);
+        return *this;
+    }
+
+    template <class Get, class Set>
+    self& add_property(char const* name, Get fget, Set fset, char const* docstr = 0)
+    {
+        base::add_property(
+            name, this->make_getter(fget), this->make_setter(fset), docstr);
+        return *this;
+    }
+# else
+ private:
+    template <class Get>
+    self& add_property_impl(char const* name, Get fget, char const* docstr, int)
+    {
+        base::add_property(name, this->make_getter(fget), docstr);
+        return *this;
+    }
+
+    template <class Get, class Set>
+    self& add_property_impl(char const* name, Get fget, Set fset, ...)
+    {
+        base::add_property(
+            name, this->make_getter(fget), this->make_setter(fset), 0);
+        return *this;
+    }
+
+ public:    
+    template <class Get>
+    self& add_property(char const* name, Get fget)
+    {
+        base::add_property(name, this->make_getter(fget), 0);
+        return *this;
+    }
+
+    template <class Get, class DocStrOrSet>
+    self& add_property(char const* name, Get fget, DocStrOrSet docstr_or_set)
+    {
+        this->add_property_impl(name, this->make_getter(fget), docstr_or_set, 0);
+        return *this;
+    }
+
+    template <class Get, class Set>
+    self&
+    add_property(char const* name, Get fget, Set fset, char const* docstr)
+    {
+        base::add_property(
+            name, this->make_getter(fget), this->make_setter(fset), docstr);
+        return *this;
+    }
+# endif
+        
+    template <class Get>
+    self& add_static_property(char const* name, Get fget)
+    {
+        base::add_static_property(name, object(fget));
+        return *this;
+    }
+
+    template <class Get, class Set>
+    self& add_static_property(char const* name, Get fget, Set fset)
+    {
+        base::add_static_property(name, object(fget), object(fset));
+        return *this;
+    }
+        
+    template <class U>
+    self& setattr(char const* name, U const& x)
+    {
+        this->base::setattr(name, object(x));
+        return *this;
+    }
+
+    // Pickle support
+    template <typename PickleSuiteType>
+    self& def_pickle(PickleSuiteType const& x)
+    {
+      error_messages::must_be_derived_from_pickle_suite(x);
+      detail::pickle_suite_finalize<PickleSuiteType>::register_(
+        *this,
+        &PickleSuiteType::getinitargs,
+        &PickleSuiteType::getstate,
+        &PickleSuiteType::setstate,
+        PickleSuiteType::getstate_manages_dict());
+      return *this;
+    }
+
+    self& enable_pickling()
+    {
+        this->base::enable_pickling_(false);
+        return *this;
+    }
+
+    self& staticmethod(char const* name)
+    {
+        this->make_method_static(name);
+        return *this;
+    }
+ private: // helper functions
+
+    // Builds a method for this class around the given [member]
+    // function pointer or object, appropriately adjusting the type of
+    // the first signature argument so that if f is a member of a
+    // (possibly not wrapped) base class of T, an lvalue argument of
+    // type T will be required.
+    //
+    // @group PropertyHelpers {
+    template <class F>
+    object make_getter(F f)
+    {
+        typedef typename api::is_object_operators<F>::type is_obj_or_proxy;
+        
+        return this->make_fn_impl(
+            detail::unwrap_wrapper((W*)0)
+          , f, is_obj_or_proxy(), (char*)0, detail::is_data_member_pointer<F>()
+        );
+    }
+    
+    template <class F>
+    object make_setter(F f)
+    {
+        typedef typename api::is_object_operators<F>::type is_obj_or_proxy;
+        
+        return this->make_fn_impl(
+            detail::unwrap_wrapper((W*)0)
+          , f, is_obj_or_proxy(), (int*)0, detail::is_data_member_pointer<F>()
+        );
+    }
+    
+    template <class T, class F>
+    object make_fn_impl(T*, F const& f, mpl::false_, void*, mpl::false_)
+    {
+        return python::make_function(f, default_call_policies(), detail::get_signature(f, (T*)0));
+    }
+
+    template <class T, class D, class B>
+    object make_fn_impl(T*, D B::*pm_, mpl::false_, char*, mpl::true_)
+    {
+        D T::*pm = pm_;
+        return python::make_getter(pm);
+    }
+
+    template <class T, class D, class B>
+    object make_fn_impl(T*, D B::*pm_, mpl::false_, int*, mpl::true_)
+    {
+        D T::*pm = pm_;
+        return python::make_setter(pm);
+    }
+
+    template <class T, class F>
+    object make_fn_impl(T*, F const& x, mpl::true_, void*, mpl::false_)
+    {
+        return x;
+    }
+    // }
+    
+    template <class D, class B>
+    self& def_readonly_impl(
+        char const* name, D B::*pm_, char const* doc BOOST_PYTHON_YES_DATA_MEMBER)
+    {
+        return this->add_property(name, pm_, doc);
+    }
+
+    template <class D, class B>
+    self& def_readwrite_impl(
+        char const* name, D B::*pm_, char const* doc BOOST_PYTHON_YES_DATA_MEMBER)
+    {
+        return this->add_property(name, pm_, pm_, doc);
+    }
+
+    template <class D>
+    self& def_readonly_impl(
+        char const* name, D& d, char const* BOOST_PYTHON_NO_DATA_MEMBER)
+    {
+        return this->add_static_property(name, python::make_getter(d));
+    }
+
+    template <class D>
+    self& def_readwrite_impl(
+        char const* name, D& d, char const* BOOST_PYTHON_NO_DATA_MEMBER)
+    {
+        return this->add_static_property(name, python::make_getter(d), python::make_setter(d));
+    }
+
+    template <class DefVisitor>
+    inline void initialize(DefVisitor const& i)
+    {
+        metadata::register_(); // set up runtime metadata/conversions
+        
+        typedef typename metadata::holder holder;
+        this->set_instance_size( objects::additional_instance_size<holder>::value );
+        
+        this->def(i);
+    }
+    
+    inline void initialize(no_init_t)
+    {
+        metadata::register_(); // set up runtime metadata/conversions
+        this->def_no_init();
+    }
+    
+    //
+    // These two overloads discriminate between def() as applied to a
+    // generic visitor and everything else.
+    //
+    // @group def_impl {
+    template <class T, class Helper, class LeafVisitor, class Visitor>
+    inline void def_impl(
+        T*
+      , char const* name
+      , LeafVisitor
+      , Helper const& helper
+      , def_visitor<Visitor> const* v
+    )
+    {
+        v->visit(*this, name,  helper);
+    }
+
+    template <class T, class Fn, class Helper>
+    inline void def_impl(
+        T*
+      , char const* name
+      , Fn fn
+      , Helper const& helper
+      , ...
+    )
+    {
+        objects::add_to_namespace(
+            *this
+          , name
+          , make_function(
+                fn
+              , helper.policies()
+              , helper.keywords()
+              , detail::get_signature(fn, (T*)0)
+            )
+          , helper.doc()
+        );
+
+        this->def_default(name, fn, helper, mpl::bool_<Helper::has_default_implementation>());
+    }
+    // }
+
+    //
+    // These two overloads handle the definition of default
+    // implementation overloads for virtual functions. The second one
+    // handles the case where no default implementation was specified.
+    //
+    // @group def_default {
+    template <class Fn, class Helper>
+    inline void def_default(
+        char const* name
+        , Fn
+        , Helper const& helper
+        , mpl::bool_<true>)
+    {
+        detail::error::virtual_function_default<W,Fn>::must_be_derived_class_member(
+            helper.default_implementation());
+            
+        objects::add_to_namespace(
+            *this, name,
+            make_function(
+                helper.default_implementation(), helper.policies(), helper.keywords())
+            );
+    }
+    
+    template <class Fn, class Helper>
+    inline void def_default(char const*, Fn, Helper const&, mpl::bool_<false>)
+    { }
+    // }
+    
+    //
+    // These two overloads discriminate between def() as applied to
+    // regular functions and def() as applied to the result of
+    // BOOST_PYTHON_FUNCTION_OVERLOADS(). The final argument is used to
+    // discriminate.
+    //
+    // @group def_maybe_overloads {
+    template <class OverloadsT, class SigT>
+    void def_maybe_overloads(
+        char const* name
+        , SigT sig
+        , OverloadsT const& overloads
+        , detail::overloads_base const*)
+
+    {
+        //  convert sig to a type_list (see detail::get_signature in signature.hpp)
+        //  before calling detail::define_with_defaults.
+        detail::define_with_defaults(
+            name, overloads, *this, detail::get_signature(sig));
+    }
+
+    template <class Fn, class A1>
+    void def_maybe_overloads(
+        char const* name
+        , Fn fn
+        , A1 const& a1
+        , ...)
+    {
+        this->def_impl(
+            detail::unwrap_wrapper((W*)0)
+          , name
+          , fn
+          , detail::def_helper<A1>(a1)
+          , &fn
+        );
+
+    }
+    // }
+};
+
+
+//
+// implementations
+//
+
+template <class W, class X1, class X2, class X3>
+inline class_<W,X1,X2,X3>::class_(char const* name, char const* doc)
+    : base(name, id_vector::size, id_vector().ids, doc)
+{
+    this->initialize(init<>());
+//  select_holder::assert_default_constructible();
+}
+
+template <class W, class X1, class X2, class X3>
+inline class_<W,X1,X2,X3>::class_(char const* name, no_init_t)
+    : base(name, id_vector::size, id_vector().ids)
+{
+    this->initialize(no_init);
+}
+
+template <class W, class X1, class X2, class X3>
+inline class_<W,X1,X2,X3>::class_(char const* name, char const* doc, no_init_t)
+    : base(name, id_vector::size, id_vector().ids, doc)
+{
+    this->initialize(no_init);
+}
+
+}} // namespace boost::python
+
+# undef BOOST_PYTHON_DATA_MEMBER_HELPER
+# undef BOOST_PYTHON_YES_DATA_MEMBER
+# undef BOOST_PYTHON_NO_DATA_MEMBER
+# undef BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING
+
+#endif // CLASS_DWA200216_HPP
--- a/include/boost/python/class_fwd.hpp
+++ b/include/boost/python/class_fwd.hpp
@@ -0,0 +1,24 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef CLASS_FWD_DWA200222_HPP
+# define CLASS_FWD_DWA200222_HPP
+
+# include <boost/python/detail/prefix.hpp>
+# include <boost/python/detail/not_specified.hpp>
+
+namespace boost { namespace python { 
+
+template <
+    class T // class being wrapped
+    // arbitrarily-ordered optional arguments. Full qualification needed for MSVC6
+    , class X1 = ::boost::python::detail::not_specified
+    , class X2 = ::boost::python::detail::not_specified
+    , class X3 = ::boost::python::detail::not_specified
+    >
+class class_;
+
+}} // namespace boost::python
+
+#endif // CLASS_FWD_DWA200222_HPP
--- a/include/boost/python/convert.hpp
+++ b/include/boost/python/convert.hpp
@@ -1,82 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef CONVERT_DWA20011129_HPP
-# define CONVERT_DWA20011129_HPP
-
-# include <boost/python/converter/target.hpp>
-# include <boost/python/converter/source.hpp>
-# include <boost/python/converter/wrap.hpp>
-# include <boost/python/converter/unwrap.hpp>
-
-namespace boost { namespace python {
-
-namespace detail
-{
-  template <class T>
-  struct converter_gen
-  {
-      typedef T value_type;
-      typedef typename converter::source<value_type>::type source;
-      typedef converter::wrap_<source> wrap;
-      typedef converter::wrap_more_<source> wrap_more;
-
-      typedef typename converter::target<value_type>::type target;
-      typedef converter::unwrap_<target> unwrap;
-      typedef converter::unwrap_more_<target> unwrap_more;
-  };
-}
-
-template <class T>
-struct wrap : detail::converter_gen<T>::wrap
-{
-    typedef typename detail::converter_gen<T>::wrap base;
-};
-
-template <class T>
-struct wrap_more : detail::converter_gen<T>::wrap_more
-{
-    typedef typename detail::converter_gen<T>::wrap_more base;
-    wrap_more(converter::handle& prev);
-};
-
-template <class T>
-struct unwrap : detail::converter_gen<T>::unwrap
-{
-    typedef typename detail::converter_gen<T>::unwrap base;
-    unwrap(PyObject*);
-};
-
-template <class T>
-struct unwrap_more : detail::converter_gen<T>::unwrap_more
-{
-    typedef typename detail::converter_gen<T>::unwrap_more base;
-    unwrap_more(PyObject*, converter::handle& prev);
-};
-
-//
-// implementations
-//
-template <class T>
-inline wrap_more<T>::wrap_more(converter::handle& prev)
-    : base(prev)
-{
-}
-
-template <class T>
-inline unwrap<T>::unwrap(PyObject* source)
-    : base(source)
-{
-}
-
-template <class T>
-inline unwrap_more<T>::unwrap_more(PyObject* source, converter::handle& prev)
-    : base(source, prev)
-{
-}
-
-}} // namespace boost::python
-
-#endif // CONVERT_DWA20011129_HPP
--- a/include/boost/python/converter/arg_from_python.hpp
+++ b/include/boost/python/converter/arg_from_python.hpp
@@ -0,0 +1,336 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef ARG_FROM_PYTHON_DWA2002127_HPP
+# define ARG_FROM_PYTHON_DWA2002127_HPP
+
+# include <boost/python/detail/prefix.hpp>
+# include <boost/python/converter/from_python.hpp>
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/python/converter/rvalue_from_python_data.hpp>
+# include <boost/mpl/eval_if.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/mpl/identity.hpp>
+# include <boost/mpl/and.hpp>
+# include <boost/mpl/or.hpp>
+# include <boost/mpl/not.hpp>
+# include <boost/python/converter/registry.hpp>
+# include <boost/python/converter/registered.hpp>
+# include <boost/python/converter/registered_pointee.hpp>
+# include <boost/python/detail/void_ptr.hpp>
+# include <boost/python/back_reference.hpp>
+# include <boost/python/detail/referent_storage.hpp>
+# include <boost/python/converter/obj_mgr_arg_from_python.hpp>
+
+namespace boost { namespace python
+{
+  template <class T> struct arg_from_python;
+}}
+
+// This header defines Python->C++ function argument converters,
+// parametrized on the argument type.
+
+namespace boost { namespace python { namespace converter {
+
+//
+// lvalue converters
+//
+//   These require that an lvalue of the type U is stored somewhere in
+//   the Python object being converted.
+
+// Used when T == U*const&
+template <class T>
+struct pointer_cref_arg_from_python
+{
+    typedef T result_type;
+    
+    pointer_cref_arg_from_python(PyObject*);
+    T operator()() const;
+    bool convertible() const;
+    
+ private: // storage for a U*
+    // needed because not all compilers will let us declare U* as the
+    // return type of operator() -- we return U*const& instead
+    typename python::detail::referent_storage<T>::type m_result;
+};
+
+// Base class for pointer and reference converters
+struct arg_lvalue_from_python_base
+{
+ public: // member functions
+    arg_lvalue_from_python_base(void* result);
+    bool convertible() const;
+    
+ protected: // member functions
+    void*const& result() const;
+    
+ private: // data members
+    void* m_result;
+};
+
+// Used when T == U* 
+template <class T>
+struct pointer_arg_from_python : arg_lvalue_from_python_base
+{
+    typedef T result_type;
+    
+    pointer_arg_from_python(PyObject*);
+    T operator()() const;
+};
+
+// Used when T == U& and (T != V const& or T == W volatile&)
+template <class T>
+struct reference_arg_from_python : arg_lvalue_from_python_base
+{
+    typedef T result_type;
+    
+    reference_arg_from_python(PyObject*);
+    T operator()() const;
+};
+
+// ===================
+
+//
+// rvalue converters
+//
+//   These require only that an object of type T can be created from
+//   the given Python object, but not that the T object exist
+//   somewhere in storage.
+//
+
+// Used when T is a plain value (non-pointer, non-reference) type or
+// a (non-volatile) const reference to a plain value type.
+template <class T>
+struct arg_rvalue_from_python
+{
+    typedef typename boost::add_reference<
+        T
+        // We can't add_const here, or it would be impossible to pass
+        // auto_ptr<U> args from Python to C++
+    >::type result_type;
+    
+    arg_rvalue_from_python(PyObject*);
+    bool convertible() const;
+
+# if BOOST_MSVC < 1301 || _MSC_FULL_VER > 13102196
+    typename arg_rvalue_from_python<T>::
+# endif 
+    result_type operator()();
+    
+ private:
+    rvalue_from_python_data<result_type> m_data;
+    PyObject* m_source;
+};
+
+
+// ==================
+
+// Converts to a (PyObject*,T) bundle, for when you need a reference
+// back to the Python object
+template <class T>
+struct back_reference_arg_from_python
+    : boost::python::arg_from_python<typename T::type>
+{
+    typedef T result_type;
+    
+    back_reference_arg_from_python(PyObject*);
+    T operator()();
+ private:
+    typedef boost::python::arg_from_python<typename T::type> base;
+    PyObject* m_source;
+};
+
+
+// ==================
+
+template <class C, class T, class F>
+struct if_2
+{
+    typedef typename mpl::eval_if<C, mpl::identity<T>, F>::type type;
+};
+
+// This metafunction selects the appropriate arg_from_python converter
+// type for an argument of type T.
+template <class T>
+struct select_arg_from_python
+{
+    typedef typename if_2<
+        is_object_manager<T>
+      , object_manager_value_arg_from_python<T>
+      , if_2<
+            is_reference_to_object_manager<T>
+          , object_manager_ref_arg_from_python<T>
+          , if_2<
+                is_pointer<T>
+              , pointer_arg_from_python<T>
+              , if_2<
+                    mpl::and_<
+                        indirect_traits::is_reference_to_pointer<T>
+                      , indirect_traits::is_reference_to_const<T>
+                      , mpl::not_<indirect_traits::is_reference_to_volatile<T> >
+                        >
+                  , pointer_cref_arg_from_python<T>
+                  , if_2<
+                        mpl::or_<
+                            indirect_traits::is_reference_to_non_const<T>
+                          , indirect_traits::is_reference_to_volatile<T>
+                        >
+                      , reference_arg_from_python<T>
+                      , mpl::if_<
+                            boost::python::is_back_reference<T>
+                          , back_reference_arg_from_python<T>
+                          , arg_rvalue_from_python<T>
+                        >
+                    >
+                >
+            >
+        >
+    >::type type;
+};
+
+// ==================
+
+//
+// implementations
+//
+
+// arg_lvalue_from_python_base
+//
+inline arg_lvalue_from_python_base::arg_lvalue_from_python_base(void* result)
+    : m_result(result)
+{
+}
+
+inline bool arg_lvalue_from_python_base::convertible() const
+{
+    return m_result != 0;
+}
+
+inline void*const& arg_lvalue_from_python_base::result() const
+{
+    return m_result;
+}
+
+// pointer_cref_arg_from_python
+//
+namespace detail
+{
+  // null_ptr_reference -- a function returning a reference to a null
+  // pointer of type U. Needed so that extractors for T*const& can
+  // convert Python's None.
+  template <class T>
+  struct null_ptr_owner
+  {
+      static T value;
+  };
+  template <class T> T null_ptr_owner<T>::value = 0;
+  
+  template <class U>
+  inline U& null_ptr_reference(U&(*)())
+  {
+      return null_ptr_owner<U>::value;
+  }
+}
+
+template <class T>
+inline pointer_cref_arg_from_python<T>::pointer_cref_arg_from_python(PyObject* p)
+{
+    // T == U*const&: store a U* in the m_result storage. Nonzero
+    // indicates success.  If find returns nonzero, it's a pointer to
+    // a U object.
+    python::detail::write_void_ptr_reference(
+        m_result.bytes
+        , p == Py_None ? p : converter::get_lvalue_from_python(p, registered_pointee<T>::converters)
+        , (T(*)())0);
+}
+
+template <class T>
+inline bool pointer_cref_arg_from_python<T>::convertible() const
+{
+    return python::detail::void_ptr_to_reference(m_result.bytes, (T(*)())0) != 0;
+}
+template <class T>
+inline T pointer_cref_arg_from_python<T>::operator()() const
+{
+    return (*(void**)m_result.bytes == Py_None)  // None ==> 0
+        ? detail::null_ptr_reference((T(*)())0)
+        // Otherwise, return a U*const& to the m_result storage.
+        : python::detail::void_ptr_to_reference(m_result.bytes, (T(*)())0);
+}
+
+// pointer_arg_from_python
+//
+template <class T>
+inline pointer_arg_from_python<T>::pointer_arg_from_python(PyObject* p)
+    : arg_lvalue_from_python_base(
+        p == Py_None ? p : converter::get_lvalue_from_python(p, registered_pointee<T>::converters))
+{
+}
+
+template <class T>
+inline T pointer_arg_from_python<T>::operator()() const
+{
+    return (result() == Py_None) ? 0 : T(result());
+}
+
+// reference_arg_from_python
+//
+template <class T>
+inline reference_arg_from_python<T>::reference_arg_from_python(PyObject* p)
+    : arg_lvalue_from_python_base(converter::get_lvalue_from_python(p,registered<T>::converters))
+{
+}
+
+template <class T>
+inline T reference_arg_from_python<T>::operator()() const
+{
+    return python::detail::void_ptr_to_reference(result(), (T(*)())0);
+}
+
+
+// arg_rvalue_from_python
+//
+template <class T>
+inline arg_rvalue_from_python<T>::arg_rvalue_from_python(PyObject* obj)
+    : m_data(converter::rvalue_from_python_stage1(obj, registered<T>::converters))
+    , m_source(obj)
+{
+}
+
+template <class T>
+inline bool arg_rvalue_from_python<T>::convertible() const
+{
+    return m_data.stage1.convertible != 0;
+}
+
+template <class T>
+inline typename arg_rvalue_from_python<T>::result_type
+arg_rvalue_from_python<T>::operator()()
+{
+    if (m_data.stage1.construct != 0)
+        m_data.stage1.construct(m_source, &m_data.stage1);
+    
+    return python::detail::void_ptr_to_reference(m_data.stage1.convertible, (result_type(*)())0);
+}
+
+// back_reference_arg_from_python
+//
+template <class T>
+back_reference_arg_from_python<T>::back_reference_arg_from_python(PyObject* x)
+  : base(x), m_source(x)
+{
+}
+
+template <class T>
+inline T
+back_reference_arg_from_python<T>::operator()()
+{
+    return T(m_source, base::operator()());
+}
+
+}}} // namespace boost::python::converter
+
+#endif // ARG_FROM_PYTHON_DWA2002127_HPP
--- a/include/boost/python/converter/arg_to_python.hpp
+++ b/include/boost/python/converter/arg_to_python.hpp
@@ -0,0 +1,261 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef ARG_TO_PYTHON_DWA200265_HPP
+# define ARG_TO_PYTHON_DWA200265_HPP
+
+# include <boost/python/ptr.hpp>
+# include <boost/python/tag.hpp>
+# include <boost/python/to_python_indirect.hpp>
+
+# include <boost/python/converter/registered.hpp>
+# include <boost/python/converter/registered_pointee.hpp>
+# include <boost/python/converter/arg_to_python_base.hpp>
+# include <boost/python/converter/shared_ptr_to_python.hpp>
+// Bring in specializations
+# include <boost/python/converter/builtin_converters.hpp>
+
+# include <boost/python/object/function_handle.hpp>
+
+# include <boost/python/base_type_traits.hpp>
+
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/python/detail/convertible.hpp>
+# include <boost/python/detail/string_literal.hpp>
+# include <boost/python/detail/value_is_shared_ptr.hpp>
+
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/type_traits/composite_traits.hpp>
+# include <boost/type_traits/function_traits.hpp>
+
+
+# include <boost/mpl/or.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+template <class T> struct is_object_manager;
+
+namespace detail
+{
+  template <class T>
+  struct function_arg_to_python : handle<>
+  {
+      function_arg_to_python(T const& x);
+  };
+
+  template <class T>
+  struct reference_arg_to_python : handle<>
+  {
+      reference_arg_to_python(T& x);
+   private:
+      static PyObject* get_object(T& x);
+  };
+
+  template <class T>
+  struct shared_ptr_arg_to_python : handle<>
+  {
+      shared_ptr_arg_to_python(T const& x);
+   private:
+      static PyObject* get_object(T& x);
+  };
+
+  template <class T>
+  struct value_arg_to_python : arg_to_python_base
+  {
+      // Throw an exception if the conversion can't succeed
+      value_arg_to_python(T const&);
+  };
+
+  template <class Ptr>
+  struct pointer_deep_arg_to_python : arg_to_python_base
+  {
+      // Throw an exception if the conversion can't succeed
+      pointer_deep_arg_to_python(Ptr);
+  };
+
+  template <class Ptr>
+  struct pointer_shallow_arg_to_python : handle<>
+  {
+      // Throw an exception if the conversion can't succeed
+      pointer_shallow_arg_to_python(Ptr);
+   private:
+      static PyObject* get_object(Ptr p);
+  };
+
+  // Convert types that manage a Python object to_python
+  template <class T>
+  struct object_manager_arg_to_python
+  {
+      object_manager_arg_to_python(T const& x) : m_src(x) {}
+      
+      PyObject* get() const
+      {
+          return python::upcast<PyObject>(get_managed_object(m_src, tag));
+      }
+      
+   private:
+      T const& m_src;
+  };
+
+  template <class T>
+  struct select_arg_to_python
+  {
+      typedef typename unwrap_reference<T>::type unwrapped_referent;
+      typedef typename unwrap_pointer<T>::type unwrapped_ptr;
+
+      typedef typename mpl::if_<
+          // Special handling for char const[N]; interpret them as char
+          // const* for the sake of conversion
+          python::detail::is_string_literal<T const>
+        , arg_to_python<char const*>
+
+        , typename mpl::if_<
+              python::detail::value_is_shared_ptr<T>
+            , shared_ptr_arg_to_python<T>
+      
+            , typename mpl::if_<
+                mpl::or_<
+                    is_function<T>
+                  , indirect_traits::is_pointer_to_function<T>
+                  , is_member_function_pointer<T>
+                >
+                , function_arg_to_python<T>
+
+                , typename mpl::if_<
+                      is_object_manager<T>
+                    , object_manager_arg_to_python<T>
+
+                    , typename mpl::if_<
+                          is_pointer<T>
+                        , pointer_deep_arg_to_python<T>
+
+                        , typename mpl::if_<
+                              is_pointer_wrapper<T>
+                            , pointer_shallow_arg_to_python<unwrapped_ptr>
+
+                            , typename mpl::if_<
+                                  is_reference_wrapper<T>
+                                , reference_arg_to_python<unwrapped_referent>
+                                , value_arg_to_python<T>
+                              >::type
+                          >::type
+                      >::type
+                  >::type
+              >::type
+          >::type
+      >::type
+      
+      type;
+  };
+}
+
+template <class T>
+struct arg_to_python
+    : detail::select_arg_to_python<T>::type
+{
+    typedef typename detail::select_arg_to_python<T>::type base;
+ public: // member functions
+    // Throw an exception if the conversion can't succeed
+    arg_to_python(T const& x);
+};
+
+//
+// implementations
+//
+namespace detail
+{
+  // reject_raw_object_ptr -- cause a compile-time error if the user
+  // should pass a raw Python object pointer
+  using python::detail::yes_convertible;
+  using python::detail::no_convertible;
+  using python::detail::unspecialized;
+  
+  template <class T> struct cannot_convert_raw_PyObject;
+
+  template <class T, class Convertibility>
+  struct reject_raw_object_helper
+  {
+      static void error(Convertibility)
+      {
+          cannot_convert_raw_PyObject<T*>::to_python_use_handle_instead();
+      }
+      static void error(...) {}
+  };
+  
+  template <class T>
+  inline void reject_raw_object_ptr(T*)
+  {
+      reject_raw_object_helper<T,yes_convertible>::error(
+          python::detail::convertible<PyObject const volatile*>::check((T*)0));
+      
+      typedef typename remove_cv<T>::type value_type;
+      
+      reject_raw_object_helper<T,no_convertible>::error(
+          python::detail::convertible<unspecialized*>::check(
+              (base_type_traits<value_type>*)0
+              ));
+  }
+  // ---------
+      
+  template <class T>
+  inline function_arg_to_python<T>::function_arg_to_python(T const& x)
+      : handle<>(python::objects::make_function_handle(x))
+  {
+  }
+
+  template <class T>
+  inline value_arg_to_python<T>::value_arg_to_python(T const& x)
+      : arg_to_python_base(&x, registered<T>::converters)
+  {
+  }
+
+  template <class Ptr>
+  inline pointer_deep_arg_to_python<Ptr>::pointer_deep_arg_to_python(Ptr x)
+      : arg_to_python_base(x, registered_pointee<Ptr>::converters)
+  {
+      detail::reject_raw_object_ptr((Ptr)0);
+  }
+
+  template <class T>
+  inline PyObject* reference_arg_to_python<T>::get_object(T& x)
+  {
+      to_python_indirect<T&,python::detail::make_reference_holder> convert;
+      return convert(x);
+  }
+
+  template <class T>
+  inline reference_arg_to_python<T>::reference_arg_to_python(T& x)
+      : handle<>(reference_arg_to_python<T>::get_object(x))
+  {
+  }
+
+  template <class T>
+  inline shared_ptr_arg_to_python<T>::shared_ptr_arg_to_python(T const& x)
+      : handle<>(shared_ptr_to_python(x))
+  {
+  }
+
+  template <class Ptr>
+  inline pointer_shallow_arg_to_python<Ptr>::pointer_shallow_arg_to_python(Ptr x)
+      : handle<>(pointer_shallow_arg_to_python<Ptr>::get_object(x))
+  {
+      detail::reject_raw_object_ptr((Ptr)0);
+  }
+
+  template <class Ptr>
+  inline PyObject* pointer_shallow_arg_to_python<Ptr>::get_object(Ptr x)
+  {
+      to_python_indirect<Ptr,python::detail::make_reference_holder> convert;
+      return convert(x);
+  }
+}
+
+template <class T>
+inline arg_to_python<T>::arg_to_python(T const& x)
+    : base(x)
+{}
+
+}}} // namespace boost::python::converter
+
+#endif // ARG_TO_PYTHON_DWA200265_HPP
--- a/include/boost/python/converter/arg_to_python_base.hpp
+++ b/include/boost/python/converter/arg_to_python_base.hpp
@@ -0,0 +1,32 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef ARG_TO_PYTHON_BASE_DWA200237_HPP
+# define ARG_TO_PYTHON_BASE_DWA200237_HPP
+# include <boost/python/handle.hpp>
+
+namespace boost { namespace python { namespace converter {
+
+struct registration;
+
+namespace detail
+{
+  struct BOOST_PYTHON_DECL arg_to_python_base
+# if !defined(BOOST_MSVC) || BOOST_MSVC <= 1300 || _MSC_FULL_VER > 13102179
+      : handle<>
+# endif 
+  {
+      arg_to_python_base(void const volatile* source, registration const&);
+# if defined(BOOST_MSVC) && BOOST_MSVC > 1300 && _MSC_FULL_VER <= 13102179
+      PyObject* get() const { return m_ptr.get(); }
+      PyObject* release() { return m_ptr.release(); }
+   private:
+      handle<> m_ptr;
+# endif 
+  };
+}
+
+}}} // namespace boost::python::converter
+
+#endif // ARG_TO_PYTHON_BASE_DWA200237_HPP
--- a/include/boost/python/converter/as_to_python_function.hpp
+++ b/include/boost/python/converter/as_to_python_function.hpp
@@ -0,0 +1,46 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef AS_TO_PYTHON_FUNCTION_DWA2002121_HPP
+# define AS_TO_PYTHON_FUNCTION_DWA2002121_HPP
+# include <boost/python/converter/to_python_function_type.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+// Given a typesafe to_python conversion function, produces a
+// to_python_function_t which can be registered in the usual way.
+template <class T, class ToPython>
+struct as_to_python_function
+{
+    // Assertion functions used to prevent wrapping of converters
+    // which take non-const reference parameters. The T* argument in
+    // the first overload ensures it isn't used in case T is a
+    // reference.
+    template <class U>
+    static void convert_function_must_take_value_or_const_reference(U(*)(T), int, T* = 0) {}
+    template <class U>
+    static void convert_function_must_take_value_or_const_reference(U(*)(T const&), long ...) {}
+        
+    static PyObject* convert(void const* x)
+    {
+        convert_function_must_take_value_or_const_reference(&ToPython::convert, 1L);
+        
+        // Yes, the const_cast below opens a hole in const-correctness,
+        // but it's needed to convert auto_ptr<U> to python.
+        //
+        // How big a hole is it?  It allows ToPython::convert() to be
+        // a function which modifies its argument. The upshot is that
+        // client converters applied to const objects may invoke
+        // undefined behavior. The damage, however, is limited by the
+        // use of the assertion function. Thus, the only way this can
+        // modify its argument is if T is an auto_ptr-like type. There
+        // is still a const-correctness hole w.r.t. auto_ptr<U> const,
+        // but c'est la vie.
+        return ToPython::convert(*const_cast<T*>(static_cast<T const*>(x)));
+    }
+};
+
+}}} // namespace boost::python::converter
+
+#endif // AS_TO_PYTHON_FUNCTION_DWA2002121_HPP
--- a/include/boost/python/converter/body.hpp
+++ b/include/boost/python/converter/body.hpp
@@ -1,46 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef BODY_DWA2001127_HPP
-# define BODY_DWA2001127_HPP
-# include <boost/config.hpp>
-# include <boost/python/converter/type_id.hpp>
-# include <boost/python/export.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-struct BOOST_PYTHON_EXPORT handle;
-
-struct BOOST_PYTHON_EXPORT body
-{
- public:
-    body(type_id_t key);
-    virtual ~body() {}
-
-    // default implementation is a no-op
-    virtual void destroy_handle(handle*) const;
-
-    type_id_t key() const;
-
- private:
-    type_id_t m_key;
-};
-
-//
-// implementations
-//
-inline body::body(type_id_t key)
-    : m_key(key)
-{
-}
-
-inline type_id_t body::key() const
-{
-    return m_key;
-}
-
-}}} // namespace boost::python::converter
-
-#endif // BODY_DWA2001127_HPP
--- a/include/boost/python/converter/builtin_converters.hpp
+++ b/include/boost/python/converter/builtin_converters.hpp
@@ -0,0 +1,144 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BUILTIN_CONVERTERS_DWA2002124_HPP
+# define BUILTIN_CONVERTERS_DWA2002124_HPP
+# include <boost/python/detail/prefix.hpp>
+# include <boost/python/detail/none.hpp>
+# include <boost/python/handle.hpp>
+# include <boost/implicit_cast.hpp>
+# include <string>
+# include <complex>
+# include <boost/limits.hpp>
+
+// Since all we can use to decide how to convert an object to_python
+// is its C++ type, there can be only one such converter for each
+// type. Therefore, for built-in conversions we can bypass registry
+// lookups using explicit specializations of arg_to_python and
+// result_to_python.
+
+namespace boost { namespace python {
+
+namespace converter
+{
+  template <class T> struct arg_to_python;
+  BOOST_PYTHON_DECL PyObject* do_return_to_python(char);
+  BOOST_PYTHON_DECL PyObject* do_return_to_python(char const*);
+  BOOST_PYTHON_DECL PyObject* do_return_to_python(PyObject*);
+  BOOST_PYTHON_DECL PyObject* do_arg_to_python(PyObject*);
+}
+
+// Provide specializations of to_python_value
+template <class T> struct to_python_value;
+
+namespace detail
+{
+  // Since there's no registry lookup, always report the existence of
+  // a converter.
+  struct builtin_to_python
+  {
+      // This information helps make_getter() decide whether to try to
+      // return an internal reference or not. I don't like it much,
+      // but it will have to serve for now.
+      BOOST_STATIC_CONSTANT(bool, uses_registry = false);
+  };
+}
+
+// Use expr to create the PyObject corresponding to x
+# define BOOST_PYTHON_RETURN_TO_PYTHON_BY_VALUE(T, expr)        \
+    template <> struct to_python_value<T&>                      \
+        : detail::builtin_to_python                             \
+    {                                                           \
+        inline PyObject* operator()(T const& x) const           \
+        {                                                       \
+            return (expr);                                      \
+        }                                                       \
+    };                                                          \
+    template <> struct to_python_value<T const&>                \
+        : detail::builtin_to_python                             \
+    {                                                           \
+        inline PyObject* operator()(T const& x) const           \
+        {                                                       \
+            return (expr);                                      \
+        }                                                       \
+    };
+
+# define BOOST_PYTHON_ARG_TO_PYTHON_BY_VALUE(T, expr)   \
+    namespace converter                                 \
+    {                                                   \
+      template <> struct arg_to_python< T >             \
+        : handle<>                                      \
+      {                                                 \
+          arg_to_python(T const& x)                     \
+            : python::handle<>(expr) {}                 \
+      };                                                \
+    } 
+
+// Specialize argument and return value converters for T using expr
+# define BOOST_PYTHON_TO_PYTHON_BY_VALUE(T, expr)       \
+        BOOST_PYTHON_RETURN_TO_PYTHON_BY_VALUE(T,expr)  \
+        BOOST_PYTHON_ARG_TO_PYTHON_BY_VALUE(T,expr)
+
+// Specialize converters for signed and unsigned T to Python Int
+# define BOOST_PYTHON_TO_INT(T)                                         \
+    BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed T, ::PyInt_FromLong(x))      \
+    BOOST_PYTHON_TO_PYTHON_BY_VALUE(                                    \
+        unsigned T                                                      \
+        , static_cast<unsigned long>(x) > static_cast<unsigned long>(   \
+                (std::numeric_limits<long>::max)())                     \
+        ? ::PyLong_FromUnsignedLong(x)                                  \
+        : ::PyInt_FromLong(x))
+
+// Bool is not signed.
+#if PY_VERSION_HEX >= 0x02030000
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(bool, ::PyBool_FromLong(x))
+#else
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(bool, ::PyInt_FromLong(x))
+#endif
+  
+// note: handles signed char and unsigned char, but not char (see below)
+BOOST_PYTHON_TO_INT(char)
+
+BOOST_PYTHON_TO_INT(short)
+BOOST_PYTHON_TO_INT(int)
+BOOST_PYTHON_TO_INT(long)
+
+// using Python's macro instead of Boost's - we don't seem to get the
+// config right all the time.
+# ifdef HAVE_LONG_LONG 
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed BOOST_PYTHON_LONG_LONG, ::PyLong_FromLongLong(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned BOOST_PYTHON_LONG_LONG, ::PyLong_FromUnsignedLongLong(x))
+# endif
+    
+# undef BOOST_TO_PYTHON_INT
+
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(char, converter::do_return_to_python(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(char const*, converter::do_return_to_python(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::string, ::PyString_FromStringAndSize(x.data(),implicit_cast<int>(x.size())))
+# ifndef BOOST_NO_STD_WSTRING
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::wstring, ::PyUnicode_FromWideChar(x.data(),implicit_cast<int>(x.size())))
+# endif 
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(float, ::PyFloat_FromDouble(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(double, ::PyFloat_FromDouble(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(long double, ::PyFloat_FromDouble(x))
+BOOST_PYTHON_RETURN_TO_PYTHON_BY_VALUE(PyObject*, converter::do_return_to_python(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<float>, ::PyComplex_FromDoubles(x.real(), x.imag()))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<double>, ::PyComplex_FromDoubles(x.real(), x.imag()))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<long double>, ::PyComplex_FromDoubles(x.real(), x.imag()))
+
+# undef BOOST_PYTHON_RETURN_TO_PYTHON_BY_VALUE
+# undef BOOST_PYTHON_ARG_TO_PYTHON_BY_VALUE
+# undef BOOST_PYTHON_TO_PYTHON_BY_VALUE
+# undef BOOST_PYTHON_TO_INT
+    
+namespace converter
+{ 
+
+  void initialize_builtin_converters();
+
+}
+
+}} // namespace boost::python::converter
+
+#endif // BUILTIN_CONVERTERS_DWA2002124_HPP
--- a/include/boost/python/converter/class.hpp
+++ b/include/boost/python/converter/class.hpp
@@ -1,56 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef CLASS_DWA20011215_HPP
-# define CLASS_DWA20011215_HPP
-
-# include <boost/python/object/class.hpp>
-# include <boost/python/converter/unwrapper.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-struct class_unwrapper_base
-{
-    class_unwrapper_base(type_id_t sought_type);
-    void*
-};
-
-template <class T>
-struct class_unwrapper
-{
-    struct ref_unwrapper : unwrapper<T&>
-    {
-        bool convertible(PyObject* p) const
-        {
-            return p->ob_type == &SimpleType;
-        }
-    
-        simple const& convert(PyObject* p, void*&) const
-        {
-            return static_cast<SimpleObject*>(p)->x;
-        }
-        
-    };
-    
-# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    struct const_ref_unwrapper : unwrapper<T const&>
-    {
-        bool convertible(PyObject* p) const
-        {
-            return p->ob_type == &SimpleType;
-        }
-    
-        simple const& convert(PyObject* p, void*&) const
-        {
-            return static_cast<SimpleObject*>(p)->x;
-        }
-        
-    };
-# endif 
-};
-
-}}} // namespace boost::python::converter
-
-#endif // CLASS_DWA20011215_HPP
--- a/include/boost/python/converter/constructor_function.hpp
+++ b/include/boost/python/converter/constructor_function.hpp
@@ -0,0 +1,17 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef CONSTRUCTOR_FUNCTION_DWA200278_HPP
+# define CONSTRUCTOR_FUNCTION_DWA200278_HPP
+
+namespace boost { namespace python { namespace converter { 
+
+// Declares the type of functions used to construct C++ objects for
+// rvalue from_python conversions.
+struct rvalue_from_python_stage1_data;
+typedef void (*constructor_function)(PyObject* source, rvalue_from_python_stage1_data*);
+
+}}} // namespace boost::python::converter
+
+#endif // CONSTRUCTOR_FUNCTION_DWA200278_HPP
--- a/include/boost/python/converter/context_result_converter.hpp
+++ b/include/boost/python/converter/context_result_converter.hpp
@@ -0,0 +1,17 @@
+// Copyright David Abrahams 2003.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef CONTEXT_RESULT_CONVERTER_DWA2003917_HPP
+# define CONTEXT_RESULT_CONVERTER_DWA2003917_HPP
+
+namespace boost { namespace python { namespace converter { 
+
+// A ResultConverter base class used to indicate that this result
+// converter should be constructed with the original Python argument
+// list.
+struct context_result_converter {};
+
+}}} // namespace boost::python::converter
+
+#endif // CONTEXT_RESULT_CONVERTER_DWA2003917_HPP
--- a/include/boost/python/converter/convertible_function.hpp
+++ b/include/boost/python/converter/convertible_function.hpp
@@ -0,0 +1,14 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef CONVERTIBLE_FUNCTION_DWA200278_HPP
+# define CONVERTIBLE_FUNCTION_DWA200278_HPP
+
+namespace boost { namespace python { namespace converter { 
+
+typedef void* (*convertible_function)(PyObject*);
+    
+}}} // namespace boost::python::converter
+
+#endif // CONVERTIBLE_FUNCTION_DWA200278_HPP
--- a/include/boost/python/converter/from_python.hpp
+++ b/include/boost/python/converter/from_python.hpp
@@ -0,0 +1,41 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef FIND_FROM_PYTHON_DWA2002223_HPP
+# define FIND_FROM_PYTHON_DWA2002223_HPP
+
+# include <boost/python/detail/prefix.hpp>
+# include <boost/python/converter/rvalue_from_python_data.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct registration;
+
+
+BOOST_PYTHON_DECL void* get_lvalue_from_python(
+    PyObject* source, registration const&);
+
+BOOST_PYTHON_DECL bool implicit_rvalue_convertible_from_python(
+    PyObject* source, registration const&);
+
+BOOST_PYTHON_DECL rvalue_from_python_stage1_data rvalue_from_python_stage1(
+    PyObject* source, registration const&);
+
+BOOST_PYTHON_DECL void* rvalue_from_python_stage2(
+    PyObject* source, rvalue_from_python_stage1_data&, registration const&);
+
+BOOST_PYTHON_DECL void* rvalue_result_from_python(
+    PyObject*, rvalue_from_python_stage1_data&);
+
+BOOST_PYTHON_DECL void* reference_result_from_python(PyObject*, registration const&);
+BOOST_PYTHON_DECL void* pointer_result_from_python(PyObject*, registration const&);
+
+BOOST_PYTHON_DECL void void_result_from_python(PyObject*);
+
+BOOST_PYTHON_DECL void throw_no_pointer_from_python(PyObject*, registration const&);
+BOOST_PYTHON_DECL void throw_no_reference_from_python(PyObject*, registration const&);
+
+}}} // namespace boost::python::converter
+
+#endif // FIND_FROM_PYTHON_DWA2002223_HPP
--- a/include/boost/python/converter/handle.hpp
+++ b/include/boost/python/converter/handle.hpp
@@ -1,91 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef HANDLE_DWA20011130_HPP
-# define HANDLE_DWA20011130_HPP
-# include <boost/python/export.hpp>
-# include <boost/utility.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/export.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-struct BOOST_PYTHON_EXPORT body;
-
-// The common base class for unwrap_ and wrap_ handle objects. They
-// share a common base so that handles can be linked into a chain
-// within a function wrapper which is managed by a single object.
-struct BOOST_PYTHON_EXPORT handle : boost::noncopyable
-{
- public: // member functions
-
-    // All constructors take a body* passed from the derived class.
-    //
-    // Constructors taking a handle links this into a chain of
-    // handles, for more efficient management in function wrappers
-    handle(body* body);
-    handle(body* body, handle& prev);
-
-    // returns true iff all handles in the chain can convert their
-    // arguments
-    bool convertible() const;
-
-    // safe_bool idiom from Peter Dimov: provides handles to/from
-    // bool without enabling handles to integer types/void*.
- private:
-    struct dummy { inline void nonnull() {} };
-    typedef void (dummy::*safe_bool)();
- public:
-    inline operator safe_bool() const;
-    inline safe_bool operator!() const;
-    
- protected: // member functions for derived classes
-    // Get the body we hold
-    inline body* get_body() const;
-    
-    // Release all bodies in the chain, in reverse order of
-    // initialization. Only actually called for the head of the chain.
-    void destroy();
-    
- private:
-    // Holds implementation
-    body* m_body;
-    
-    // handle for next argument, if any.
-    handle* m_next;
-};
-
-//
-// implementations
-// 
-inline handle::handle(body* body, handle& prev)
-    : m_body(body), m_next(0)
-{
-    prev.m_next = this;
-}
-
-inline handle::handle(body* body)
-    : m_body(body), m_next(0)
-{
-}
-
-inline handle::operator handle::safe_bool() const
-{
-    return convertible() ? &dummy::nonnull : 0;
-}
-
-inline handle::safe_bool handle::operator!() const
-{
-    return convertible() ? 0 : &dummy::nonnull;
-}
-
-inline body* handle::get_body() const
-{
-    return m_body;
-}
-
-}}} // namespace boost::python::converter
-
-#endif // HANDLE_DWA20011130_HPP
--- a/include/boost/python/converter/implicit.hpp
+++ b/include/boost/python/converter/implicit.hpp
@@ -0,0 +1,42 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef IMPLICIT_DWA2002326_HPP
+# define IMPLICIT_DWA2002326_HPP
+
+# include <boost/python/converter/rvalue_from_python_data.hpp>
+# include <boost/python/converter/registrations.hpp>
+# include <boost/python/converter/registered.hpp>
+
+# include <boost/python/extract.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+template <class Source, class Target>
+struct implicit
+{
+    static void* convertible(PyObject* obj)
+    {
+        // Find a converter which can produce a Source instance from
+        // obj. The user has told us that Source can be converted to
+        // Target, and instantiating construct() below, ensures that
+        // at compile-time.
+        return implicit_rvalue_convertible_from_python(obj, registered<Source>::converters)
+            ? obj : 0;
+    }
+      
+    static void construct(PyObject* obj, rvalue_from_python_stage1_data* data)
+    {
+        void* storage = ((rvalue_from_python_storage<Target>*)data)->storage.bytes;
+        
+        new (storage) Target(extract<Source>(obj)());
+        
+        // record successful construction
+        data->convertible = storage;
+    }
+};
+
+}}} // namespace boost::python::converter
+
+#endif // IMPLICIT_DWA2002326_HPP
--- a/include/boost/python/converter/obj_mgr_arg_from_python.hpp
+++ b/include/boost/python/converter/obj_mgr_arg_from_python.hpp
@@ -0,0 +1,121 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef OBJ_MGR_ARG_FROM_PYTHON_DWA2002628_HPP
+# define OBJ_MGR_ARG_FROM_PYTHON_DWA2002628_HPP
+
+# include <boost/python/detail/prefix.hpp>
+# include <boost/python/detail/referent_storage.hpp>
+# include <boost/python/detail/destroy.hpp>
+# include <boost/python/detail/construct.hpp>
+# include <boost/python/converter/object_manager.hpp>
+# include <boost/python/detail/raw_pyobject.hpp>
+# include <boost/python/tag.hpp>
+
+//
+// arg_from_python converters for Python type wrappers, to be used as
+// base classes for specializations.
+//
+namespace boost { namespace python { namespace converter { 
+
+template <class T>
+struct object_manager_value_arg_from_python
+{
+    typedef T result_type;
+    
+    object_manager_value_arg_from_python(PyObject*);
+    bool convertible() const;
+    T operator()() const;
+ private:
+    PyObject* m_source;
+};
+
+// Used for converting reference-to-object-manager arguments from
+// python. The process used here is a little bit odd. Upon
+// construction, we build the object manager object in the m_result
+// object, *forcing* it to accept the source Python object by casting
+// its pointer to detail::borrowed_reference. This is supposed to
+// bypass any type checking of the source object. The convertible
+// check then extracts the owned object and checks it. If the check
+// fails, nothing else in the program ever gets to touch this strange
+// "forced" object.
+template <class Ref>
+struct object_manager_ref_arg_from_python
+{
+    typedef Ref result_type;
+    
+    object_manager_ref_arg_from_python(PyObject*);
+    bool convertible() const;
+    Ref operator()() const;
+    ~object_manager_ref_arg_from_python();
+ private:
+    typename python::detail::referent_storage<Ref>::type m_result;
+};
+
+//
+// implementations
+//
+
+template <class T>
+inline object_manager_value_arg_from_python<T>::object_manager_value_arg_from_python(PyObject* x)
+    : m_source(x)
+{
+}
+    
+template <class T>
+inline bool object_manager_value_arg_from_python<T>::convertible() const
+{
+    return object_manager_traits<T>::check(m_source);
+}
+
+template <class T>
+inline T object_manager_value_arg_from_python<T>::operator()() const
+{
+    return T(python::detail::borrowed_reference(m_source));
+}
+
+template <class Ref>
+inline object_manager_ref_arg_from_python<Ref>::object_manager_ref_arg_from_python(PyObject* x)
+{
+# if defined(__EDG_VERSION__) && __EDG_VERSION__ <= 243
+    // needed for warning suppression
+    python::detail::borrowed_reference x_ = python::detail::borrowed_reference(x);
+    python::detail::construct_referent<Ref>(&m_result.bytes, x_);
+# else 
+    python::detail::construct_referent<Ref>(&m_result.bytes, (python::detail::borrowed_reference)x);
+# endif 
+}
+
+template <class Ref>
+inline object_manager_ref_arg_from_python<Ref>::~object_manager_ref_arg_from_python()
+{
+    python::detail::destroy_referent<Ref>(this->m_result.bytes);
+}
+
+namespace detail
+{
+  template <class T>
+  inline bool object_manager_ref_check(T const& x)
+  {
+      return object_manager_traits<T>::check(get_managed_object(x, tag));
+  }
+}
+
+template <class Ref>
+inline bool object_manager_ref_arg_from_python<Ref>::convertible() const
+{
+    return detail::object_manager_ref_check(
+        python::detail::void_ptr_to_reference(this->m_result.bytes, (Ref(*)())0));
+}
+
+template <class Ref>
+inline Ref object_manager_ref_arg_from_python<Ref>::operator()() const
+{
+    return python::detail::void_ptr_to_reference(
+        this->m_result.bytes, (Ref(*)())0);
+}
+
+}}} // namespace boost::python::converter
+
+#endif // OBJ_MGR_ARG_FROM_PYTHON_DWA2002628_HPP
--- a/include/boost/python/converter/object_manager.hpp
+++ b/include/boost/python/converter/object_manager.hpp
@@ -0,0 +1,230 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef OBJECT_MANAGER_DWA2002614_HPP
+# define OBJECT_MANAGER_DWA2002614_HPP
+
+# include <boost/python/handle.hpp>
+# include <boost/python/cast.hpp>
+# include <boost/python/converter/pyobject_traits.hpp>
+# include <boost/type_traits/object_traits.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/mpl/bool.hpp>
+
+// Facilities for dealing with types which always manage Python
+// objects. Some examples are object, list, str, et. al. Different
+// to_python/from_python conversion rules apply here because in
+// contrast to other types which are typically embedded inside a
+// Python object, these are wrapped around a Python object. For most
+// object managers T, a C++ non-const T reference argument does not
+// imply the existence of a T lvalue embedded in the corresponding
+// Python argument, since mutating member functions on T actually only
+// modify the held Python object.
+//
+// handle<T> is an object manager, though strictly speaking it should
+// not be. In other words, even though mutating member functions of
+// hanlde<T> actually modify the handle<T> and not the T object,
+// handle<T>& arguments of wrapped functions will bind to "rvalues"
+// wrapping the actual Python argument, just as with other object
+// manager classes. Making an exception for handle<T> is simply not
+// worth the trouble.
+//
+// borrowed<T> cv* is an object manager so that we can use the general
+// to_python mechanisms to convert raw Python object pointers to
+// python, without the usual semantic problems of using raw pointers.
+
+
+// Object Manager Concept requirements:
+//
+//    T is an Object Manager
+//    p is a PyObject*
+//    x is a T
+//
+//    * object_manager_traits<T>::is_specialized == true
+//
+//    * T(detail::borrowed_reference(p))
+//        Manages p without checking its type
+//
+//    * get_managed_object(x, boost::python::tag)
+//        Convertible to PyObject*
+//
+// Additional requirements if T can be converted from_python:
+//
+//    * T(object_manager_traits<T>::adopt(p))
+//        steals a reference to p, or throws a TypeError exception if
+//        p doesn't have an appropriate type. May assume p is non-null
+//
+//    * X::check(p)
+//        convertible to bool. True iff T(X::construct(p)) will not
+//        throw.
+
+// Forward declarations
+//
+namespace boost { namespace python
+{
+  namespace api
+  {
+    class object; 
+  }
+}}
+
+namespace boost { namespace python { namespace converter { 
+
+
+// Specializations for handle<T>
+template <class T>
+struct handle_object_manager_traits
+    : pyobject_traits<typename T::element_type>
+{
+ private:
+  typedef pyobject_traits<typename T::element_type> base;
+  
+ public:
+  BOOST_STATIC_CONSTANT(bool, is_specialized = true);
+
+  // Initialize with a null_ok pointer for efficiency, bypassing the
+  // null check since the source is always non-null.
+  static null_ok<typename T::element_type>* adopt(PyObject* p)
+  {
+      return python::allow_null(base::checked_downcast(p));
+  }
+};
+
+template <class T>
+struct default_object_manager_traits
+{
+    BOOST_STATIC_CONSTANT(
+        bool, is_specialized = python::detail::is_borrowed_ptr<T>::value
+        );
+};
+
+template <class T>
+struct object_manager_traits
+    : mpl::if_c<
+         is_handle<T>::value
+       , handle_object_manager_traits<T>
+       , default_object_manager_traits<T>
+    >::type
+{
+};
+
+//
+// Traits for detecting whether a type is an object manager or a
+// (cv-qualified) reference to an object manager.
+// 
+
+template <class T>
+struct is_object_manager
+    : mpl::bool_<object_manager_traits<T>::is_specialized>
+{
+};
+
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template <class T>
+struct is_reference_to_object_manager
+    : mpl::false_
+{
+};
+
+template <class T>
+struct is_reference_to_object_manager<T&>
+    : is_object_manager<T>
+{
+};
+
+template <class T>
+struct is_reference_to_object_manager<T const&>
+    : is_object_manager<T>
+{
+};
+
+template <class T>
+struct is_reference_to_object_manager<T volatile&>
+    : is_object_manager<T>
+{
+};
+
+template <class T>
+struct is_reference_to_object_manager<T const volatile&>
+    : is_object_manager<T>
+{
+};
+# else
+
+namespace detail
+{
+  typedef char (&yes_reference_to_object_manager)[1];
+  typedef char (&no_reference_to_object_manager)[2];
+
+  // A number of nastinesses go on here in order to work around MSVC6
+  // bugs.
+  template <class T>
+  struct is_object_manager_help
+  {
+      typedef typename mpl::if_<
+          is_object_manager<T>
+          , yes_reference_to_object_manager
+          , no_reference_to_object_manager
+          >::type type;
+
+      // If we just use the type instead of the result of calling this
+      // function, VC6 will ICE.
+      static type call();
+  };
+
+  // A set of overloads for each cv-qualification. The same argument
+  // is passed twice: the first one is used to unwind the cv*, and the
+  // second one is used to avoid relying on partial ordering for
+  // overload resolution.
+  template <class U>
+  typename is_object_manager_help<U>
+  is_object_manager_helper(U*, void*);
+  
+  template <class U>
+  typename is_object_manager_help<U>
+  is_object_manager_helper(U const*, void const*);
+  
+  template <class U>
+  typename is_object_manager_help<U>
+  is_object_manager_helper(U volatile*, void volatile*);
+  
+  template <class U>
+  typename is_object_manager_help<U>
+  is_object_manager_helper(U const volatile*, void const volatile*);
+  
+  template <class T>
+  struct is_reference_to_object_manager_nonref
+      : mpl::false_
+  {
+  };
+
+  template <class T>
+  struct is_reference_to_object_manager_ref
+  {
+      static T sample_object;
+      BOOST_STATIC_CONSTANT(
+        bool, value
+        = (sizeof(is_object_manager_helper(&sample_object, &sample_object).call())
+            == sizeof(detail::yes_reference_to_object_manager)
+          )
+        );
+      typedef mpl::bool_<value> type;
+  };
+}
+
+template <class T>
+struct is_reference_to_object_manager
+    : mpl::if_<
+        is_reference<T>
+        , detail::is_reference_to_object_manager_ref<T>
+        , detail::is_reference_to_object_manager_nonref<T>
+    >::type
+{
+};
+# endif 
+
+}}} // namespace boost::python::converter
+
+#endif // OBJECT_MANAGER_DWA2002614_HPP
--- a/include/boost/python/converter/pointer_type_id.hpp
+++ b/include/boost/python/converter/pointer_type_id.hpp
@@ -0,0 +1,68 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef POINTER_TYPE_ID_DWA2002222_HPP
+# define POINTER_TYPE_ID_DWA2002222_HPP
+
+# include <boost/python/type_id.hpp>
+# include <boost/type_traits/composite_traits.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+namespace detail
+{
+  template <bool is_ref = false>
+  struct pointer_typeid_select
+  {
+      template <class T>
+      static inline type_info execute(T*(*)() = 0)
+      {
+          return type_id<T>();
+      }
+  };
+
+  template <>
+  struct pointer_typeid_select<true>
+  {
+      template <class T>
+      static inline type_info execute(T* const volatile&(*)() = 0)
+      {
+          return type_id<T>();
+      }
+    
+      template <class T>
+      static inline type_info execute(T*volatile&(*)() = 0)
+      {
+          return type_id<T>();
+      }
+    
+      template <class T>
+      static inline type_info execute(T*const&(*)() = 0)
+      {
+          return type_id<T>();
+      }
+
+      template <class T>
+      static inline type_info execute(T*&(*)() = 0)
+      {
+          return type_id<T>();
+      }
+  };
+}
+
+// Usage: pointer_type_id<T>()
+//
+// Returns a type_info associated with the type pointed
+// to by T, which may be a pointer or a reference to a pointer.
+template <class T>
+type_info pointer_type_id(T(*)() = 0)
+{
+    return detail::pointer_typeid_select<
+          is_reference<T>::value
+        >::execute((T(*)())0);
+}
+
+}}} // namespace boost::python::converter
+
+#endif // POINTER_TYPE_ID_DWA2002222_HPP
--- a/include/boost/python/converter/pyobject_traits.hpp
+++ b/include/boost/python/converter/pyobject_traits.hpp
@@ -0,0 +1,41 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef PYOBJECT_TRAITS_DWA2002720_HPP
+# define PYOBJECT_TRAITS_DWA2002720_HPP
+
+# include <boost/python/detail/prefix.hpp>
+# include <boost/python/converter/pyobject_type.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+template <class> struct pyobject_traits;
+
+template <>
+struct pyobject_traits<PyObject>
+{
+    // All objects are convertible to PyObject
+    static bool check(PyObject*) { return true; }
+    static PyObject* checked_downcast(PyObject* x) { return x; }
+};
+
+//
+// Specializations
+//
+
+# define BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(T)                  \
+    template <> struct pyobject_traits<Py##T##Object>           \
+        : pyobject_type<Py##T##Object, &Py##T##_Type> {}
+
+// This is not an exhaustive list; should be expanded.
+BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Type);
+BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(List);
+BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Int);
+BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Long);
+BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Dict);
+BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Tuple);
+
+}}} // namespace boost::python::converter
+
+#endif // PYOBJECT_TRAITS_DWA2002720_HPP
--- a/include/boost/python/converter/pyobject_type.hpp
+++ b/include/boost/python/converter/pyobject_type.hpp
@@ -0,0 +1,34 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef PYOBJECT_TYPE_DWA2002720_HPP
+# define PYOBJECT_TYPE_DWA2002720_HPP
+
+# include <boost/python/cast.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+BOOST_PYTHON_DECL PyObject* checked_downcast_impl(PyObject*, PyTypeObject*);
+
+// Used as a base class for specializations which need to provide
+// Python type checking capability.
+template <class Object, PyTypeObject* pytype>
+struct pyobject_type
+{
+    static bool check(PyObject* x)
+    {
+        return ::PyObject_IsInstance(x, (PyObject*)pytype);
+    }
+
+    static Object* checked_downcast(PyObject* x)
+    {
+        return python::downcast<Object>(
+            (checked_downcast_impl)(x, pytype)
+            );
+    }
+};
+
+}}} // namespace boost::python::converter
+
+#endif // PYOBJECT_TYPE_DWA2002720_HPP
--- a/include/boost/python/converter/pytype_object_mgr_traits.hpp
+++ b/include/boost/python/converter/pytype_object_mgr_traits.hpp
@@ -0,0 +1,42 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef PYTYPE_OBJECT_MANAGER_TRAITS_DWA2002716_HPP
+# define PYTYPE_OBJECT_MANAGER_TRAITS_DWA2002716_HPP
+
+# include <boost/python/detail/prefix.hpp>
+# include <boost/python/detail/raw_pyobject.hpp>
+# include <boost/python/cast.hpp>
+# include <boost/python/converter/pyobject_type.hpp>
+# include <boost/python/errors.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+// Provide a forward declaration as a convenience for clients, who all
+// need it.
+template <class T> struct object_manager_traits;
+
+// Derive specializations of object_manager_traits from this class
+// when T is an object manager for a particular Python type hierarchy.
+//
+template <PyTypeObject* pytype, class T>
+struct pytype_object_manager_traits
+    : pyobject_type<T, pytype> // provides check()
+{
+    BOOST_STATIC_CONSTANT(bool, is_specialized = true);
+    static inline python::detail::new_reference adopt(PyObject*);
+};
+
+//
+// implementations
+//
+template <PyTypeObject* pytype, class T>
+inline python::detail::new_reference pytype_object_manager_traits<pytype,T>::adopt(PyObject* x)
+{
+    return python::detail::new_reference(python::pytype_check(pytype, x));
+}
+
+}}} // namespace boost::python::converter
+
+#endif // PYTYPE_OBJECT_MANAGER_TRAITS_DWA2002716_HPP
--- a/include/boost/python/converter/registered.hpp
+++ b/include/boost/python/converter/registered.hpp
@@ -0,0 +1,93 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef REGISTERED_DWA2002710_HPP
+# define REGISTERED_DWA2002710_HPP
+# include <boost/python/type_id.hpp>
+# include <boost/python/converter/registry.hpp>
+# include <boost/python/converter/registrations.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/detail/workaround.hpp>
+
+namespace boost {
+
+// You'll see shared_ptr mentioned in this header because we need to
+// note which types are shared_ptrs in their registrations, to
+// implement special shared_ptr handling for rvalue conversions.
+template <class T> class shared_ptr;
+
+namespace python { namespace converter { 
+
+struct registration;
+
+namespace detail
+{
+  template <class T>
+  struct registered_base
+  {
+      static registration const& converters;
+  };
+}
+
+template <class T>
+struct registered
+  : detail::registered_base<
+        typename add_reference<
+            typename add_cv<T>::type
+        >::type
+    >
+{
+};
+
+# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+    && !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
+// collapses a few more types to the same static instance.  MSVC7.1
+// fails to strip cv-qualification from array types in typeid.  For
+// some reason we can't use this collapse there or array converters
+// will not be found.
+template <class T>
+struct registered<T&>
+  : registered<T> {};
+# endif
+
+//
+// implementations
+//
+namespace detail
+{
+  inline void
+  register_shared_ptr0(...)
+  {
+  }
+  
+  template <class T>
+  inline void
+  register_shared_ptr0(shared_ptr<T>*)
+  {
+      registry::lookup_shared_ptr(type_id<shared_ptr<T> >());
+  }
+  
+  template <class T>
+  inline void
+  register_shared_ptr1(T const volatile*)
+  {
+      detail::register_shared_ptr0((T*)0);
+  }
+  
+  template <class T>
+  registration const& 
+  registry_lookup(T&(*)())
+  {
+      detail::register_shared_ptr1((T*)0);
+      return registry::lookup(type_id<T&>());
+  }
+
+  template <class T>
+  registration const& registered_base<T>::converters = detail::registry_lookup((T(*)())0);
+}
+
+}}} // namespace boost::python::converter
+
+#endif // REGISTERED_DWA2002710_HPP
--- a/include/boost/python/converter/registered_pointee.hpp
+++ b/include/boost/python/converter/registered_pointee.hpp
@@ -0,0 +1,62 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef REGISTERED_POINTEE_DWA2002710_HPP
+# define REGISTERED_POINTEE_DWA2002710_HPP
+# include <boost/python/converter/registered.hpp>
+# include <boost/python/converter/pointer_type_id.hpp>
+# include <boost/python/converter/registry.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct registration;
+
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template <class T>
+struct registered_pointee
+    : registered<
+        typename remove_pointer<
+           typename remove_cv<
+              typename remove_reference<T>::type
+           >::type
+        >::type
+    >
+{
+};
+# else
+namespace detail
+{
+  template <class T>
+  struct registered_pointee_base
+  {
+      static registration const& converters;
+  };
+}
+
+template <class T>
+struct registered_pointee
+    : detail::registered_pointee_base<
+        typename add_reference<
+           typename add_cv<T>::type
+        >::type
+    >
+{
+};
+
+//
+// implementations
+//
+namespace detail
+{
+  template <class T>
+  registration const& registered_pointee_base<T>::converters
+     = registry::lookup(pointer_type_id<T>());
+}
+
+# endif 
+}}} // namespace boost::python::converter
+
+#endif // REGISTERED_POINTEE_DWA2002710_HPP
--- a/include/boost/python/converter/registration.hpp
+++ b/include/boost/python/converter/registration.hpp
@@ -1,83 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef REGISTRATION_DWA20011130_HPP
-# define REGISTRATION_DWA20011130_HPP
-# include <boost/config.hpp>
-# include <boost/python/converter/registry.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/export.hpp>
-# ifdef BOOST_PYTHON_TRACE
-#  include <iostream>
-# endif 
-
-namespace boost { namespace python { namespace converter { 
-
-struct BOOST_PYTHON_EXPORT wrapper_base;
-struct BOOST_PYTHON_EXPORT unwrapper_base;
-
-// This class is really sort of a "templated namespace". It manages a
-// static data member which refers to the registry entry for T. This
-// reference is acquired once to reduce the burden of multiple
-// dictionary lookups at runtime.
-template <class T>
-struct registration
-{
- public: // member functions
-    // Return a converter which can convert the given Python object to
-    // T, or 0 if no such converter exists
-    static unwrapper_base* unwrapper(PyObject*);
-
-    // Return a converter which can convert T to a Python object, or 0
-    // if no such converter exists
-    static wrapper_base* wrapper();
-
- private: // helper functions
-    static registry::entry* entry();
-    static registry::entry* find_entry();
-    
- private: // data members
-    static registry::entry* m_registry_entry;
-};
-
-// because this is static POD data it will be initialized to zero
-template <class T>
-registry::entry* registration<T>::m_registry_entry;
-
-template <class T>
-registry::entry* registration<T>::find_entry()
-{
-    return registry::find(type_id<T>());
-}
-
-template <class T>
-inline registry::entry* registration<T>::entry()
-{
-    if (!m_registry_entry)
-        m_registry_entry = find_entry();
-    return m_registry_entry;
-}
-
-template <class T>
-unwrapper_base* registration<T>::unwrapper(PyObject* p)
-{
-# ifdef BOOST_PYTHON_TRACE
-    std::cout << "retrieving unwrapper for " << type_id<T>() << std::endl;
-# endif 
-    return entry()->unwrapper(p);
-}
-
-template <class T>
-wrapper_base* registration<T>::wrapper()
-{
-# ifdef BOOST_PYTHON_TRACE
-    std::cout << "retrieving wrapper for " << type_id<T>() << std::endl;
-# endif 
-    return entry()->wrapper();
-}
-
-}}} // namespace boost::python::converter
-
-#endif // REGISTRATION_DWA20011130_HPP
--- a/include/boost/python/converter/registrations.hpp
+++ b/include/boost/python/converter/registrations.hpp
@@ -0,0 +1,89 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef REGISTRATIONS_DWA2002223_HPP
+# define REGISTRATIONS_DWA2002223_HPP
+
+# include <boost/python/detail/prefix.hpp>
+
+# include <boost/python/type_id.hpp>
+
+# include <boost/python/converter/convertible_function.hpp>
+# include <boost/python/converter/constructor_function.hpp>
+# include <boost/python/converter/to_python_function_type.hpp>
+
+# include <boost/detail/workaround.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct lvalue_from_python_chain
+{
+    convertible_function convert;
+    lvalue_from_python_chain* next;
+};
+
+struct rvalue_from_python_chain
+{
+    convertible_function convertible;
+    constructor_function construct;
+    rvalue_from_python_chain* next;
+};
+
+struct BOOST_PYTHON_DECL registration
+{
+ public: // member functions
+    explicit registration(type_info target, bool is_shared_ptr = false);
+    
+    // Convert the appropriately-typed data to Python
+    PyObject* to_python(void const volatile*) const;
+
+    // Return the class object, or raise an appropriate Python
+    // exception if no class has been registered.
+    PyTypeObject* get_class_object() const;
+
+ public: // data members. So sue me.
+    const python::type_info target_type;
+
+    // The chain of eligible from_python converters when an lvalue is required
+    lvalue_from_python_chain* lvalue_chain;
+
+    // The chain of eligible from_python converters when an rvalue is acceptable
+    rvalue_from_python_chain* rvalue_chain;
+    
+    // The class object associated with this type
+    PyTypeObject* m_class_object;
+
+    // The unique to_python converter for the associated C++ type.
+    to_python_function_t m_to_python;
+
+    // True iff this type is a shared_ptr.  Needed for special rvalue
+    // from_python handling.
+    const bool is_shared_ptr;
+
+# if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+ private:
+    void operator=(registration); // This is not defined, and just keeps MWCW happy.
+# endif 
+};
+
+//
+// implementations
+//
+inline registration::registration(type_info target_type, bool is_shared_ptr)
+    : target_type(target_type)
+      , lvalue_chain(0)
+      , rvalue_chain(0)
+      , m_class_object(0)
+      , m_to_python(0)
+      , is_shared_ptr(is_shared_ptr)
+{}
+
+inline bool operator<(registration const& lhs, registration const& rhs)
+{
+    return lhs.target_type < rhs.target_type;
+}
+
+}}} // namespace boost::python::converter
+
+#endif // REGISTRATIONS_DWA2002223_HPP
--- a/include/boost/python/converter/registry.hpp
+++ b/include/boost/python/converter/registry.hpp
@@ -1,72 +1,51 @@
-//  Copyright David Abrahams 2001. Permission to copy, use,
-//  modify, sell and distribute this software is granted provided this
-//  copyright notice appears in all copies. This software is provided
-//  "as is" without express or implied warranty, and with no claim as
-//  to its suitability for any purpose.
+//  Copyright David Abrahams 2001.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 #ifndef REGISTRY_DWA20011127_HPP
 # define REGISTRY_DWA20011127_HPP
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/converter/type_id.hpp>
-# include <boost/python/export.hpp>
-# include <list>
-# include <memory>
+# include <boost/python/type_id.hpp>
+# include <boost/python/converter/to_python_function_type.hpp>
+# include <boost/python/converter/rvalue_from_python_data.hpp>
+# include <boost/python/converter/constructor_function.hpp>
+# include <boost/python/converter/convertible_function.hpp>

 namespace boost { namespace python { namespace converter {

-struct BOOST_PYTHON_EXPORT wrapper_base;
-struct BOOST_PYTHON_EXPORT unwrapper_base;
+struct registration;

 // This namespace acts as a sort of singleton
 namespace registry
 {
-  // These are the elements stored in the registry
-  class BOOST_PYTHON_EXPORT entry
-  {
-   public: // member functions
-      entry();
-      ~entry();
+  // Get the registration corresponding to the type, creating it if necessary
+  BOOST_PYTHON_DECL registration const& lookup(type_info);

-      // Return a converter appropriate for converting the given
-      // Python object from_python to the C++ type with which this
-      // converter is associated in the registry, or 0 if no such
-      // converter exists.
-      unwrapper_base* unwrapper(PyObject*) const;
+  // Get the registration corresponding to the type, creating it if
+  // necessary.  Use this first when the type is a shared_ptr.
+  BOOST_PYTHON_DECL registration const& lookup_shared_ptr(type_info);

-      // Return a converter appropriate for converting a C++ object
-      // whose type this entry is associated with in the registry to a
-      // Python object, or 0 if no such converter exists.
-      wrapper_base* wrapper() const;
-
-      // Conversion classes use these functions to register
-      // themselves.
-      void insert(wrapper_base&);
-      void remove(wrapper_base&);
-
-      void insert(unwrapper_base&);
-      void remove(unwrapper_base&);
-
-   private: // types
-      typedef std::list<unwrapper_base*> unwrappers;
-      
-   private: // helper functions
-      unwrappers::iterator find(unwrapper_base const&);
-      
-   private: // data members
-      
-      // The collection of from_python converters for the associated
-      // C++ type.
-      unwrappers m_unwrappers;
-
-      // The unique to_python converter for the associated C++ type.
-      converter::wrapper_base* m_wrapper;
-  };
-
-  BOOST_PYTHON_EXPORT entry* find(type_id_t);
+  // Return a pointer to the corresponding registration, if one exists
+  BOOST_PYTHON_DECL registration const* query(type_info);
  
-  BOOST_PYTHON_EXPORT void insert(wrapper_base& x);
-  BOOST_PYTHON_EXPORT void insert(unwrapper_base& x);
-  BOOST_PYTHON_EXPORT void remove(wrapper_base& x);
-  BOOST_PYTHON_EXPORT void remove(unwrapper_base& x);
+  BOOST_PYTHON_DECL void insert(to_python_function_t, type_info);
+
+  // Insert an lvalue from_python converter
+  BOOST_PYTHON_DECL void insert(void* (*convert)(PyObject*), type_info);
+
+  // Insert an rvalue from_python converter
+  BOOST_PYTHON_DECL void insert(
+      convertible_function
+      , constructor_function
+      , type_info
+      );
+  
+  // Insert an rvalue from_python converter at the tail of the
+  // chain. Used for implicit conversions
+  BOOST_PYTHON_DECL void push_back(
+      convertible_function
+      , constructor_function
+      , type_info
+      );
 }

 }}} // namespace boost::python::converter
--- a/include/boost/python/converter/return_from_python.hpp
+++ b/include/boost/python/converter/return_from_python.hpp
@@ -0,0 +1,162 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef RETURN_FROM_PYTHON_DWA200265_HPP
+# define RETURN_FROM_PYTHON_DWA200265_HPP
+
+# include <boost/python/converter/from_python.hpp>
+# include <boost/python/converter/rvalue_from_python_data.hpp>
+# include <boost/python/converter/registered.hpp>
+# include <boost/python/converter/registered_pointee.hpp>
+# include <boost/python/converter/object_manager.hpp>
+# include <boost/python/detail/void_ptr.hpp>
+# include <boost/python/detail/void_return.hpp>
+# include <boost/python/errors.hpp>
+# include <boost/python/handle.hpp>
+# include <boost/type_traits/has_trivial_copy.hpp>
+# include <boost/mpl/and.hpp>
+# include <boost/mpl/bool.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+template <class T> struct is_object_manager;
+
+namespace detail
+{
+  template <class T>
+  struct return_pointer_from_python
+  {
+      typedef T result_type;
+      T operator()(PyObject*) const;
+  };
+  
+  template <class T>
+  struct return_reference_from_python
+  {
+      typedef T result_type;
+      T operator()(PyObject*) const;
+  };
+  
+  template <class T>
+  struct return_rvalue_from_python
+  {
+      typedef T result_type;
+
+      return_rvalue_from_python();
+      result_type operator()(PyObject*);
+   private:
+      rvalue_from_python_data<T> m_data;
+  };
+  
+  template <class T>
+  struct return_object_manager_from_python
+  {
+      typedef T result_type;
+      result_type operator()(PyObject*) const;
+  };
+  
+  template <class T>
+  struct select_return_from_python
+  {
+      BOOST_STATIC_CONSTANT(
+          bool, obj_mgr = is_object_manager<T>::value);
+
+      BOOST_STATIC_CONSTANT(
+          bool, ptr = is_pointer<T>::value);
+    
+      BOOST_STATIC_CONSTANT(
+          bool, ref = is_reference<T>::value);
+
+      typedef typename mpl::if_c<
+          obj_mgr
+          , return_object_manager_from_python<T>
+          , typename mpl::if_c<
+              ptr
+              , return_pointer_from_python<T>
+              , typename mpl::if_c<
+                  ref
+                  , return_reference_from_python<T>
+                  , return_rvalue_from_python<T>
+                >::type
+            >::type
+         >::type type;
+  };
+}
+
+template <class T>
+struct return_from_python
+    : detail::select_return_from_python<T>::type
+{
+};
+
+// Specialization as a convenience for call and call_method
+template <>
+struct return_from_python<void>
+{
+    typedef python::detail::returnable<void>::type result_type;
+    
+    result_type operator()(PyObject* x) const
+    {
+        (void_result_from_python)(x);
+# ifdef BOOST_NO_VOID_RETURNS
+        return result_type();
+# endif 
+    }
+};
+
+//
+// Implementations
+//
+namespace detail
+{
+  template <class T>
+  inline return_rvalue_from_python<T>::return_rvalue_from_python()
+      : m_data(
+          const_cast<registration*>(&registered<T>::converters)
+          )
+  {
+  }
+  
+  template <class T>
+  inline typename return_rvalue_from_python<T>::result_type
+  return_rvalue_from_python<T>::operator()(PyObject* obj)
+  {
+    // Take possession of the source object here.  If the result is in
+    // fact going to be a copy of an lvalue embedded in the object,
+    // and we take possession inside rvalue_result_from_python, it
+    // will be destroyed too early.
+    handle<> holder(obj);
+
+      return *(T*)
+          (rvalue_result_from_python)(obj, m_data.stage1);
+  }
+
+  template <class T>
+  inline T return_reference_from_python<T>::operator()(PyObject* obj) const
+  {
+      return python::detail::void_ptr_to_reference(
+          (reference_result_from_python)(obj, registered<T>::converters)
+          , (T(*)())0);
+  }
+
+  template <class T>
+  inline T return_pointer_from_python<T>::operator()(PyObject* obj) const
+  {
+      return T(
+          (pointer_result_from_python)(obj, registered_pointee<T>::converters)
+          );
+  }
+
+  template <class T>
+  inline T return_object_manager_from_python<T>::operator()(PyObject* obj) const
+  {
+      return T(
+          object_manager_traits<T>::adopt(expect_non_null(obj))
+          );
+  }
+}
+  
+}}} // namespace boost::python::converter
+
+#endif // RETURN_FROM_PYTHON_DWA200265_HPP
--- a/include/boost/python/converter/rvalue_from_python_data.hpp
+++ b/include/boost/python/converter/rvalue_from_python_data.hpp
@@ -0,0 +1,140 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef FROM_PYTHON_AUX_DATA_DWA2002128_HPP
+# define FROM_PYTHON_AUX_DATA_DWA2002128_HPP
+
+# include <boost/python/converter/constructor_function.hpp>
+# include <boost/python/detail/referent_storage.hpp>
+# include <boost/python/detail/destroy.hpp>
+# include <boost/static_assert.hpp>
+# include <boost/type_traits/add_reference.hpp>
+# include <boost/type_traits/add_cv.hpp>
+# include <cstddef>
+
+// Data management for potential rvalue conversions from Python to C++
+// types. When a client requests a conversion to T* or T&, we
+// generally require that an object of type T exists in the source
+// Python object, and the code here does not apply**. This implements
+// conversions which may create new temporaries of type T. The classic
+// example is a conversion which converts a Python tuple to a
+// std::vector. Since no std::vector lvalue exists in the Python
+// object -- it must be created "on-the-fly" by the converter, and
+// which must manage the lifetime of the created object.
+//
+// Note that the client is not precluded from using a registered
+// lvalue conversion to T in this case. In other words, we will
+// happily accept a Python object which /does/ contain a std::vector
+// lvalue, provided an appropriate converter is registered. So, while
+// this is an rvalue conversion from the client's point-of-view, the
+// converter registry may serve up lvalue or rvalue conversions for
+// the target type.
+//
+// ** C++ argument from_python conversions to T const& are an
+// exception to the rule for references: since in C++, const
+// references can bind to temporary rvalues, we allow rvalue
+// converters to be chosen when the target type is T const& for some
+// T.
+namespace boost { namespace python { namespace converter { 
+
+// Conversions begin by filling in and returning a copy of this
+// structure. The process looks up a converter in the rvalue converter
+// registry for the target type. It calls the convertible() function
+// of each registered converter, passing the source PyObject* as an
+// argument, until a non-null result is returned. This result goes in
+// the convertible field, and the converter's construct() function is
+// stored in the construct field.
+//
+// If no appropriate converter is found, conversion fails and the
+// convertible field is null. When used in argument conversion for
+// wrapped C++ functions, it causes overload resolution to reject the
+// current function but not to fail completely. If an exception is
+// thrown, overload resolution stops and the exception propagates back
+// through the caller.
+//
+// If an lvalue converter is matched, its convertible() function is
+// expected to return a pointer to the stored T object; its
+// construct() function will be NULL. The convertible() function of
+// rvalue converters may return any non-singular pointer; the actual
+// target object will only be available once the converter's
+// construct() function is called.
+struct rvalue_from_python_stage1_data
+{
+    void* convertible;
+    constructor_function construct;
+};
+
+// Augments rvalue_from_python_stage1_data by adding storage for
+// constructing an object of remove_reference<T>::type. The
+// construct() function of rvalue converters (stored in m_construct
+// above) will cast the rvalue_from_python_stage1_data to an
+// appropriate instantiation of this template in order to access that
+// storage.
+template <class T>
+struct rvalue_from_python_storage
+{
+    rvalue_from_python_stage1_data stage1;
+
+    // Storage for the result, in case an rvalue must be constructed
+    typename python::detail::referent_storage<
+        typename add_reference<T>::type
+    >::type storage;
+};
+
+// Augments rvalue_from_python_storage<T> with a destructor. If
+// stage1.convertible == storage.bytes, it indicates that an object of
+// remove_reference<T>::type has been constructed in storage and
+// should will be destroyed in ~rvalue_from_python_data(). It is
+// crucial that successful rvalue conversions establish this equality
+// and that unsuccessful ones do not.
+template <class T>
+struct rvalue_from_python_data : rvalue_from_python_storage<T>
+{
+# if (!defined(__MWERKS__) || __MWERKS__ >= 0x3000) \
+        && (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 245) \
+        && (!defined(__DECCXX_VER) || __DECCXX_VER > 60590014) \
+        && !defined(BOOST_PYTHON_SYNOPSIS) /* Synopsis' OpenCXX has trouble parsing this */
+    // This must always be a POD struct with m_data its first member.
+    BOOST_STATIC_ASSERT(BOOST_PYTHON_OFFSETOF(rvalue_from_python_storage<T>,stage1) == 0);
+# endif
+    
+    // The usual constructor 
+    rvalue_from_python_data(rvalue_from_python_stage1_data const&);
+
+    // This constructor just sets m_convertible -- used by
+    // implicitly_convertible<> to perform the final step of the
+    // conversion, where the construct() function is already known.
+    rvalue_from_python_data(void* convertible);
+
+    // Destroys any object constructed in the storage.
+    ~rvalue_from_python_data();
+ private:
+    typedef typename add_reference<typename add_cv<T>::type>::type ref_type;
+};
+
+//
+// Implementataions
+//
+template <class T>
+inline rvalue_from_python_data<T>::rvalue_from_python_data(rvalue_from_python_stage1_data const& stage1)
+{
+    this->stage1 = stage1;
+}
+
+template <class T>
+inline rvalue_from_python_data<T>::rvalue_from_python_data(void* convertible)
+{
+    this->stage1.convertible = convertible;
+}
+
+template <class T>
+inline rvalue_from_python_data<T>::~rvalue_from_python_data()
+{
+    if (this->stage1.convertible == this->storage.bytes)
+        python::detail::destroy_referent<ref_type>(this->storage.bytes);
+}
+
+}}} // namespace boost::python::converter
+
+#endif // FROM_PYTHON_AUX_DATA_DWA2002128_HPP
--- a/include/boost/python/converter/shared_ptr_deleter.hpp
+++ b/include/boost/python/converter/shared_ptr_deleter.hpp
@@ -0,0 +1,22 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef SHARED_PTR_DELETER_DWA2002121_HPP
+# define SHARED_PTR_DELETER_DWA2002121_HPP
+
+namespace boost { namespace python { namespace converter { 
+
+struct BOOST_PYTHON_DECL shared_ptr_deleter
+{
+    shared_ptr_deleter(handle<> owner);
+    ~shared_ptr_deleter();
+
+    void operator()(void const*);
+        
+    handle<> owner;
+};
+
+}}} // namespace boost::python::converter
+
+#endif // SHARED_PTR_DELETER_DWA2002121_HPP
--- a/include/boost/python/converter/shared_ptr_from_python.hpp
+++ b/include/boost/python/converter/shared_ptr_from_python.hpp
@@ -0,0 +1,52 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef SHARED_PTR_FROM_PYTHON_DWA20021130_HPP
+# define SHARED_PTR_FROM_PYTHON_DWA20021130_HPP
+
+# include <boost/python/handle.hpp>
+# include <boost/python/converter/shared_ptr_deleter.hpp>
+# include <boost/python/converter/from_python.hpp>
+# include <boost/python/converter/rvalue_from_python_data.hpp>
+# include <boost/python/converter/registered.hpp>
+# include <boost/shared_ptr.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+template <class T>
+struct shared_ptr_from_python
+{
+    shared_ptr_from_python()
+    {
+        converter::registry::insert(&convertible, &construct, type_id<shared_ptr<T> >());
+    }
+
+ private:
+    static void* convertible(PyObject* p)
+    {
+        if (p == Py_None)
+            return p;
+        
+        return converter::get_lvalue_from_python(p, registered<T>::converters);
+    }
+    
+    static void construct(PyObject* source, rvalue_from_python_stage1_data* data)
+    {
+        void* const storage = ((converter::rvalue_from_python_storage<shared_ptr<T> >*)data)->storage.bytes;
+        // Deal with the "None" case.
+        if (data->convertible == source)
+            new (storage) shared_ptr<T>();
+        else
+            new (storage) shared_ptr<T>(
+                static_cast<T*>(data->convertible),
+                shared_ptr_deleter(handle<>(borrowed(source)))
+                );
+        
+        data->convertible = storage;
+    }
+};
+
+}}} // namespace boost::python::converter
+
+#endif // SHARED_PTR_FROM_PYTHON_DWA20021130_HPP
--- a/include/boost/python/converter/shared_ptr_to_python.hpp
+++ b/include/boost/python/converter/shared_ptr_to_python.hpp
@@ -0,0 +1,28 @@
+// Copyright David Abrahams 2003.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef SHARED_PTR_TO_PYTHON_DWA2003224_HPP
+# define SHARED_PTR_TO_PYTHON_DWA2003224_HPP
+
+# include <boost/python/refcount.hpp>
+# include <boost/python/converter/shared_ptr_deleter.hpp>
+# include <boost/shared_ptr.hpp>
+# include <boost/get_pointer.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+template <class T>
+PyObject* shared_ptr_to_python(shared_ptr<T> const& x)
+{
+    if (!x)
+        return python::detail::none();
+    else if (shared_ptr_deleter* d = boost::get_deleter<shared_ptr_deleter>(x))
+        return incref( get_pointer( d->owner ) );
+    else
+        return converter::registered<shared_ptr<T> const&>::converters.to_python(&x);
+}
+
+}}} // namespace boost::python::converter
+
+#endif // SHARED_PTR_TO_PYTHON_DWA2003224_HPP
--- a/include/boost/python/converter/source.hpp
+++ b/include/boost/python/converter/source.hpp
@@ -1,80 +0,0 @@
-//  Copyright David Abrahams 2001. Permission to copy, use,
-//  modify, sell and distribute this software is granted provided this
-//  copyright notice appears in all copies. This software is provided
-//  "as is" without express or implied warranty, and with no claim as
-//  to its suitability for any purpose.
-#ifndef SOURCE_DWA20011119_HPP
-# define SOURCE_DWA20011119_HPP
-# include <boost/type_traits/cv_traits.hpp>
-# include <boost/type_traits/transform_traits.hpp>
-# include <boost/mpl/select_type.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-// source --
-//
-//    This type generator (see
-//    ../../../more/generic_programming.html#type_generator) is used
-//    to select the argument type to use when converting T to a PyObject*
-
-template <class T> struct source;
-
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-// Since for some strange reason temporaries can't be bound to const
-// volatile references (8.5.3/5 in the C++ standard), we cannot use a
-// const volatile reference as the standard for values and references.
-template <class T>
-struct source
-{
-    typedef T const& type;
-};
-
-// This will handle the following:
-//      T const volatile& -> T const volatile&
-//      T volatile& -> T const volatile&
-//      T const& -> T const&
-//      T& -> T const&
-template <class T>
-struct source<T&>
-{
-    typedef T const& type;
-};
-
-template <class T>
-struct source<T*>
-{
-    typedef T const* type;
-};
-
-template <class T>
-struct source<T* const>
-{
-    typedef T const* type;
-};
-
-// Deal with references to pointers
-template <class T>
-struct source<T*&>
-{
-    typedef T const* type;
-};
-
-template <class T>
-struct source<T* const&>
-{
-    typedef T const* type;
-};
-# else
-template <class T>
-struct source
-{
-    typedef typename add_reference<
-        typename add_const<T>::type
-    >::type type;
-};
-# endif
-
-}}} // namespace boost::python::converter
-
-#endif // SOURCE_DWA20011119_HPP
--- a/include/boost/python/converter/source_holder.hpp
+++ b/include/boost/python/converter/source_holder.hpp
@@ -1,24 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef SOURCE_HOLDER_DWA20011215_HPP
-# define SOURCE_HOLDER_DWA20011215_HPP
-
-namespace boost { namespace python { namespace converter { 
-
-struct source_holder_base
-{
-};
-
-template <class T>
-struct source_holder : source_holder_base
-{
-    source_holder(T x) : value(x) {}
-    T value;
-};
-
-}}} // namespace boost::python::converter
-
-#endif // SOURCE_HOLDER_DWA20011215_HPP
--- a/include/boost/python/converter/target.hpp
+++ b/include/boost/python/converter/target.hpp
@@ -1,172 +0,0 @@
-//  Copyright David Abrahams 2001. Permission to copy, use,
-//  modify, sell and distribute this software is granted provided this
-//  copyright notice appears in all copies. This software is provided
-//  "as is" without express or implied warranty, and with no claim as
-//  to its suitability for any purpose.
-
-#ifndef TARGET_DWA20011119_HPP
-# define TARGET_DWA20011119_HPP
-# include <boost/type_traits/cv_traits.hpp>
-# include <boost/type_traits/transform_traits.hpp>
-# include <boost/type_traits/object_traits.hpp>
-# include <boost/mpl/select_type.hpp>
-# include <boost/type_traits/same_traits.hpp>
-
-namespace boost { namespace python { namespace converter {
-
-// target --
-//
-//    This type generator (see
-//    ../../../more/generic_programming.html#type_generator) is used
-//    to select the return type of the appropriate converter for
-//    unwrapping a given type.
-
-// Strategy:
-//
-// 1. reduce everything to a common, un-cv-qualified reference
-//    type where possible. This will save on registering many different
-//    converter types.
-//
-// 2. Treat built-in types specially: when unwrapping a value or
-//    constant reference to one of these, use a value for the target
-//    type. It will bind to a const reference if neccessary, and more
-//    importantly, avoids having to dynamically allocate room for
-//    an lvalue of types which can be cheaply copied.
-//
-// In the tables below, "cv" stands for the set of all possible
-// cv-qualifications.
-
-// Target                Source
-// int                   int
-// int const&            int
-// int&                  int&
-// int volatile&         int volatile&
-// int const volatile&   int const volatile&
-
-// On compilers supporting partial specialization:
-//
-// Target                Source
-// T                     T&
-// T cv&                 T&
-// T cv*                 T*
-// T cv*const&           T*
-// T cv*&                T*& <- should this be legal?
-// T cv*volatile&        T*& <- should this be legal?
-// T cv*const volatile&  T*& <- should this be legal?
-
-// On others:
-//
-// Target                Source
-// T                     T&
-// T cv&                 T cv&
-// T cv*                 T cv*
-// T cv*cv&              T cv*cv&
-
-// As you can see, in order to handle the same range of types without
-// partial specialization, more converters need to be registered.
-
-template <class T>
-struct target
-{
-    // Some pointer types are handled in a more sophisticated way on
-    // compilers supporting partial specialization.
-    BOOST_STATIC_CONSTANT(bool, use_identity = (::boost::is_scalar<T>::value));
-
-    typedef typename mpl::select_type<
-        use_identity
-        , T
-        , typename add_reference<typename remove_cv<T>::type>::type 
-    >::type type;
-};
-
-// When partial specialization is not present, we'll simply need to
-// register many more converters.
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-template <class T>
-struct target<T&>
-{
-    typedef typename remove_cv<T>::type& type;
-};
-
-template <class T>
-struct target<T*>
-{
-    typedef typename remove_cv<T>::type* type;
-};
-
-// Handle T*-cv for completeness. Function arguments in a signature
-// are never actually cv-qualified, but who knows how this might be
-// used, or what compiler bugs may lurk?
-template <class T>
-struct target<T* const>
-{
-    typedef typename remove_cv<T>::type* type;
-};
-
-template <class T>
-struct target<T* volatile>
-{
-    typedef typename remove_cv<T>::type* type;
-};
-
-template <class T>
-struct target<T* const volatile>
-{
-    typedef typename remove_cv<T>::type* type;
-};
-
-// non-const references to pointers should be handled by the
-// specialization for T&, above.
-template <class T>
-struct target<T* const&>
-{
-    typedef typename remove_cv<T>::type* type;
-};
-# endif
-
-// Fortunately, we can handle T const& where T is an arithmetic type
-// by explicit specialization. These specializations will cause value
-// and const& arguments to be converted to values, rather than to
-// references.
-# define  BOOST_PYTHON_UNWRAP_VALUE(T)  \
-template <>                             \
-struct target<T>                        \
-{                                       \
-    typedef T type;                     \
-};                                      \
-template <>                             \
-struct target<T const>                  \
-{                                       \
-    typedef T type;                     \
-};                                      \
-template <>                             \
-struct target<T volatile>               \
-{                                       \
-    typedef T type;                     \
-};                                      \
-template <>                             \
-struct target<T const volatile>         \
-{                                       \
-    typedef T type;                     \
-};                                      \
-template <>                             \
-struct target<T const&>                 \
-{                                       \
-    typedef T type;                     \
-}
-
-BOOST_PYTHON_UNWRAP_VALUE(char);
-BOOST_PYTHON_UNWRAP_VALUE(unsigned char);
-BOOST_PYTHON_UNWRAP_VALUE(signed char);
-BOOST_PYTHON_UNWRAP_VALUE(unsigned int);
-BOOST_PYTHON_UNWRAP_VALUE(signed int);
-BOOST_PYTHON_UNWRAP_VALUE(unsigned short);
-BOOST_PYTHON_UNWRAP_VALUE(signed short);
-BOOST_PYTHON_UNWRAP_VALUE(unsigned long);
-BOOST_PYTHON_UNWRAP_VALUE(signed long);
-BOOST_PYTHON_UNWRAP_VALUE(char const*);
-
-}}} // namespace boost::python::converter
-
-#endif // TARGET_DWA20011119_HPP
--- a/include/boost/python/converter/to_python_function_type.hpp
+++ b/include/boost/python/converter/to_python_function_type.hpp
@@ -0,0 +1,19 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef TO_PYTHON_FUNCTION_TYPE_DWA200236_HPP
+# define TO_PYTHON_FUNCTION_TYPE_DWA200236_HPP
+# include <boost/python/detail/prefix.hpp>
+# include <boost/static_assert.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+// The type of stored function pointers which actually do conversion
+// by-value. The void* points to the object to be converted, and
+// type-safety is preserved through runtime registration.
+typedef PyObject* (*to_python_function_t)(void const*);
+
+}}} // namespace boost::python::converter
+
+#endif // TO_PYTHON_FUNCTION_TYPE_DWA200236_HPP
--- a/include/boost/python/converter/type_id.hpp
+++ b/include/boost/python/converter/type_id.hpp
@@ -1,200 +0,0 @@
-//  Copyright David Abrahams 2001. Permission to copy, use,
-//  modify, sell and distribute this software is granted provided this
-//  copyright notice appears in all copies. This software is provided
-//  "as is" without express or implied warranty, and with no claim as
-//  to its suitability for any purpose.
-#ifndef TYPE_ID_DWA20011127_HPP
-# define TYPE_ID_DWA20011127_HPP
-# include <boost/config.hpp>
-# include <boost/python/export.hpp>
-# include <boost/mpl/select_type.hpp>
-# include <boost/type_traits/cv_traits.hpp>
-# include <boost/type_traits/composite_traits.hpp>
-# include <boost/python/export.hpp>
-# include <boost/operators.hpp>
-# include <typeinfo>
-# include <iosfwd>
-# include <cstring>
-
-
-namespace boost { namespace python { namespace converter { 
-
-// a portable mechanism for identifying types at runtime across modules.
-
-namespace detail
-{
-  template <class T> class dummy;
-}
-
-// for this compiler at least, cross-shared-library type_info
-// comparisons don't work, so use typeid(x).name() instead. It's not
-// yet clear what the best default strategy is.
-# if defined(__GNUC__) && __GNUC__ >= 3
-#  define BOOST_PYTHON_TYPE_ID_NAME
-# endif 
-
-# if 1
-struct type_id_t : totally_ordered<type_id_t>
-{
-    enum decoration { const_ = 0x1, volatile_ = 0x2, reference = 0x4 };
-    
-#  ifdef BOOST_PYTHON_TYPE_ID_NAME
-typedef char const* base_id_t;
-#  else
-typedef std::type_info const* base_id_t;
-#  endif
-    
-    type_id_t(base_id_t, decoration decoration);
-
-    bool operator<(type_id_t const& rhs) const;
-    bool operator==(type_id_t const& rhs) const;
-    friend BOOST_PYTHON_EXPORT std::ostream& operator<<(std::ostream&, type_id_t const&);
-    
- private:
-    decoration m_decoration;
-    base_id_t m_base_type;
-};
-
-#  ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T>
-struct is_reference_to_const
-{
-    BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template <class T>
-struct is_reference_to_const<T const&>
-{
-    BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-template <class T>
-struct is_reference_to_volatile
-{
-    BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template <class T>
-struct is_reference_to_volatile<T volatile&>
-{
-    BOOST_STATIC_CONSTANT(bool, value = true);
-};
-#  else 
-template <typename V>
-struct is_const_help
-{
-    typedef typename mpl::select_type<
-        is_const<V>::value
-        , type_traits::yes_type
-        , type_traits::no_type
-        >::type type;
-};
-
-template <typename V>
-struct is_volatile_help
-{
-    typedef typename mpl::select_type<
-        is_volatile<V>::value
-        , type_traits::yes_type
-        , type_traits::no_type
-        >::type type;
-};
-
-template <typename V>
-typename is_const_help<V>::type reference_to_const_helper(V&);
-    
-type_traits::no_type
-reference_to_const_helper(...);
-
-template <class T>
-struct is_reference_to_const
-{
-    static T t;
-    BOOST_STATIC_CONSTANT(
-        bool, value
-        = sizeof(reference_to_const_helper(t)) == sizeof(type_traits::yes_type));
-};
-
-template <typename V>
-typename is_volatile_help<V>::type reference_to_volatile_helper(V&);
-type_traits::no_type reference_to_volatile_helper(...);
-
-template <class T>
-struct is_reference_to_volatile
-{
-    static T t;
-    BOOST_STATIC_CONSTANT(
-        bool, value
-        = sizeof(reference_to_volatile_helper(t)) == sizeof(type_traits::yes_type));
-};
-#  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION 
-
-template <class T>
-inline type_id_t type_id(detail::dummy<T>* = 0)
-{
-    return type_id_t(
-#  ifdef BOOST_PYTHON_TYPE_ID_NAME
-        typeid(T).name()
-#  else
-        &typeid(T)
-#  endif 
-        , type_id_t::decoration(
-            (is_const<T>::value || is_reference_to_const<T>::value
-             ? type_id_t::const_ : 0)
-            | (is_volatile<T>::value || is_reference_to_volatile<T>::value
-               ? type_id_t::volatile_ : 0)
-            | (is_reference<T>::value ? type_id_t::reference : 0)
-            )
-        );
-}
-
-inline type_id_t::type_id_t(base_id_t base_t, decoration decoration)
-    : m_decoration(decoration)
-    , m_base_type(base_t)
-{
-}
-
-inline bool type_id_t::operator<(type_id_t const& rhs) const
-{
-    return m_decoration < rhs.m_decoration
-        || m_decoration == rhs.m_decoration
-#  ifdef BOOST_PYTHON_TYPE_ID_NAME
-           && std::strcmp(m_base_type, rhs.m_base_type) < 0;
-#  else
-           && m_base_type->before(*rhs.m_base_type);
-#  endif 
-}
-
-inline bool type_id_t::operator==(type_id_t const& rhs) const
-{
-    return m_decoration == rhs.m_decoration
-#  ifdef BOOST_PYTHON_TYPE_ID_NAME
-        && !std::strcmp(m_base_type, rhs.m_base_type);
-#  else
-        && *m_base_type == *rhs.m_base_type;
-#  endif 
-}
-
-# else 
-// This is the type which is used to identify a type
-typedef char const* type_id_t;
-
-// This is a workaround for a silly MSVC bug
-// Converts a compile-time type to its corresponding runtime identifier.
-template <class T>
-type_id_t type_id(detail::dummy<T>* = 0)
-{
-    return typeid(T).name();
-}
-# endif 
-
-struct BOOST_PYTHON_EXPORT type_id_before
-{
-    bool operator()(type_id_t const& x, type_id_t const& y) const;
-};
-
-BOOST_PYTHON_EXPORT std::ostream& operator<<(std::ostream&, type_id_t const&);
-
-}}} // namespace boost::python::converter
-
-#endif // TYPE_ID_DWA20011127_HPP
--- a/include/boost/python/converter/unwrap.hpp
+++ b/include/boost/python/converter/unwrap.hpp
@@ -1,192 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef UNWRAP_BASE_DWA20011130_HPP
-# define UNWRAP_BASE_DWA20011130_HPP
-
-# include <boost/python/converter/unwrapper_base.hpp>
-# include <boost/python/converter/unwrapper.hpp>
-# include <boost/python/converter/handle.hpp>
-# include <boost/python/converter/registration.hpp>
-# include <boost/python/converter/type_id.hpp>
-# include <boost/python/export.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-template <class T> struct unwrapper;
-struct BOOST_PYTHON_EXPORT body;
-
-struct BOOST_PYTHON_EXPORT unwrap_base : handle
-{
- public: // member functions
-    inline unwrap_base(PyObject* source, body*, handle& prev);
-    inline unwrap_base(PyObject* source, body*);
-    inline PyObject* source() const;
-
- private: // data members
-    PyObject* m_source;
-};
-
-// These converters will be used by the function wrappers. They don't
-// manage any resources, but are instead linked into a chain which is
-// managed by an instance of unwrap_ or wrap_.
-template <class T>
-struct unwrap_more_ : unwrap_base
-{
- public: // member functions
-    // Construction
-    unwrap_more_(PyObject* source, handle& prev);
-
-    // invoke the conversion or throw an exception if unsuccessful
-    T operator*();
-
- protected: // constructor
-    // this constructor is only for the use of unwrap_
-    unwrap_more_(PyObject* source);
-
- private: // helper functions
-    // Return the unwrapper which will convert the given Python object
-    // to T, or 0 if no such converter exists
-    static unwrapper_base* lookup(PyObject*);
-
- private:
-    // unspecified storage which may be allocated by the unwrapper to
-    // do value conversions.
-    mutable void* m_storage;
-    friend class unwrapper<T>;
-};
-
-// specialization for PyObject*
-template <>
-struct unwrap_more_<PyObject*>
-    : unwrap_base
-{
- public: // member functions
-    // Construction
-    unwrap_more_(PyObject* source, handle& prev)
-        : unwrap_base(source, m_unwrapper, prev)
-    {
-    }
-
-
-    // invoke the conversion or throw an exception if unsuccessful
-    PyObject* operator*()
-    {
-        return source();
-    }
-        
-    bool convertible(PyObject*) const
-    {
-        return true;
-    }
-    
- protected: // constructor
-    // this constructor is only for the use of unwrap_
-    unwrap_more_(PyObject* source)
-    : unwrap_base(source, m_unwrapper)
-
-    {
-    }
- private:
-    static BOOST_PYTHON_EXPORT unwrapper_base* m_unwrapper;
-};
-
-template <class T>
-struct unwrap_ : unwrap_more_<T>
-{
-    unwrap_(PyObject* source);
-    ~unwrap_();
-};
-
-//
-// implementations
-//
-inline unwrap_base::unwrap_base(PyObject* source, body* body, handle& prev)
-    : handle(body, prev)
-    , m_source(source)
-{
-}
-
-inline unwrap_base::unwrap_base(PyObject* source, body* body)
-    : handle(body)
-    , m_source(source)
-{
-}
-
-inline PyObject* unwrap_base::source() const
-{
-    return m_source;
-}
-
-template <class T>
-inline unwrapper_base* unwrap_more_<T>::lookup(PyObject* source)
-{
-    // Find the converters registered for T and get a unwrapper
-    // appropriate for the source object
-    return registration<T>::unwrapper(source);
-}
-
-template <class T>
-unwrap_more_<T>::unwrap_more_(PyObject* source, handle& prev)
-    : unwrap_base(source, lookup(source), prev)
-    , m_storage(0)
-{
-}
-
-template <class T>
-unwrap_more_<T>::unwrap_more_(PyObject* source)
-    : unwrap_base(source, lookup(source))
-    , m_storage(0)
-{
-}
-
-# if 0
-template <>
-inline unwrap_more_<PyObject*>::unwrap_more_(PyObject* source, handle& prev)
-    : unwrap_base(source, m_unwrapper, prev)
-{
-}
-
-template <>
-inline unwrap_more_<PyObject*>::unwrap_more_(PyObject* source)
-    : unwrap_base(source, m_unwrapper)
-
-{
-}
-
-template <>
-inline PyObject* unwrap_more_<PyObject*>::operator*()
-{
-    return source();
-}
-
-template <>
-inline bool unwrap_more_<PyObject*>::convertible(PyObject*) const
-{
-    return true;
-}
-# endif 
-template <class T>
-inline unwrap_<T>::unwrap_(PyObject* source)
-    : unwrap_more_<T>(source)
-{
-}
-
-template <class T>
-T unwrap_more_<T>::operator*()
-{
-    return static_cast<unwrapper<T>*>(
-        get_body())->do_conversion(this);
-}
-
-template <class T>
-unwrap_<T>::~unwrap_()
-{
-    destroy();
-}
-    
-}}} // namespace boost::python::converter
-
-#endif // UNWRAP_BASE_DWA20011130_HPP
--- a/include/boost/python/converter/unwrapper.hpp
+++ b/include/boost/python/converter/unwrapper.hpp
@@ -1,53 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef UNWRAPPER_DWA2001127_HPP
-# define UNWRAPPER_DWA2001127_HPP
-
-# include <boost/python/converter/unwrapper_base.hpp>
-# include <boost/python/converter/unwrap.hpp>
-# include <boost/python/converter/body.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-template <class T> struct unwrap_more_;
-
-// Abstract base for all unwrappers of Ts
-template <class T>
-struct unwrapper : unwrapper_base
-{
- public:
-    unwrapper();
-
-    T do_conversion(unwrap_more_<T> const* handle) const;
-    
- private:
-    virtual T convert(PyObject*, void*&) const = 0;
-    
- private: // body required interface implementation
-    void destroy_handle(handle*) const {}
-};
-
-//
-// implementations
-//
-template <class T>
-unwrapper<T>::unwrapper()
-    : unwrapper_base(type_id<T>())
-{
-}
-
-// We could think about making this virtual in an effort to get its
-// code generated in the module where the unwrapper is defined, but
-// it's not clear that it's a good tradeoff.
-template <class T>
-T unwrapper<T>::do_conversion(unwrap_more_<T> const* handle) const
-{
-    return convert(handle->source(), handle->m_storage);
-}
-
-}}} // namespace boost::python::converter
-
-#endif // UNWRAPPER_DWA2001127_HPP
--- a/include/boost/python/converter/unwrapper_base.hpp
+++ b/include/boost/python/converter/unwrapper_base.hpp
@@ -1,25 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef UNWRAPPER_BASE_DWA20011215_HPP
-# define UNWRAPPER_BASE_DWA20011215_HPP
-# include <boost/python/converter/type_id.hpp>
-# include <boost/python/converter/body.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/export.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-struct BOOST_PYTHON_EXPORT unwrapper_base : body
-{
- public:
-    unwrapper_base(type_id_t); // registers
-    ~unwrapper_base();         // unregisters
-    virtual bool convertible(PyObject*) const = 0;
-};
-
-}}} // namespace boost::python::converter
-
-#endif // UNWRAPPER_BASE_DWA20011215_HPP
--- a/include/boost/python/converter/wrap.hpp
+++ b/include/boost/python/converter/wrap.hpp
@@ -1,145 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef WRAP_DWA2001127_HPP
-# define WRAP_DWA2001127_HPP
-# include <boost/python/converter/registration.hpp>
-# include <boost/python/converter/handle.hpp>
-# include <boost/python/converter/body.hpp>
-# include <boost/python/converter/wrapper.hpp>
-# include <boost/python/export.hpp>
-# include <boost/python/converter/source_holder.hpp>
-# include <cassert>
-
-namespace boost { namespace python { namespace converter { 
-
-struct BOOST_PYTHON_EXPORT wrapper_base;
-
-template <class T> struct wrapper;
-
-struct wrap_base : handle
-{
- public: // member functions
-    wrap_base(body*, handle& prev);
-    wrap_base(body*);
-    PyObject* release();
-    
- public: // accessor, really only for wrappers
-    PyObject*& target() const;
-    
- protected:
-    void hold_result(PyObject*) const;
-    
- private: 
-    mutable PyObject* m_target;
-};
-
-template <class T>
-struct wrap_more_ : wrap_base
-{
- protected:
-    typedef T source_t;
-    
- public: // member functions
-    wrap_more_(handle& prev);
-
-    PyObject* operator()(source_t) const;
-
- protected: // constructor for wrap_<T>, below
-    wrap_more_();
-    
- private: // helper functions
-    static wrapper_base* lookup();
-    
- private:
-    friend class wrapper<T>;
-};
-
-template <class T>
-struct wrap_ : wrap_more_<T>
-{
-    typedef typename wrap_more_<T>::source_t source_t;
- public: // member functions
-    wrap_();
-    ~wrap_();
-};
-
-//
-// implementations
-//
-
-inline wrap_base::wrap_base(body* body, handle& prev)
-    : handle(body, prev),
-      m_target(0)
-{
-}
-
-inline wrap_base::wrap_base(body* body)
-    : handle(body),
-      m_target(0)
-{
-}
-
-inline PyObject*& wrap_base::target() const
-{
-    return m_target;
-}
-
-inline void wrap_base::hold_result(PyObject* p) const
-{
-    assert(m_target == 0);
-    m_target = p;
-}
-
-inline PyObject* wrap_base::release()
-{
-    PyObject* result = m_target;
-    m_target = 0;
-    return result;
-}
-
-template <class T>
-inline wrapper_base* wrap_more_<T>::lookup()
-{
-    // Find the converters registered for T and get a wrapper
-    // appropriate for the source object
-    return registration<T>::wrapper();
-}
-
-template <class T>
-inline wrap_more_<T>::wrap_more_(handle& prev)
-    : wrap_base(lookup(), prev)
-{
-    
-}
-
-template <class T>
-PyObject* wrap_more_<T>::operator()(source_t x) const
-{
-    return static_cast<wrapper<T>*>(
-        get_body())->do_conversion(*this, source_holder<T>(x));
-}
-
-template <class T>
-wrap_more_<T>::wrap_more_()
-    : wrap_base(lookup())
-{
-}
-
-template <class T>
-wrap_<T>::wrap_()
-    : wrap_more_<T>()
-{
-}
-
-template <class T>
-wrap_<T>::~wrap_()
-{
-    destroy();
-}
-
-}}} // namespace boost::python::converter
-
-#endif // WRAP_DWA2001127_HPP
--- a/include/boost/python/converter/wrapper.hpp
+++ b/include/boost/python/converter/wrapper.hpp
@@ -1,69 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef WRAPPER_DWA2001127_HPP
-# define WRAPPER_DWA2001127_HPP
-# include <boost/config.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/converter/body.hpp>
-# include <boost/python/converter/type_id.hpp>
-# include <boost/python/converter/wrap.hpp>
-# include <boost/python/converter/source_holder.hpp>
-# include <boost/python/export.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-struct source_holder_base;
-struct wrap_base;
-template <class T> struct wrap_more_;
-
-struct BOOST_PYTHON_EXPORT wrapper_base : body
-{
- public:
-    wrapper_base(type_id_t); // registers
-    ~wrapper_base();         // unregisters
-    
-    virtual PyObject* do_conversion(wrap_base const&, source_holder_base const&) const = 0;
-};
-
-template <class T>
-struct wrapper : wrapper_base
-{
- public:
-    wrapper();
-    
-    PyObject* do_conversion(wrap_base const&, source_holder_base const&) const;
-    
-    // This does the actual conversion
-    virtual PyObject* convert(T source) const = 0;
-};
-
-//
-// implementations
-//
-
-template <class T>
-wrapper<T>::wrapper()
-    : wrapper_base(type_id<T>())
-{
-}
-
-
-template <class T>
-PyObject* wrapper<T>::do_conversion(wrap_base const& handle_, source_holder_base const& data_) const
-{
-    // Casting pointers instead of references suppresses a CWPro7 bug.
-    wrap_more_<T> const& handle = *static_cast<wrap_more_<T> const*>(&handle_);
-    source_holder<T> const& data = *static_cast<source_holder<T> const*>(&data_);
-    if (handle.target() == 0)
-    {
-        handle.hold_result(convert(data.value));
-    }
-    return handle.target();
-}
-
-}}} // namespace boost::python::converter
-
-#endif // WRAPPER_DWA2001127_HPP
--- a/include/boost/python/copy_const_reference.hpp
+++ b/include/boost/python/copy_const_reference.hpp
@@ -0,0 +1,43 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef COPY_CONST_REFERENCE_DWA2002131_HPP
+# define COPY_CONST_REFERENCE_DWA2002131_HPP
+
+# include <boost/python/detail/prefix.hpp>
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/python/to_python_value.hpp>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  template <class R>
+  struct copy_const_reference_expects_a_const_reference_return_type
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
+  {}
+# endif
+  ;
+}
+
+template <class T> struct to_python_value;
+
+struct copy_const_reference
+{
+    template <class T>
+    struct apply
+    {
+        typedef typename mpl::if_c<
+            indirect_traits::is_reference_to_const<T>::value
+          , to_python_value<T>
+          , detail::copy_const_reference_expects_a_const_reference_return_type<T>
+        >::type type;
+    };
+};
+
+
+}} // namespace boost::python
+
+#endif // COPY_CONST_REFERENCE_DWA2002131_HPP
--- a/include/boost/python/copy_non_const_reference.hpp
+++ b/include/boost/python/copy_non_const_reference.hpp
@@ -0,0 +1,43 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef COPY_NON_CONST_REFERENCE_DWA2002131_HPP
+# define COPY_NON_CONST_REFERENCE_DWA2002131_HPP
+
+# include <boost/python/detail/prefix.hpp>
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/python/to_python_value.hpp>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  template <class R>
+  struct copy_non_const_reference_expects_a_non_const_reference_return_type
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
+  {}
+# endif
+  ;
+}
+
+template <class T> struct to_python_value;
+
+struct copy_non_const_reference
+{
+    template <class T>
+    struct apply
+    {
+        typedef typename mpl::if_c<
+            indirect_traits::is_reference_to_non_const<T>::value
+            , to_python_value<T>
+            , detail::copy_non_const_reference_expects_a_non_const_reference_return_type<T>
+        >::type type;
+    };
+};
+
+
+}} // namespace boost::python
+
+#endif // COPY_NON_CONST_REFERENCE_DWA2002131_HPP
--- a/include/boost/python/data_members.hpp
+++ b/include/boost/python/data_members.hpp
@@ -0,0 +1,316 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef DATA_MEMBERS_DWA2002328_HPP
+# define DATA_MEMBERS_DWA2002328_HPP
+
+# include <boost/python/detail/prefix.hpp>
+
+# include <boost/python/handle.hpp>
+
+# include <boost/python/return_value_policy.hpp>
+# include <boost/python/return_by_value.hpp>
+# include <boost/python/return_internal_reference.hpp>
+# include <boost/python/make_function.hpp>
+
+# include <boost/python/converter/builtin_converters.hpp>
+
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/python/detail/not_specified.hpp>
+# include <boost/python/detail/value_arg.hpp>
+
+# include <boost/type_traits/add_const.hpp>
+# include <boost/type_traits/add_reference.hpp>
+# include <boost/type_traits/is_member_pointer.hpp>
+
+# if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+#  include <boost/type_traits/remove_cv.hpp>
+# endif 
+
+# include <boost/mpl/eval_if.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/mpl/vector/vector10.hpp>
+
+# include <boost/detail/workaround.hpp>
+
+namespace boost { namespace python { 
+
+//
+// This file defines the make_getter and make_setter function
+// families, which are responsible for turning pointers, references,
+// and pointers-to-data-members into callable Python objects which
+// can be used for attribute access on wrapped classes.
+//
+
+namespace detail
+{
+
+  // A small function object which handles the getting and setting of
+  // data members.
+  template <class Data, class Class>
+  struct member
+  {
+   public:      
+      member(Data Class::*which) : m_which(which) {}
+      
+      Data& operator()(Class& c) const
+      {
+          return c.*m_which;
+      }
+
+      void operator()(Class& c, typename value_arg<Data>::type d) const
+      {
+          c.*m_which = d;
+      }
+   private:
+      Data Class::*m_which;
+  };
+
+  // A small function object which handles the getting and setting of
+  // non-member objects.
+  template <class Data>
+  struct datum
+  {
+   public:      
+      datum(Data *which) : m_which(which) {}
+      
+      Data& operator()() const
+      {
+          return *m_which;
+      }
+
+      void operator()(typename value_arg<Data>::type d) const
+      {
+          *m_which = d;
+      }
+   private:
+      Data *m_which;
+  };
+  
+  //
+  // Helper metafunction for determining the default CallPolicy to use
+  // for attribute access.  If T is a [reference to a] class type X
+  // whose conversion to python would normally produce a new copy of X
+  // in a wrapped X class instance (as opposed to types such as
+  // std::string, which are converted to native Python types, and
+  // smart pointer types which produce a wrapped class instance of the
+  // pointee type), to-python conversions will attempt to produce an
+  // object which refers to the original C++ object, rather than a
+  // copy.  See default_member_getter_policy for rationale.
+  // 
+  template <class T>
+  struct default_getter_by_ref
+      : mpl::and_<
+          mpl::bool_<
+              to_python_value<
+                  typename value_arg<T>::type
+              >::uses_registry
+          >
+        , indirect_traits::is_reference_to_class<
+              typename value_arg<T>::type
+          >
+       >
+  {
+  };
+
+  // Metafunction computing the default CallPolicy to use for reading
+  // data members
+  //
+  // If it's a regular class type (not an object manager or other
+  // type for which we have to_python specializations, use
+  // return_internal_reference so that we can do things like
+  //    x.y.z =  1
+  // and get the right result.
+  template <class T>
+  struct default_member_getter_policy
+    : mpl::if_<
+          default_getter_by_ref<T>
+        , return_internal_reference<>
+        , return_value_policy<return_by_value>
+      >
+  {};
+
+  // Metafunction computing the default CallPolicy to use for reading
+  // non-member data.
+  template <class T>
+  struct default_datum_getter_policy
+    : mpl::if_<
+          default_getter_by_ref<T>
+        , return_value_policy<reference_existing_object>
+        , return_value_policy<return_by_value>
+      >
+  {};
+
+  //
+  // make_getter helper function family -- These helpers to
+  // boost::python::make_getter are used to dispatch behavior.  The
+  // third argument is a workaround for a CWPro8 partial ordering bug
+  // with pointers to data members.  It should be convertible to
+  // mpl::true_ iff the first argument is a pointer-to-member, and
+  // mpl::false_ otherwise.  The fourth argument is for compilers
+  // which don't support partial ordering at all and should always be
+  // passed 0L.
+  //
+
+#if BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+  template <class D, class P>
+  inline object make_getter(D& d, P& p, mpl::false_, ...);
+#endif
+
+  // Handle non-member pointers with policies
+  template <class D, class Policies>
+  inline object make_getter(D* d, Policies const& policies, mpl::false_, int)
+  {
+      return python::make_function(
+          detail::datum<D>(d), policies, mpl::vector1<D&>()
+      );
+  }
+  
+  // Handle non-member pointers without policies
+  template <class D>
+  inline object make_getter(D* d, not_specified, mpl::false_, long)
+  {
+      typedef typename default_datum_getter_policy<D>::type policies;
+      return detail::make_getter(d, policies(), mpl::false_(), 0);
+  }
+
+  // Handle pointers-to-members with policies
+  template <class C, class D, class Policies>
+  inline object make_getter(D C::*pm, Policies const& policies, mpl::true_, int)
+  {
+#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+      typedef typename remove_cv<C>::type Class;
+#else
+      typedef C Class;
+#endif 
+      return python::make_function(
+          detail::member<D,Class>(pm)
+        , policies
+        , mpl::vector2<D&,Class&>()
+      );
+  }
+      
+  // Handle pointers-to-members without policies
+  template <class C, class D>
+  inline object make_getter(D C::*pm, not_specified, mpl::true_, long)
+  {
+      typedef typename default_member_getter_policy<D>::type policies;
+      return detail::make_getter(pm, policies(), mpl::true_(), 0);
+  }
+
+  // Handle references
+  template <class D, class P>
+  inline object make_getter(D& d, P& p, mpl::false_, ...)
+  {
+      // Just dispatch to the handler for pointer types.
+      return detail::make_getter(&d, p, mpl::false_(), 0L);
+  }
+
+  //
+  // make_setter helper function family -- These helpers to
+  // boost::python::make_setter are used to dispatch behavior.  The
+  // third argument is for compilers which don't support partial
+  // ordering at all and should always be passed 0.
+  //
+
+  
+  // Handle non-member pointers
+  template <class D, class Policies>
+  inline object make_setter(D* p, Policies const& policies, mpl::false_, int)
+  {
+      return python::make_function(
+          detail::datum<D>(p), policies, mpl::vector2<void,D const&>()
+      );
+  }
+
+  // Handle pointers-to-members
+  template <class C, class D, class Policies>
+  inline object make_setter(D C::*pm, Policies const& policies, mpl::true_, int)
+  {
+      return python::make_function(
+          detail::member<D,C>(pm)
+        , policies
+        , mpl::vector3<void, C&, D const&>()
+      );
+  }
+
+  // Handle references
+  template <class D, class Policies>
+  inline object make_setter(D& x, Policies const& policies, mpl::false_, ...)
+  {
+      return detail::make_setter(&x, policies, mpl::false_(), 0L);
+  }
+}
+
+//
+// make_getter function family -- build a callable object which
+// retrieves data through the first argument and is appropriate for
+// use as the `get' function in Python properties .  The second,
+// policies argument, is optional.  We need both D& and D const&
+// overloads in order be able to handle rvalues.
+//
+template <class D, class Policies>
+inline object make_getter(D& d, Policies const& policies)
+{
+    return detail::make_getter(d, policies, is_member_pointer<D>(), 0L);
+}
+
+template <class D, class Policies>
+inline object make_getter(D const& d, Policies const& policies)
+{
+    return detail::make_getter(d, policies, is_member_pointer<D>(), 0L);
+}
+
+template <class D>
+inline object make_getter(D& x)
+{
+    detail::not_specified policy;
+    return detail::make_getter(x, policy, is_member_pointer<D>(), 0L);
+}
+
+#  if !BOOST_WORKAROUND(__EDG_VERSION__, <= 238) && !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+template <class D>
+inline object make_getter(D const& d)
+{
+    detail::not_specified policy;
+    return detail::make_getter(d, policy, is_member_pointer<D>(), 0L);
+}
+#  endif
+
+//
+// make_setter function family -- build a callable object which
+// writes data through the first argument and is appropriate for
+// use as the `set' function in Python properties .  The second,
+// policies argument, is optional.  We need both D& and D const&
+// overloads in order be able to handle rvalues.
+//
+template <class D, class Policies>
+inline object make_setter(D& x, Policies const& policies)
+{
+    return detail::make_setter(x, policies, is_member_pointer<D>(), 0);
+}
+
+template <class D, class Policies>
+inline object make_setter(D const& x, Policies const& policies)
+{
+    return detail::make_setter(x, policies, is_member_pointer<D>(), 0);
+}
+
+template <class D>
+inline object make_setter(D& x)
+{
+    return detail::make_setter(x, default_call_policies(), is_member_pointer<D>(), 0);
+}
+
+# if !(BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || BOOST_WORKAROUND(__EDG_VERSION__, <= 238))
+template <class D>
+inline object make_setter(D const& x)
+{
+    return detail::make_setter(x, default_call_policies(), is_member_pointer<D>(), 0);
+}
+# endif
+
+}} // namespace boost::python
+
+#endif // DATA_MEMBERS_DWA2002328_HPP
--- a/include/boost/python/def.hpp
+++ b/include/boost/python/def.hpp
@@ -0,0 +1,114 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef DEF_DWA200292_HPP
+# define DEF_DWA200292_HPP
+
+# include <boost/python/detail/prefix.hpp>
+
+# include <boost/python/object_fwd.hpp>
+# include <boost/python/make_function.hpp>
+# include <boost/python/detail/def_helper.hpp>
+# include <boost/python/detail/overloads_fwd.hpp>
+# include <boost/python/scope.hpp>
+# include <boost/python/signature.hpp>
+# include <boost/python/detail/scope.hpp>
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  namespace error
+  {
+    // Compile-time error messages
+    template <bool> struct multiple_functions_passed_to_def;
+    template <> struct multiple_functions_passed_to_def<false> { typedef char type; };
+  }
+  
+  //
+  // def_from_helper --
+  //
+  // Use a def_helper to define a regular wrapped function in the current scope.
+  template <class F, class Helper>
+  void def_from_helper(
+      char const* name, F const& fn, Helper const& helper)
+  {
+      // Must not try to use default implementations except with method definitions.
+      typedef typename error::multiple_functions_passed_to_def<
+          Helper::has_default_implementation
+          >::type assertion;
+      
+      detail::scope_setattr_doc(
+          name, boost::python::make_function(
+              fn
+              , helper.policies()
+              , helper.keywords())
+          , helper.doc()
+          );
+  }
+
+  //
+  // These two overloads discriminate between def() as applied to
+  // regular functions and def() as applied to the result of
+  // BOOST_PYTHON_FUNCTION_OVERLOADS(). The final argument is used to
+  // discriminate.
+  //
+  template <class Fn, class A1>
+  void
+  def_maybe_overloads(
+      char const* name
+      , Fn fn
+      , A1 const& a1
+      , ...)
+  {
+      detail::def_from_helper(name, fn, def_helper<A1>(a1));
+  }
+
+  template <class StubsT, class SigT>
+  void def_maybe_overloads(
+      char const* name
+      , SigT sig
+      , StubsT const& stubs
+      , detail::overloads_base const*)
+  {
+      scope current;
+      
+      detail::define_with_defaults(
+          name, stubs, current, detail::get_signature(sig));
+  }
+
+  template <class T>
+  object make_function1(T fn, ...) { return make_function(fn); }
+
+  inline
+  object make_function1(object const& x, object const*) { return x; }
+}
+
+template <class Fn>
+void def(char const* name, Fn fn)
+{
+    detail::scope_setattr_doc(name, detail::make_function1(fn, &fn), 0);
+}
+
+template <class Arg1T, class Arg2T>
+void def(char const* name, Arg1T arg1, Arg2T const& arg2)
+{
+    detail::def_maybe_overloads(name, arg1, arg2, &arg2);
+}
+
+template <class F, class A1, class A2>
+void def(char const* name, F f, A1 const& a1, A2 const& a2)
+{
+    detail::def_from_helper(name, f, detail::def_helper<A1,A2>(a1,a2));
+}
+
+template <class F, class A1, class A2, class A3>
+void def(char const* name, F f, A1 const& a1, A2 const& a2, A3 const& a3)
+{
+    detail::def_from_helper(name, f, detail::def_helper<A1,A2,A3>(a1,a2,a3));
+}
+
+}} // namespace boost::python
+
+#endif // DEF_DWA200292_HPP
--- a/include/boost/python/def_visitor.hpp
+++ b/include/boost/python/def_visitor.hpp
@@ -0,0 +1,86 @@
+// Copyright David Abrahams 2003.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef DEF_VISITOR_DWA2003810_HPP
+# define DEF_VISITOR_DWA2003810_HPP
+
+# include <boost/python/detail/prefix.hpp>
+# include <boost/detail/workaround.hpp>
+
+namespace boost { namespace python { 
+
+template <class DerivedVisitor> class def_visitor;
+template <class T, class X1, class X2, class X3> class class_;
+
+class def_visitor_access
+{
+# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)                  \
+    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+    // Tasteless as this may seem, making all members public allows member templates
+    // to work in the absence of member template friends.
+ public:
+# else      
+    template <class Derived> friend class def_visitor;
+# endif
+    
+    // unnamed visit, c.f. init<...>, container suites
+    template <class V, class classT>
+    static void visit(V const& v, classT& c)
+    {
+        v.derived_visitor().visit(c);
+    }
+
+    // named visit, c.f. object, pure_virtual
+    template <class V, class classT, class OptionalArgs>
+    static void visit(
+        V const& v
+      , classT& c
+      , char const* name
+      , OptionalArgs const& options
+    ) 
+    {
+        v.derived_visitor().visit(c, name, options);
+    }
+    
+};
+
+
+template <class DerivedVisitor>
+class def_visitor
+{
+    friend class def_visitor_access;
+    
+# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)                  \
+    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+    // Tasteless as this may seem, making all members public allows member templates
+    // to work in the absence of member template friends.
+ public:
+# else      
+    template <class T, class X1, class X2, class X3> friend class class_;
+# endif
+    
+    // unnamed visit, c.f. init<...>, container suites
+    template <class classT>
+    void visit(classT& c) const
+    {
+        def_visitor_access::visit(*this, c);
+    }
+
+    // named visit, c.f. object, pure_virtual
+    template <class classT, class OptionalArgs>
+    void visit(classT& c, char const* name, OptionalArgs const& options) const
+    {
+        def_visitor_access::visit(*this, c, name, options);
+    }
+    
+ protected:
+    DerivedVisitor const& derived_visitor() const
+    {
+        return static_cast<DerivedVisitor const&>(*this);
+    }
+};
+
+}} // namespace boost::python
+
+#endif // DEF_VISITOR_DWA2003810_HPP
--- a/include/boost/python/default_call_policies.hpp
+++ b/include/boost/python/default_call_policies.hpp
@@ -0,0 +1,84 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef DEFAULT_CALL_POLICIES_DWA2002131_HPP
+# define DEFAULT_CALL_POLICIES_DWA2002131_HPP
+
+# include <boost/python/detail/prefix.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/python/to_python_value.hpp>
+# include <boost/python/detail/value_arg.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/is_pointer.hpp>
+# include <boost/type_traits/is_reference.hpp>
+# include <boost/mpl/or.hpp>
+
+namespace boost { namespace python { 
+
+template <class T> struct to_python_value;
+
+namespace detail
+{
+// for "readable" error messages
+  template <class T> struct specify_a_return_value_policy_to_wrap_functions_returning
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
+  {}
+# endif 
+  ;
+}
+
+struct default_result_converter;
+
+struct default_call_policies
+{
+    // Ownership of this argument tuple will ultimately be adopted by
+    // the caller.
+    template <class ArgumentPackage>
+    static bool precall(ArgumentPackage const&)
+    {
+        return true;
+    }
+
+    // Pass the result through
+    template <class ArgumentPackage>
+    static PyObject* postcall(ArgumentPackage const&, PyObject* result)
+    {
+        return result;
+    }
+
+    typedef default_result_converter result_converter;
+    typedef PyObject* argument_package;
+};
+
+struct default_result_converter
+{
+    template <class R>
+    struct apply
+    {
+        typedef typename mpl::if_<
+            mpl::or_<is_pointer<R>, is_reference<R> >
+          , detail::specify_a_return_value_policy_to_wrap_functions_returning<R>
+          , boost::python::to_python_value<
+                typename detail::value_arg<R>::type
+            >
+        >::type type;
+    };
+};
+
+// Exceptions for c strings an PyObject*s
+template <>
+struct default_result_converter::apply<char const*>
+{
+    typedef boost::python::to_python_value<char const*const&> type;
+};
+
+template <>
+struct default_result_converter::apply<PyObject*>
+{
+    typedef boost::python::to_python_value<PyObject*const&> type;
+};
+
+}} // namespace boost::python
+
+#endif // DEFAULT_CALL_POLICIES_DWA2002131_HPP
--- a/include/boost/python/detail/aix_init_module.hpp
+++ b/include/boost/python/detail/aix_init_module.hpp
@@ -0,0 +1,26 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef AIX_INIT_MODULE_DWA2002529_HPP
+# define AIX_INIT_MODULE_DWA2002529_HPP
+# ifdef _AIX
+# include <boost/python/detail/prefix.hpp>
+# include <cstdio>
+# ifdef __KCC
+#  include <iostream> // this works around a problem in KCC 4.0f
+# endif 
+
+namespace boost { namespace python { namespace detail { 
+
+extern "C"
+{
+    typedef PyObject* (*so_load_function)(char*,char*,FILE*);
+}
+
+void aix_init_module(so_load_function, char const* name, void (*init_module)());
+
+}}} // namespace boost::python::detail
+# endif
+
+#endif // AIX_INIT_MODULE_DWA2002529_HPP
--- a/include/boost/python/detail/api_placeholder.hpp
+++ b/include/boost/python/detail/api_placeholder.hpp
@@ -0,0 +1,18 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_PYTHON_API_PLACE_HOLDER_HPP
+#define BOOST_PYTHON_API_PLACE_HOLDER_HPP
+
+namespace boost { namespace python {
+
+    inline long len(object const& obj)
+    {
+        long result = PyObject_Length(obj.ptr());
+        if (PyErr_Occurred()) throw_error_already_set();
+        return result;
+    }
+}} // namespace boost::python
+
+#endif // BOOST_PYTHON_API_PLACE_HOLDER_HPP
--- a/include/boost/python/detail/arg_tuple_size.hpp
+++ b/include/boost/python/detail/arg_tuple_size.hpp
@@ -1,233 +0,0 @@
-//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  This work was funded in part by Lawrence Berkeley National Labs
-//
-//  This file generated for 5-argument member functions and 6-argument free
-//  functions by gen_arg_tuple_size.python
-
-#ifndef ARG_TUPLE_SIZE_DWA20011201_HPP
-# define ARG_TUPLE_SIZE_DWA20011201_HPP
-
-namespace boost { namespace python { namespace detail {
-
-// Computes (at compile-time) the number of elements that a Python
-// argument tuple must have in order to be passed to a wrapped C++
-// (member) function of the given type.
-template <class F> struct arg_tuple_size;
-
-# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__BORLANDC__)
-
-template <class R>
-struct arg_tuple_size<R (*)()>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 0);
-};
-
-template <class R, class A1>
-struct arg_tuple_size<R (*)(A1)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 1);
-};
-
-template <class R, class A1, class A2>
-struct arg_tuple_size<R (*)(A1, A2)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 2);
-};
-
-template <class R, class A1, class A2, class A3>
-struct arg_tuple_size<R (*)(A1, A2, A3)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 3);
-};
-
-template <class R, class A1, class A2, class A3, class A4>
-struct arg_tuple_size<R (*)(A1, A2, A3, A4)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 4);
-};
-
-template <class R, class A1, class A2, class A3, class A4, class A5>
-struct arg_tuple_size<R (*)(A1, A2, A3, A4, A5)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 5);
-};
-
-template <class R, class A1, class A2, class A3, class A4, class A5, class A6>
-struct arg_tuple_size<R (*)(A1, A2, A3, A4, A5, A6)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 6);
-};
-
-
-template <class R, class A0>
-struct arg_tuple_size<R (A0::*)()>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 1);
-};
-
-template <class R, class A0, class A1>
-struct arg_tuple_size<R (A0::*)(A1)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 2);
-};
-
-template <class R, class A0, class A1, class A2>
-struct arg_tuple_size<R (A0::*)(A1, A2)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 3);
-};
-
-template <class R, class A0, class A1, class A2, class A3>
-struct arg_tuple_size<R (A0::*)(A1, A2, A3)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 4);
-};
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-struct arg_tuple_size<R (A0::*)(A1, A2, A3, A4)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 5);
-};
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-struct arg_tuple_size<R (A0::*)(A1, A2, A3, A4, A5)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 6);
-};
-
-# else
-
-// We will use the "sizeof() trick" to work around the lack of
-// partial specialization in MSVC6 and its broken-ness in borland.
-// See http://opensource.adobe.com  or
-// http://groups.yahoo.com/group/boost/message/5441 for
-// more examples
-
-// This little package is used to transmit the number of arguments
-// from the helper functions below to the sizeof() expression below.
-// Because we can never have an array of fewer than 1 element, we
-// add 1 to n and then subtract 1 from the result of sizeof() below.
-template <int n>
-struct char_array
-{
-    char elements[n+1];
-};
-
-// The following helper functions are never actually called, since
-// they are only used within a sizeof() expression, but the type of
-// their return value is used to discriminate between various free
-// and member function pointers at compile-time.
-
-template <class R>
-char_array<0> arg_tuple_size_helper(R (*)());
-
-template <class R, class A1>
-char_array<1> arg_tuple_size_helper(R (*)(A1));
-
-template <class R, class A1, class A2>
-char_array<2> arg_tuple_size_helper(R (*)(A1, A2));
-
-template <class R, class A1, class A2, class A3>
-char_array<3> arg_tuple_size_helper(R (*)(A1, A2, A3));
-
-template <class R, class A1, class A2, class A3, class A4>
-char_array<4> arg_tuple_size_helper(R (*)(A1, A2, A3, A4));
-
-template <class R, class A1, class A2, class A3, class A4, class A5>
-char_array<5> arg_tuple_size_helper(R (*)(A1, A2, A3, A4, A5));
-
-template <class R, class A1, class A2, class A3, class A4, class A5, class A6>
-char_array<6> arg_tuple_size_helper(R (*)(A1, A2, A3, A4, A5, A6));
-
-template <class R, class A0>
-char_array<1> arg_tuple_size_helper(R (A0::*)());
-
-template <class R, class A0, class A1>
-char_array<2> arg_tuple_size_helper(R (A0::*)(A1));
-
-template <class R, class A0, class A1, class A2>
-char_array<3> arg_tuple_size_helper(R (A0::*)(A1, A2));
-
-template <class R, class A0, class A1, class A2, class A3>
-char_array<4> arg_tuple_size_helper(R (A0::*)(A1, A2, A3));
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-char_array<5> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4));
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-char_array<6> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4, A5));
-
-
-template <class R, class A0>
-char_array<1> arg_tuple_size_helper(R (A0::*)() const);
-
-template <class R, class A0, class A1>
-char_array<2> arg_tuple_size_helper(R (A0::*)(A1) const);
-
-template <class R, class A0, class A1, class A2>
-char_array<3> arg_tuple_size_helper(R (A0::*)(A1, A2) const);
-
-template <class R, class A0, class A1, class A2, class A3>
-char_array<4> arg_tuple_size_helper(R (A0::*)(A1, A2, A3) const);
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-char_array<5> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4) const);
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-char_array<6> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4, A5) const);
-
-
-template <class R, class A0>
-char_array<1> arg_tuple_size_helper(R (A0::*)() volatile);
-
-template <class R, class A0, class A1>
-char_array<2> arg_tuple_size_helper(R (A0::*)(A1) volatile);
-
-template <class R, class A0, class A1, class A2>
-char_array<3> arg_tuple_size_helper(R (A0::*)(A1, A2) volatile);
-
-template <class R, class A0, class A1, class A2, class A3>
-char_array<4> arg_tuple_size_helper(R (A0::*)(A1, A2, A3) volatile);
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-char_array<5> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4) volatile);
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-char_array<6> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4, A5) volatile);
-
-
-template <class R, class A0>
-char_array<1> arg_tuple_size_helper(R (A0::*)() const volatile);
-
-template <class R, class A0, class A1>
-char_array<2> arg_tuple_size_helper(R (A0::*)(A1) const volatile);
-
-template <class R, class A0, class A1, class A2>
-char_array<3> arg_tuple_size_helper(R (A0::*)(A1, A2) const volatile);
-
-template <class R, class A0, class A1, class A2, class A3>
-char_array<4> arg_tuple_size_helper(R (A0::*)(A1, A2, A3) const volatile);
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-char_array<5> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4) const volatile);
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-char_array<6> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4, A5) const volatile);
-
-
-template <class F>
-struct arg_tuple_size
-{
-    // The sizeof() magic happens here
-    BOOST_STATIC_CONSTANT(std::size_t, value
-      = sizeof(arg_tuple_size_helper(F(0)).elements) - 1);
-};
-# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-}}} // namespace boost::python::detail
-
-#endif // ARG_TUPLE_SIZE_DWA20011201_HPP
-
--- a/include/boost/python/detail/borrowed_ptr.hpp
+++ b/include/boost/python/detail/borrowed_ptr.hpp
@@ -0,0 +1,111 @@
+#ifndef BORROWED_PTR_DWA20020601_HPP
+# define BORROWED_PTR_DWA20020601_HPP
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+# include <boost/config.hpp>
+# include <boost/type.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/type_traits/object_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/python/tag.hpp>
+
+namespace boost { namespace python { namespace detail {
+
+template<class T> class borrowed
+{ 
+    typedef T type;
+};
+
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template<typename T>
+struct is_borrowed_ptr
+{
+    BOOST_STATIC_CONSTANT(bool, value = false); 
+};
+
+#  if !defined(__MWERKS__) || __MWERKS__ > 0x3000
+template<typename T>
+struct is_borrowed_ptr<borrowed<T>*>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template<typename T>
+struct is_borrowed_ptr<borrowed<T> const*>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template<typename T>
+struct is_borrowed_ptr<borrowed<T> volatile*>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template<typename T>
+struct is_borrowed_ptr<borrowed<T> const volatile*>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+#  else
+template<typename T>
+struct is_borrowed
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+template<typename T>
+struct is_borrowed<borrowed<T> >
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+template<typename T>
+struct is_borrowed_ptr<T*>
+    : is_borrowed<typename remove_cv<T>::type>
+{
+};
+#  endif 
+
+# else // no partial specialization
+
+typedef char (&yes_borrowed_ptr_t)[1];
+typedef char (&no_borrowed_ptr_t)[2];
+
+no_borrowed_ptr_t is_borrowed_ptr_test(...);
+
+template <class T>
+typename mpl::if_c<
+    is_pointer<T>::value
+    , T
+    , int
+    >::type
+is_borrowed_ptr_test1(boost::type<T>);
+
+template<typename T>
+yes_borrowed_ptr_t is_borrowed_ptr_test(borrowed<T> const volatile*);
+
+template<typename T>
+class is_borrowed_ptr
+{
+ public:
+    BOOST_STATIC_CONSTANT(
+        bool, value = (
+            sizeof(detail::is_borrowed_ptr_test(is_borrowed_ptr_test1(boost::type<T>())))
+            == sizeof(detail::yes_borrowed_ptr_t)));
+};
+
+# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+}
+
+template <class T>
+inline T* get_managed_object(detail::borrowed<T> const volatile* p, tag_t)
+{
+    return (T*)p;
+}
+
+}} // namespace boost::python::detail
+
+#endif // #ifndef BORROWED_PTR_DWA20020601_HPP
--- a/include/boost/python/detail/caller.hpp
+++ b/include/boost/python/detail/caller.hpp
@@ -1,27 +1,220 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef CALLER_DWA20011214_HPP
-# define CALLER_DWA20011214_HPP
+#if !defined(BOOST_PP_IS_ITERATING)

-# include <boost/python/call.hpp>
-# include <boost/python/detail/wrap_python.hpp>
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+# ifndef CALLER_DWA20021121_HPP
+#  define CALLER_DWA20021121_HPP
+
+#  include <boost/python/type_id.hpp>
+#  include <boost/python/handle.hpp>
+
+#  include <boost/python/detail/invoke.hpp>
+#  include <boost/python/detail/signature.hpp>
+#  include <boost/python/detail/preprocessor.hpp>
+
+#  include <boost/python/arg_from_python.hpp>
+#  include <boost/python/converter/context_result_converter.hpp>
+
+#  include <boost/preprocessor/iterate.hpp>
+#  include <boost/preprocessor/cat.hpp>
+#  include <boost/preprocessor/dec.hpp>
+#  include <boost/preprocessor/if.hpp>
+#  include <boost/preprocessor/iteration/local.hpp>
+#  include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#  include <boost/preprocessor/repetition/repeat.hpp>
+
+#  include <boost/compressed_pair.hpp>
+
+#  include <boost/type_traits/is_same.hpp>
+#  include <boost/type_traits/is_convertible.hpp>
+
+#  include <boost/mpl/apply.hpp>
+#  include <boost/mpl/eval_if.hpp>
+#  include <boost/mpl/identity.hpp>
+#  include <boost/mpl/size.hpp>
+#  include <boost/mpl/at.hpp>
+#  include <boost/mpl/int.hpp>
+#  include <boost/mpl/next.hpp>

 namespace boost { namespace python { namespace detail { 

-struct caller
+template <int N>
+inline PyObject* get(mpl::int_<N>, PyObject* const& args_)
 {
+    return PyTuple_GET_ITEM(args_,N);
+}
+
+inline unsigned arity(PyObject* const& args_)
+{
+    return PyTuple_GET_SIZE(args_);
+}
+
+// This "result converter" is really just used as
+// a dispatch tag to invoke(...), selecting the appropriate
+// implementation
+typedef int void_result_to_python;
+
+// Given a model of CallPolicies and a C++ result type, this
+// metafunction selects the appropriate converter to use for
+// converting the result to python.
+template <class Policies, class Result>
+struct select_result_converter
+  : mpl::eval_if<
+        is_same<Result,void>
+      , mpl::identity<void_result_to_python>
+      , mpl::apply1<typename Policies::result_converter,Result>
+    >
+{
+};
+
+template <class ArgPackage, class ResultConverter>
+inline ResultConverter create_result_converter(
+    ArgPackage const& args_
+  , ResultConverter*
+  , converter::context_result_converter*
+)
+{
+    return ResultConverter(args_);
+}
+    
+template <class ArgPackage, class ResultConverter>
+inline ResultConverter create_result_converter(
+    ArgPackage const&
+  , ResultConverter*
+  , ...
+)
+{
+    return ResultConverter();
+}
+    
+template <unsigned> struct caller_arity;
+
+template <class F, class CallPolicies, class Sig>
+struct caller;
+
+#  define BOOST_PYTHON_NEXT(init,name,n)                                                        \
+    typedef BOOST_PP_IF(n,typename mpl::next< BOOST_PP_CAT(name,BOOST_PP_DEC(n)) >::type, init) name##n;
+
+#  define BOOST_PYTHON_ARG_CONVERTER(n)                                         \
+     BOOST_PYTHON_NEXT(typename mpl::next<first>::type, arg_iter,n)             \
+     typedef arg_from_python<BOOST_DEDUCED_TYPENAME arg_iter##n::type> c_t##n;  \
+     c_t##n c##n(get(mpl::int_<n>(), inner_args));                              \
+     if (!c##n.convertible())                                                   \
+          return 0;
+
+#  define BOOST_PP_ITERATION_PARAMS_1                                            \
+        (3, (0, BOOST_PYTHON_MAX_ARITY + 1, <boost/python/detail/caller.hpp>))
+#  include BOOST_PP_ITERATE()
+
+#  undef BOOST_PYTHON_ARG_CONVERTER
+#  undef BOOST_PYTHON_NEXT
+
+// A metafunction returning the base class used for caller<class F,
+// class ConverterGenerators, class CallPolicies, class Sig>.
+template <class F, class CallPolicies, class Sig>
+struct caller_base_select
+{
+    enum { arity = mpl::size<Sig>::value - 1 };
+    typedef typename caller_arity<arity>::template impl<F,CallPolicies,Sig> type;
+};
+
+// A function object type which wraps C++ objects as Python callable
+// objects.
+//
+// Template Arguments:
+//
+//   F -
+//      the C++ `function object' that will be called. Might
+//      actually be any data for which an appropriate invoke_tag() can
+//      be generated. invoke(...) takes care of the actual invocation syntax.
+//
+//   CallPolicies -
+//      The precall, postcall, and what kind of resultconverter to
+//      generate for mpl::front<Sig>::type
+//
+//   Sig -
+//      The `intended signature' of the function. An MPL sequence
+//      beginning with a result type and continuing with a list of
+//      argument types.
+template <class F, class CallPolicies, class Sig>
+struct caller
+    : caller_base_select<F,CallPolicies,Sig>::type
+{
+    typedef typename caller_base_select<
+        F,CallPolicies,Sig
+        >::type base;
+
    typedef PyObject* result_type;
    
-    template <class F>
-    PyObject* operator()(F f, PyObject* args, PyObject* keywords)
-    {
-        return call(f, args, keywords);
-    }
+    caller(F f, CallPolicies p) : base(f,p) {}
+
 };

 }}} // namespace boost::python::detail

-#endif // CALLER_DWA20011214_HPP
+# endif // CALLER_DWA20021121_HPP
+
+#else
+
+# define N BOOST_PP_ITERATION()
+
+template <>
+struct caller_arity<N>
+{
+    template <class F, class Policies, class Sig>
+    struct impl
+    {
+        impl(F f, Policies p) : m_data(f,p) {}
+
+        PyObject* operator()(PyObject* args_, PyObject*) // eliminate
+                                                         // this
+                                                         // trailing
+                                                         // keyword dict
+        {
+            typedef typename mpl::begin<Sig>::type first;
+            typedef typename first::type result_t;
+            typedef typename select_result_converter<Policies, result_t>::type result_converter;
+            typedef typename Policies::argument_package argument_package;
+            
+            argument_package inner_args(args_);
+
+# if N
+#  define BOOST_PP_LOCAL_MACRO(i) BOOST_PYTHON_ARG_CONVERTER(i)
+#  define BOOST_PP_LOCAL_LIMITS (0, N-1)
+#  include BOOST_PP_LOCAL_ITERATE()
+# endif 
+            // all converters have been checked. Now we can do the
+            // precall part of the policy
+            if (!m_data.second().precall(inner_args))
+                return 0;
+
+            PyObject* result = detail::invoke(
+                detail::invoke_tag<result_t,F>()
+              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
+              , m_data.first()
+                BOOST_PP_ENUM_TRAILING_PARAMS(N, c)
+            );
+            
+            return m_data.second().postcall(inner_args, result);
+        }
+
+        static unsigned min_arity() { return N; }
+        
+        static signature_element const* signature()
+        {
+            return detail::signature<Sig>::elements();
+        }
+        
+     private:
+        compressed_pair<F,Policies> m_data;
+    };
+};
+
+
+
+#endif // BOOST_PP_IS_ITERATING 
+
+
--- a/include/boost/python/detail/config.hpp
+++ b/include/boost/python/detail/config.hpp
@@ -0,0 +1,117 @@
+//  (C) Copyright David Abrahams 2000.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
+//  producing this work.
+
+//  Revision History:
+//  04 Mar 01  Some fixes so it will compile with Intel C++ (Dave Abrahams)
+
+#ifndef CONFIG_DWA052200_H_
+# define CONFIG_DWA052200_H_
+
+# include <boost/config.hpp>
+# include <boost/detail/workaround.hpp>
+
+# ifdef BOOST_NO_OPERATORS_IN_NAMESPACE
+   // A gcc bug forces some symbols into the global namespace
+#  define BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
+#  define BOOST_PYTHON_END_CONVERSION_NAMESPACE
+#  define BOOST_PYTHON_CONVERSION
+#  define BOOST_PYTHON_IMPORT_CONVERSION(x) using ::x
+# else
+#  define BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE namespace boost { namespace python {
+#  define BOOST_PYTHON_END_CONVERSION_NAMESPACE }} // namespace boost::python
+#  define BOOST_PYTHON_CONVERSION boost::python
+#  define BOOST_PYTHON_IMPORT_CONVERSION(x) void never_defined() // so we can follow the macro with a ';'
+# endif
+
+# if defined(BOOST_MSVC)
+#  if _MSC_VER < 1300
+#   define BOOST_MSVC6_OR_EARLIER 1
+#  endif
+
+#  pragma warning (disable : 4786) // disable truncated debug symbols
+#  pragma warning (disable : 4251) // disable exported dll function
+#  pragma warning (disable : 4800) //'int' : forcing value to bool 'true' or 'false'
+#  pragma warning (disable : 4275) // non dll-interface class
+
+# elif defined(__ICL) && __ICL < 600 // Intel C++ 5
+
+#  pragma warning(disable: 985) // identifier was truncated in debug information
+
+# endif
+
+// The STLport puts all of the standard 'C' library names in std (as far as the
+// user is concerned), but without it you need a fix if you're using MSVC or
+// Intel C++
+# if defined(BOOST_NO_STDC_NAMESPACE)
+#  define BOOST_CSTD_
+# else
+#  define BOOST_CSTD_ std
+# endif
+
+/*****************************************************************************
+ *
+ *  Set up dll import/export options:
+ *
+ ****************************************************************************/
+
+// backwards compatibility:
+#ifdef BOOST_PYTHON_STATIC_LIB
+#  define BOOST_PYTHON_STATIC_LINK
+# elif !defined(BOOST_PYTHON_DYNAMIC_LIB)
+#  define BOOST_PYTHON_DYNAMIC_LIB
+#endif
+
+#if defined(BOOST_PYTHON_DYNAMIC_LIB)
+
+#  if !defined(_WIN32) && !defined(__CYGWIN__)                  \
+    && defined(__GNUC__) && __GNUC__ >= 3 && __GNUC_MINOR__ >=5 \
+    && !defined(BOOST_PYTHON_GCC_SYMBOL_VISIBILITY)
+#    define BOOST_PYTHON_USE_GCC_SYMBOL_VISIBILITY
+#  endif 
+
+#  if defined(BOOST_PYTHON_USE_GCC_SYMBOL_VISIBILITY)
+#     if defined(BOOST_PYTHON_SOURCE)
+#        define BOOST_PYTHON_DECL __attribute__ ((visibility("default")))
+#        define BOOST_PYTHON_BUILD_DLL
+#     else
+#        define BOOST_PYTHON_DECL
+#     endif
+#     define BOOST_PYTHON_DECL_FORWARD
+#     define BOOST_PYTHON_DECL_EXCEPTION __attribute__ ((visibility("default")))
+#  elif (defined(_WIN32) || defined(__CYGWIN__))
+#     if defined(BOOST_PYTHON_SOURCE)
+#        define BOOST_PYTHON_DECL __declspec(dllexport)
+#        define BOOST_PYTHON_BUILD_DLL
+#     else
+#        define BOOST_PYTHON_DECL __declspec(dllimport)
+#     endif
+#  endif
+
+#endif
+
+#ifndef BOOST_PYTHON_DECL
+#  define BOOST_PYTHON_DECL
+#endif
+
+#ifndef BOOST_PYTHON_DECL_FORWARD
+#  define BOOST_PYTHON_DECL_FORWARD BOOST_PYTHON_DECL
+#endif
+
+#ifndef BOOST_PYTHON_DECL_EXCEPTION
+#  define BOOST_PYTHON_DECL_EXCEPTION BOOST_PYTHON_DECL
+#endif
+
+#if BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
+// Replace broken Tru64/cxx offsetof macro
+# define BOOST_PYTHON_OFFSETOF(s_name, s_member) \
+        ((size_t)__INTADDR__(&(((s_name *)0)->s_member)))
+#else
+# define BOOST_PYTHON_OFFSETOF offsetof
+#endif
+
+#endif // CONFIG_DWA052200_H_
--- a/include/boost/python/detail/construct.hpp
+++ b/include/boost/python/detail/construct.hpp
@@ -0,0 +1,42 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef CONSTRUCT_REFERENCE_DWA2002716_HPP
+# define CONSTRUCT_REFERENCE_DWA2002716_HPP
+
+namespace boost { namespace python { namespace detail { 
+
+template <class T, class Arg>
+void construct_pointee(void* storage, Arg& x
+# if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
+                       , T const volatile*
+# else 
+                       , T const*
+# endif 
+    )
+{
+    new (storage) T(x);
+}
+
+template <class T, class Arg>
+void construct_referent_impl(void* storage, Arg& x, T&(*)())
+{
+    construct_pointee(storage, x, (T*)0);
+}
+
+template <class T, class Arg>
+void construct_referent(void* storage, Arg const& x, T(*tag)() = 0)
+{
+    construct_referent_impl(storage, x, tag);
+}
+
+template <class T, class Arg>
+void construct_referent(void* storage, Arg& x, T(*tag)() = 0)
+{
+    construct_referent_impl(storage, x, tag);
+}
+
+}}} // namespace boost::python::detail
+
+#endif // CONSTRUCT_REFERENCE_DWA2002716_HPP
--- a/include/boost/python/detail/convertible.hpp
+++ b/include/boost/python/detail/convertible.hpp
@@ -0,0 +1,38 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef CONVERTIBLE_DWA2002614_HPP
+# define CONVERTIBLE_DWA2002614_HPP
+
+# if defined(__EDG_VERSION__) && __EDG_VERSION__ <= 241
+#  include <boost/mpl/if.hpp>
+#  include <boost/type_traits/conversion_traits.hpp>
+# endif 
+
+// Supplies a runtime is_convertible check which can be used with tag
+// dispatching to work around the Metrowerks Pro7 limitation with boost::is_convertible
+namespace boost { namespace python { namespace detail { 
+
+typedef char* yes_convertible;
+typedef int* no_convertible;
+
+template <class Target>
+struct convertible
+{
+# if !defined(__EDG_VERSION__) || __EDG_VERSION__ > 241 || __EDG_VERSION__ == 238
+    static inline no_convertible check(...) { return 0; }
+    static inline yes_convertible check(Target) { return 0; }
+# else
+    template <class X>
+    static inline typename mpl::if_c<
+        is_convertible<X,Target>::value
+        , yes_convertible
+        , no_convertible
+        >::type check(X const&) { return 0; }
+# endif 
+};
+
+}}} // namespace boost::python::detail
+
+#endif // CONVERTIBLE_DWA2002614_HPP
--- a/include/boost/python/detail/copy_ctor_mutates_rhs.hpp
+++ b/include/boost/python/detail/copy_ctor_mutates_rhs.hpp
@@ -0,0 +1,21 @@
+// Copyright David Abrahams 2003.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef COPY_CTOR_MUTATES_RHS_DWA2003219_HPP
+# define COPY_CTOR_MUTATES_RHS_DWA2003219_HPP
+
+#include <boost/python/detail/is_auto_ptr.hpp>
+#include <boost/mpl/bool.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+template <class T>
+struct copy_ctor_mutates_rhs
+    : is_auto_ptr<T>
+{
+};
+
+}}} // namespace boost::python::detail
+
+#endif // COPY_CTOR_MUTATES_RHS_DWA2003219_HPP
--- a/include/boost/python/detail/cv_category.hpp
+++ b/include/boost/python/detail/cv_category.hpp
@@ -0,0 +1,36 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef CV_CATEGORY_DWA200222_HPP
+# define CV_CATEGORY_DWA200222_HPP
+# include <boost/type_traits/cv_traits.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+template <bool is_const_, bool is_volatile_>
+struct cv_tag
+{
+    BOOST_STATIC_CONSTANT(bool, is_const = is_const_);
+    BOOST_STATIC_CONSTANT(bool, is_volatile = is_const_);
+};
+
+typedef cv_tag<false,false> cv_unqualified;
+typedef cv_tag<true,false> const_;
+typedef cv_tag<false,true> volatile_;
+typedef cv_tag<true,true> const_volatile_;
+
+template <class T>
+struct cv_category
+{
+//    BOOST_STATIC_CONSTANT(bool, c = is_const<T>::value);
+//    BOOST_STATIC_CONSTANT(bool, v = is_volatile<T>::value);
+    typedef cv_tag<
+        ::boost::is_const<T>::value
+      , ::boost::is_volatile<T>::value
+    > type;
+};
+
+}}} // namespace boost::python::detail
+
+#endif // CV_CATEGORY_DWA200222_HPP
--- a/include/boost/python/detail/dealloc.hpp
+++ b/include/boost/python/detail/dealloc.hpp
@@ -0,0 +1,17 @@
+// Copyright Gottfried Ganßauge 2003.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+# ifndef BOOST_PYTHON_DETAIL_DEALLOC_HPP_
+# define BOOST_PYTHON_DETAIL_DEALLOC_HPP_
+namespace boost { namespace python { namespace detail {
+    extern "C"
+    {
+        inline void dealloc(PyObject* self)
+        {
+          PyObject_Del(self);
+        }
+    }
+}}} // namespace boost::python::detail
+# endif    // BOOST_PYTHON_DETAIL_DEALLOC_HPP_
--- a/include/boost/python/detail/decorated_type_id.hpp
+++ b/include/boost/python/detail/decorated_type_id.hpp
@@ -0,0 +1,76 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef DECORATED_TYPE_ID_DWA2002517_HPP
+# define DECORATED_TYPE_ID_DWA2002517_HPP
+
+# include <boost/python/type_id.hpp>
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+struct decorated_type_info : totally_ordered<decorated_type_info>
+{
+    enum decoration { const_ = 0x1, volatile_ = 0x2, reference = 0x4 };
+    
+    decorated_type_info(type_info, decoration = decoration());
+
+    inline bool operator<(decorated_type_info const& rhs) const;
+    inline bool operator==(decorated_type_info const& rhs) const;
+
+    friend BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, decorated_type_info const&);
+
+    operator type_info const&() const;
+ private: // type
+    typedef type_info base_id_t;
+    
+ private: // data members
+    decoration m_decoration;
+    base_id_t m_base_type;
+};
+
+template <class T>
+inline decorated_type_info decorated_type_id(boost::type<T>* = 0)
+{
+    return decorated_type_info(
+        type_id<T>()
+        , decorated_type_info::decoration(
+            (is_const<T>::value || indirect_traits::is_reference_to_const<T>::value
+             ? decorated_type_info::const_ : 0)
+            | (is_volatile<T>::value || indirect_traits::is_reference_to_volatile<T>::value
+               ? decorated_type_info::volatile_ : 0)
+            | (is_reference<T>::value ? decorated_type_info::reference : 0)
+            )
+        );
+}
+
+inline decorated_type_info::decorated_type_info(type_info base_t, decoration decoration)
+    : m_decoration(decoration)
+    , m_base_type(base_t)
+{
+}
+
+inline bool decorated_type_info::operator<(decorated_type_info const& rhs) const
+{
+    return m_decoration < rhs.m_decoration
+        || m_decoration == rhs.m_decoration
+           && m_base_type < rhs.m_base_type;
+}
+
+inline bool decorated_type_info::operator==(decorated_type_info const& rhs) const
+{
+    return m_decoration == rhs.m_decoration && m_base_type == rhs.m_base_type;
+}
+
+inline decorated_type_info::operator type_info const&() const
+{
+    return m_base_type;
+}
+
+BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, decorated_type_info const&);
+
+}}} // namespace boost::python::detail
+
+#endif // DECORATED_TYPE_ID_DWA2002517_HPP
--- a/include/boost/python/detail/decref_guard.hpp
+++ b/include/boost/python/detail/decref_guard.hpp
@@ -0,0 +1,21 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef DECREF_GUARD_DWA20021220_HPP
+# define DECREF_GUARD_DWA20021220_HPP
+
+namespace boost { namespace python { namespace detail { 
+
+struct decref_guard
+{
+    decref_guard(PyObject* o) : obj(o) {}
+    ~decref_guard() { Py_XDECREF(obj); }
+    void cancel() { obj = 0; }
+ private:
+    PyObject* obj;
+};
+
+}}} // namespace boost::python::detail
+
+#endif // DECREF_GUARD_DWA20021220_HPP
--- a/include/boost/python/detail/def_helper.hpp
+++ b/include/boost/python/detail/def_helper.hpp
@@ -0,0 +1,212 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef DEF_HELPER_DWA200287_HPP
+# define DEF_HELPER_DWA200287_HPP
+
+# include <boost/python/args.hpp>
+# include <boost/type_traits/ice.hpp>
+# include <boost/type_traits/same_traits.hpp>
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/mpl/not.hpp>
+# include <boost/mpl/and.hpp>
+# include <boost/mpl/or.hpp>
+# include <boost/type_traits/add_reference.hpp>
+# include <boost/mpl/lambda.hpp>
+# include <boost/mpl/apply.hpp>
+# include <boost/tuple/tuple.hpp>
+# include <boost/python/detail/not_specified.hpp>
+# include <boost/python/detail/def_helper_fwd.hpp>
+
+namespace boost { namespace python {
+
+struct default_call_policies;
+
+namespace detail
+{
+  // tuple_extract<Tuple,Predicate>::extract(t) returns the first
+  // element of a Tuple whose type E satisfies the given Predicate
+  // applied to add_reference<E>. The Predicate must be an MPL
+  // metafunction class.
+  template <class Tuple, class Predicate>
+  struct tuple_extract;
+
+  // Implementation class for when the tuple's head type does not
+  // satisfy the Predicate
+  template <bool matched>
+  struct tuple_extract_impl
+  {
+      template <class Tuple, class Predicate>
+      struct apply
+      {
+          typedef typename Tuple::head_type result_type;
+          
+          static typename Tuple::head_type extract(Tuple const& x)
+          {
+              return x.get_head();
+          }
+      };
+  };
+
+  // Implementation specialization for when the tuple's head type
+  // satisfies the predicate
+  template <>
+  struct tuple_extract_impl<false>
+  {
+      template <class Tuple, class Predicate>
+      struct apply
+      {
+          // recursive application of tuple_extract on the tail of the tuple
+          typedef tuple_extract<typename Tuple::tail_type, Predicate> next;
+          typedef typename next::result_type result_type;
+          
+          static result_type extract(Tuple const& x)
+          {
+              return next::extract(x.get_tail());
+          }
+      };
+  };
+
+  // A metafunction which selects a version of tuple_extract_impl to
+  // use for the implementation of tuple_extract
+  template <class Tuple, class Predicate>
+  struct tuple_extract_base_select
+  {
+      typedef typename Tuple::head_type head_type;
+      typedef typename mpl::apply1<Predicate, typename add_reference<head_type>::type>::type match_t;
+      BOOST_STATIC_CONSTANT(bool, match = match_t::value);
+      typedef typename tuple_extract_impl<match>::template apply<Tuple,Predicate> type;
+  };
+  
+  template <class Tuple, class Predicate>
+  struct tuple_extract
+      : tuple_extract_base_select<
+         Tuple
+         , typename mpl::lambda<Predicate>::type
+      >::type
+  {
+  };
+
+
+  //
+  // Specialized extractors for the docstring, keywords, CallPolicies,
+  // and default implementation of virtual functions
+  //
+
+  template <class Tuple>
+  struct doc_extract
+      : tuple_extract<
+        Tuple
+        , mpl::not_<
+           mpl::or_<
+               indirect_traits::is_reference_to_class<mpl::_1>
+             , indirect_traits::is_reference_to_member_function_pointer<mpl::_1 >
+           >
+        >
+     >
+  {
+  };
+  
+  template <class Tuple>
+  struct keyword_extract
+      : tuple_extract<Tuple, is_reference_to_keywords<mpl::_1 > >
+  {
+  };
+
+  template <class Tuple>
+  struct policy_extract
+      : tuple_extract<
+          Tuple
+          , mpl::and_<
+             mpl::not_<is_same<not_specified const&,mpl::_1> >
+              , indirect_traits::is_reference_to_class<mpl::_1 >
+              , mpl::not_<is_reference_to_keywords<mpl::_1 > >
+          >
+        >
+  {
+  };
+
+  template <class Tuple>
+  struct default_implementation_extract
+      : tuple_extract<
+          Tuple
+          , indirect_traits::is_reference_to_member_function_pointer<mpl::_1 >
+          >
+  {
+  };
+
+  //
+  // A helper class for decoding the optional arguments to def()
+  // invocations, which can be supplied in any order and are
+  // discriminated by their type properties. The template parameters
+  // are expected to be the types of the actual (optional) arguments
+  // passed to def().
+  //
+  template <class T1, class T2, class T3, class T4>
+  struct def_helper
+  {
+      // A tuple type which begins with references to the supplied
+      // arguments and ends with actual representatives of the default
+      // types.
+      typedef boost::tuples::tuple<
+          T1 const&
+          , T2 const&
+          , T3 const&
+          , T4 const&
+          , default_call_policies
+          , keywords<0>
+          , char const*
+          , void(not_specified::*)()   // A function pointer type which is never an
+                                       // appropriate default implementation
+          > all_t;
+
+      // Constructors; these initialize an member of the tuple type
+      // shown above.
+      def_helper(T1 const& a1) : m_all(a1,m_nil,m_nil,m_nil) {}
+      def_helper(T1 const& a1, T2 const& a2) : m_all(a1,a2,m_nil,m_nil) {}
+      def_helper(T1 const& a1, T2 const& a2, T3 const& a3) : m_all(a1,a2,a3,m_nil) {}
+      def_helper(T1 const& a1, T2 const& a2, T3 const& a3, T4 const& a4) : m_all(a1,a2,a3,a4) {}
+
+   private: // types
+      typedef typename default_implementation_extract<all_t>::result_type default_implementation_t;
+      
+   public: // Constants which can be used for static assertions.
+
+      // Users must not supply a default implementation for non-class
+      // methods.
+      BOOST_STATIC_CONSTANT(
+          bool, has_default_implementation = (
+              !is_same<default_implementation_t, void(not_specified::*)()>::value));
+      
+   public: // Extractor functions which pull the appropriate value out
+           // of the tuple
+      char const* doc() const
+      {
+          return doc_extract<all_t>::extract(m_all);
+      }
+      
+      typename keyword_extract<all_t>::result_type keywords() const
+      {
+          return keyword_extract<all_t>::extract(m_all);
+      }
+      
+      typename policy_extract<all_t>::result_type policies() const
+      {
+          return policy_extract<all_t>::extract(m_all);
+      }
+
+      default_implementation_t default_implementation() const
+      {
+          return default_implementation_extract<all_t>::extract(m_all);
+      }
+      
+   private: // data members
+      all_t m_all; 
+      not_specified m_nil; // for filling in not_specified slots
+  };
+}
+
+}} // namespace boost::python::detail
+
+#endif // DEF_HELPER_DWA200287_HPP
--- a/include/boost/python/detail/def_helper_fwd.hpp
+++ b/include/boost/python/detail/def_helper_fwd.hpp
@@ -0,0 +1,17 @@
+// Copyright David Abrahams 2003.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef DEF_HELPER_FWD_DWA2003810_HPP
+# define DEF_HELPER_FWD_DWA2003810_HPP
+
+# include <boost/python/detail/not_specified.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+template <class T1, class T2 = not_specified, class T3 = not_specified, class T4 = not_specified>
+struct def_helper;
+
+}}} // namespace boost::python::detail
+
+#endif // DEF_HELPER_FWD_DWA2003810_HPP
--- a/include/boost/python/detail/defaults_def.hpp
+++ b/include/boost/python/detail/defaults_def.hpp
@@ -0,0 +1,291 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright David Abrahams 2002, Joel de Guzman, 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+///////////////////////////////////////////////////////////////////////////////
+#if !defined(BOOST_PP_IS_ITERATING)
+
+#ifndef DEFAULTS_DEF_JDG20020811_HPP
+#define DEFAULTS_DEF_JDG20020811_HPP
+
+#include <boost/python/detail/defaults_gen.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/python/class_fwd.hpp>
+#include <boost/python/scope.hpp>
+#include <boost/preprocessor/debug/line.hpp>
+#include <boost/python/detail/scope.hpp>
+#include <boost/python/detail/make_keyword_range_fn.hpp>
+#include <boost/python/object/add_to_namespace.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace python {
+
+struct module;
+
+namespace objects
+{
+  struct class_base;
+}
+
+namespace detail
+{
+  // Called as::
+  //
+  //    name_space_def(ns, "func", func, kw, policies, docstring, &ns)
+  //
+  // Dispatch to properly add f to namespace ns.
+  //
+  // @group define_stub_function helpers { 
+  template <class Func, class CallPolicies, class NameSpaceT>
+  static void name_space_def(
+      NameSpaceT& name_space
+      , char const* name
+      , Func f
+      , keyword_range const& kw
+      , CallPolicies const& policies
+      , char const* doc
+      , objects::class_base*
+      )
+  {
+      typedef typename NameSpaceT::wrapped_type wrapped_type;
+      
+      objects::add_to_namespace(
+          name_space, name,
+          detail::make_keyword_range_function(
+              f, policies, kw, get_signature(f, (wrapped_type*)0))
+        , doc
+      );
+  }
+
+  template <class Func, class CallPolicies>
+  static void name_space_def(
+      object& name_space
+      , char const* name
+      , Func f
+      , keyword_range const& kw
+      , CallPolicies const& policies
+      , char const* doc
+      , ...
+      )
+  {
+      scope within(name_space);
+
+      detail::scope_setattr_doc(
+          name
+          , detail::make_keyword_range_function(f, policies, kw)
+          , doc);
+  }
+
+  // For backward compatibility -- is this obsolete?
+  template <class Func, class CallPolicies, class NameSpaceT>
+  static void name_space_def(
+      NameSpaceT& name_space
+      , char const* name
+      , Func f
+      , keyword_range const& kw // ignored
+      , CallPolicies const& policies
+      , char const* doc
+      , module*
+      )
+  {
+      name_space.def(name, f, policies, doc);
+  }
+  // }
+
+
+  //  Expansions of ::
+  //
+  //      template <typename OverloadsT, typename NameSpaceT>
+  //      inline void
+  //      define_stub_function(
+  //          char const* name, OverloadsT s, NameSpaceT& name_space, mpl::int_<N>)
+  //      {
+  //          name_space.def(name, &OverloadsT::func_N);
+  //      }
+  //
+  //  where N runs from 0 to BOOST_PYTHON_MAX_ARITY.
+  //
+  //  The set of overloaded functions (define_stub_function) expects:
+  //
+  //      1. char const* name:        function name that will be visible to python
+  //      2. OverloadsT:              a function overloads struct (see defaults_gen.hpp)
+  //      3. NameSpaceT& name_space:  a python::class_ or python::module instance
+  //      4. int_t<N>:                the Nth overloaded function (OverloadsT::func_N)
+  //                                  (see defaults_gen.hpp)
+  //      5. char const* name:        doc string
+  //
+  // @group define_stub_function<N> {
+  template <int N>
+  struct define_stub_function {};
+
+#define BOOST_PP_ITERATION_PARAMS_1                                             \
+    (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/defaults_def.hpp>))
+
+#include BOOST_PP_ITERATE()
+  
+  // }
+  
+  //  This helper template struct does the actual recursive
+  //  definition.  There's a generic version
+  //  define_with_defaults_helper<N> and a terminal case
+  //  define_with_defaults_helper<0>. The struct and its
+  //  specialization has a sole static member function def that
+  //  expects:
+  //
+  //    1. char const* name:        function name that will be
+  //                                visible to python
+  //
+  //    2. OverloadsT:              a function overloads struct
+  //                                (see defaults_gen.hpp)
+  //
+  //    3. NameSpaceT& name_space:  a python::class_ or
+  //                                python::module instance
+  //
+  //    4. char const* name:        doc string
+  //
+  //  The def static member function calls a corresponding
+  //  define_stub_function<N>. The general case recursively calls
+  //  define_with_defaults_helper<N-1>::def until it reaches the
+  //  terminal case case define_with_defaults_helper<0>.
+  template <int N>
+  struct define_with_defaults_helper {
+
+      template <class StubsT, class CallPolicies, class NameSpaceT>
+      static void
+      def(
+          char const* name,
+          StubsT stubs,
+          keyword_range kw,
+          CallPolicies const& policies,
+          NameSpaceT& name_space,
+          char const* doc)
+      {
+          //  define the NTH stub function of stubs
+          define_stub_function<N>::define(name, stubs, kw, policies, name_space, 0);
+
+          if (kw.second > kw.first)
+              --kw.second;
+
+          //  call the next define_with_defaults_helper
+          define_with_defaults_helper<N-1>::def(name, stubs, kw, policies, name_space, doc);
+      }
+  };
+
+  template <>
+  struct define_with_defaults_helper<0> {
+
+      template <class StubsT, class CallPolicies, class NameSpaceT>
+      static void
+      def(
+          char const* name,
+          StubsT stubs,
+          keyword_range const& kw,
+          CallPolicies const& policies,
+          NameSpaceT& name_space,
+          char const* doc)
+      {
+          //  define the Oth stub function of stubs
+          define_stub_function<0>::define(name, stubs, kw, policies, name_space, doc);
+          //  return
+      }
+  };
+
+  //  define_with_defaults
+  //
+  //      1. char const* name:        function name that will be
+  //                                  visible to python
+  //
+  //      2. OverloadsT:              a function overloads struct
+  //                                  (see defaults_gen.hpp)
+  //
+  //      3. CallPolicies& policies:  Call policies
+  //      4. NameSpaceT& name_space:  a python::class_ or
+  //                                  python::module instance
+  //
+  //      5. SigT sig:                Function signature typelist
+  //                                  (see defaults_gen.hpp)
+  //
+  //      6. char const* name:        doc string
+  //
+  //  This is the main entry point. This function recursively
+  //  defines all stub functions of StubT (see defaults_gen.hpp) in
+  //  NameSpaceT name_space which can be either a python::class_ or
+  //  a python::module. The sig argument is a typelist that
+  //  specifies the return type, the class (for member functions,
+  //  and the arguments. Here are some SigT examples:
+  //
+  //      int foo(int)        mpl::vector<int, int>
+  //      void bar(int, int)  mpl::vector<void, int, int>
+  //      void C::foo(int)    mpl::vector<void, C, int>
+  //
+  template <class OverloadsT, class NameSpaceT, class SigT>
+  inline void
+  define_with_defaults(
+      char const* name,
+      OverloadsT const& overloads,
+      NameSpaceT& name_space,
+      SigT const&)
+  {
+      typedef typename mpl::front<SigT>::type return_type;
+      typedef typename OverloadsT::void_return_type void_return_type;
+      typedef typename OverloadsT::non_void_return_type non_void_return_type;
+
+      typedef typename mpl::if_c<
+          boost::is_same<void, return_type>::value
+          , void_return_type
+          , non_void_return_type
+      >::type stubs_type;
+
+      BOOST_STATIC_ASSERT(
+          (stubs_type::max_args) <= mpl::size<SigT>::value);
+
+      typedef typename stubs_type::template gen<SigT> gen_type;
+      define_with_defaults_helper<stubs_type::n_funcs-1>::def(
+          name
+          , gen_type()
+          , overloads.keywords()
+          , overloads.call_policies()
+          , name_space
+          , overloads.doc_string());
+  }
+
+} // namespace detail
+
+}} // namespace boost::python
+
+#endif // DEFAULTS_DEF_JDG20020811_HPP
+
+#else // defined(BOOST_PP_IS_ITERATING)
+// PP vertical iteration code
+
+
+template <>
+struct define_stub_function<BOOST_PP_ITERATION()> {
+    template <class StubsT, class CallPolicies, class NameSpaceT>
+    static void define(
+        char const* name
+        , StubsT const&
+        , keyword_range const& kw
+        , CallPolicies const& policies
+        , NameSpaceT& name_space
+        , char const* doc)
+    {
+        detail::name_space_def(
+            name_space
+            , name
+            , &StubsT::BOOST_PP_CAT(func_, BOOST_PP_ITERATION())
+            , kw
+            , policies
+            , doc
+            , &name_space);
+    }
+};
+
+#endif // !defined(BOOST_PP_IS_ITERATING)
--- a/include/boost/python/detail/defaults_gen.hpp
+++ b/include/boost/python/detail/defaults_gen.hpp
@@ -0,0 +1,388 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright David Abrahams 2002, Joel de Guzman, 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+///////////////////////////////////////////////////////////////////////////////
+#ifndef DEFAULTS_GEN_JDG20020807_HPP
+#define DEFAULTS_GEN_JDG20020807_HPP
+
+#include <boost/python/detail/preprocessor.hpp>
+#include <boost/preprocessor/repeat.hpp>
+#include <boost/preprocessor/repeat_from_to.hpp>
+#include <boost/preprocessor/enum.hpp>
+#include <boost/preprocessor/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/tuple.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/arithmetic/sub.hpp>
+#include <boost/preprocessor/stringize.hpp>
+#include <boost/preprocessor/inc.hpp>
+#include <boost/preprocessor/empty.hpp>
+#include <boost/preprocessor/comma_if.hpp>
+#include <boost/config.hpp>
+#include <boost/mpl/begin_end.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/mpl/deref.hpp>
+#include <cstddef>
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  // overloads_base is used as a base class for all function
+  // stubs. This class holds the doc_string of the stubs.
+  struct overloads_base
+  {
+      overloads_base(char const* doc_)
+          : m_doc(doc_) {}
+
+      overloads_base(char const* doc_, detail::keyword_range const& kw)
+          : m_doc(doc_), m_keywords(kw) {}
+
+      char const* doc_string() const
+      {
+          return m_doc;
+      }
+
+      detail::keyword_range const& keywords() const
+      {
+          return m_keywords;
+      }
+
+   private:
+      char const* m_doc;
+      detail::keyword_range m_keywords;
+  };
+
+  // overloads_proxy is generated by the overloads_common operator[] (see
+  // below). This class holds a user defined call policies of the stubs.
+  template <class CallPoliciesT, class OverloadsT>
+  struct overloads_proxy
+      : public overloads_base
+  {
+      typedef typename OverloadsT::non_void_return_type   non_void_return_type;
+      typedef typename OverloadsT::void_return_type       void_return_type;
+
+      overloads_proxy(
+          CallPoliciesT const& policies_
+          , char const* doc
+          , keyword_range const& kw
+          )
+          : overloads_base(doc, kw)
+            , policies(policies_)
+      {}
+
+      CallPoliciesT
+      call_policies() const
+      {
+          return policies;
+      }
+
+      CallPoliciesT policies;
+  };
+
+  // overloads_common is our default function stubs base class. This
+  // class returns the default_call_policies in its call_policies()
+  // member function.  It can generate a overloads_proxy however through
+  // its operator[]
+  template <class DerivedT>
+  struct overloads_common
+      : public overloads_base
+  {
+      overloads_common(char const* doc)
+          : overloads_base(doc) {}
+
+      overloads_common(char const* doc, keyword_range const& kw)
+          : overloads_base(doc, kw) {}
+
+      default_call_policies
+      call_policies() const
+      {
+          return default_call_policies();
+      }
+
+      template <class CallPoliciesT>
+      overloads_proxy<CallPoliciesT, DerivedT>
+      operator[](CallPoliciesT const& policies) const
+      {
+          return overloads_proxy<CallPoliciesT, DerivedT>(
+              policies, this->doc_string(), this->keywords());
+      }
+  };
+
+}}} // namespace boost::python::detail
+
+
+#define BOOST_PYTHON_TYPEDEF_GEN(z, index, data)                                \
+    typedef typename ::boost::mpl::next<BOOST_PP_CAT(iter, index)>::type        \
+        BOOST_PP_CAT(iter, BOOST_PP_INC(index));                                \
+    typedef typename ::boost::mpl::deref<BOOST_PP_CAT(iter, index)>::type       \
+        BOOST_PP_CAT(T, index);
+
+#define BOOST_PYTHON_FUNC_WRAPPER_GEN(z, index, data)                   \
+    static RT BOOST_PP_CAT(func_,                                       \
+        BOOST_PP_SUB_D(1, index, BOOST_PP_TUPLE_ELEM(3, 1, data))) (    \
+        BOOST_PP_ENUM_BINARY_PARAMS_Z(                                  \
+            1, index, T, arg))                                          \
+    {                                                                   \
+        BOOST_PP_TUPLE_ELEM(3, 2, data)                                 \
+        BOOST_PP_TUPLE_ELEM(3, 0, data)(                                \
+            BOOST_PP_ENUM_PARAMS(                                       \
+                index,                                                  \
+                arg));                                                  \
+    }
+
+#define BOOST_PYTHON_GEN_FUNCTION(fname, fstubs_name, n_args, n_dflts, ret)     \
+    struct fstubs_name                                                          \
+    {                                                                           \
+        BOOST_STATIC_CONSTANT(int, n_funcs = BOOST_PP_INC(n_dflts));            \
+        BOOST_STATIC_CONSTANT(int, max_args = n_funcs);                         \
+                                                                                \
+        template <typename SigT>                                                \
+        struct gen                                                              \
+        {                                                                       \
+            typedef typename ::boost::mpl::begin<SigT>::type rt_iter;           \
+            typedef typename ::boost::mpl::deref<rt_iter>::type RT;             \
+            typedef typename ::boost::mpl::next<rt_iter>::type iter0;           \
+                                                                                \
+            BOOST_PP_REPEAT_2ND(                                                \
+                n_args,                                                         \
+                BOOST_PYTHON_TYPEDEF_GEN,                                       \
+                0)                                                              \
+                                                                                \
+            BOOST_PP_REPEAT_FROM_TO_2(                                          \
+                BOOST_PP_SUB_D(1, n_args, n_dflts),                             \
+                BOOST_PP_INC(n_args),                                           \
+                BOOST_PYTHON_FUNC_WRAPPER_GEN,                                  \
+                (fname, BOOST_PP_SUB_D(1, n_args, n_dflts), ret))               \
+        };                                                                      \
+    };                                                                          \
+
+///////////////////////////////////////////////////////////////////////////////
+#define BOOST_PYTHON_MEM_FUNC_WRAPPER_GEN(z, index, data)                       \
+    static RT BOOST_PP_CAT(func_,                                               \
+        BOOST_PP_SUB_D(1, index, BOOST_PP_TUPLE_ELEM(3, 1, data))) (            \
+            ClassT obj BOOST_PP_COMMA_IF(index)                                 \
+            BOOST_PP_ENUM_BINARY_PARAMS_Z(1, index, T, arg)                     \
+        )                                                                       \
+    {                                                                           \
+        BOOST_PP_TUPLE_ELEM(3, 2, data) obj.BOOST_PP_TUPLE_ELEM(3, 0, data)(    \
+            BOOST_PP_ENUM_PARAMS(index, arg)                                    \
+        );                                                                      \
+    }
+
+#define BOOST_PYTHON_GEN_MEM_FUNCTION(fname, fstubs_name, n_args, n_dflts, ret) \
+    struct fstubs_name                                                          \
+    {                                                                           \
+        BOOST_STATIC_CONSTANT(int, n_funcs = BOOST_PP_INC(n_dflts));            \
+        BOOST_STATIC_CONSTANT(int, max_args = n_funcs + 1);                     \
+                                                                                \
+        template <typename SigT>                                                \
+        struct gen                                                              \
+        {                                                                       \
+            typedef typename ::boost::mpl::begin<SigT>::type rt_iter;           \
+            typedef typename ::boost::mpl::deref<rt_iter>::type RT;             \
+                                                                                \
+            typedef typename ::boost::mpl::next<rt_iter>::type class_iter;      \
+            typedef typename ::boost::mpl::deref<class_iter>::type ClassT;      \
+            typedef typename ::boost::mpl::next<class_iter>::type iter0;        \
+                                                                                \
+            BOOST_PP_REPEAT_2ND(                                                \
+                n_args,                                                         \
+                BOOST_PYTHON_TYPEDEF_GEN,                                       \
+                0)                                                              \
+                                                                                \
+            BOOST_PP_REPEAT_FROM_TO_2(                                          \
+                BOOST_PP_SUB_D(1, n_args, n_dflts),                             \
+                BOOST_PP_INC(n_args),                                           \
+                BOOST_PYTHON_MEM_FUNC_WRAPPER_GEN,                              \
+                (fname, BOOST_PP_SUB_D(1, n_args, n_dflts), ret))               \
+        };                                                                      \
+    };
+
+#define BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts)                    \
+    fstubs_name(char const* doc = 0)                                                        \
+        : ::boost::python::detail::overloads_common<fstubs_name>(doc) {}                    \
+    template <std::size_t N>                                                                \
+    fstubs_name(char const* doc, ::boost::python::detail::keywords<N> const& keywords)      \
+        : ::boost::python::detail::overloads_common<fstubs_name>(                           \
+            doc, keywords.range())                                                          \
+    {                                                                                       \
+        typedef typename ::boost::python::detail::                                          \
+            error::more_keywords_than_function_arguments<                                   \
+                N,n_args>::too_many_keywords assertion;                                     \
+    }                                                                                       \
+    template <std::size_t N>                                                                \
+    fstubs_name(::boost::python::detail::keywords<N> const& keywords, char const* doc = 0)  \
+        : ::boost::python::detail::overloads_common<fstubs_name>(                           \
+            doc, keywords.range())                                                          \
+    {                                                                                       \
+        typedef typename ::boost::python::detail::                                          \
+            error::more_keywords_than_function_arguments<                                   \
+                N,n_args>::too_many_keywords assertion;                                     \
+    }
+
+# if defined(BOOST_NO_VOID_RETURNS)
+
+#  define BOOST_PYTHON_GEN_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts)   \
+    struct fstubs_name                                                          \
+        : public ::boost::python::detail::overloads_common<fstubs_name>         \
+    {                                                                           \
+        BOOST_PYTHON_GEN_FUNCTION(                                              \
+            fname, non_void_return_type, n_args, n_dflts, return)               \
+        BOOST_PYTHON_GEN_FUNCTION(                                              \
+            fname, void_return_type, n_args, n_dflts, ;)                        \
+                                                                                \
+        BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts)        \
+    };
+
+#  define BOOST_PYTHON_GEN_MEM_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts)       \
+    struct fstubs_name                                                                  \
+        : public ::boost::python::detail::overloads_common<fstubs_name>                 \
+    {                                                                                   \
+        BOOST_PYTHON_GEN_MEM_FUNCTION(                                                  \
+            fname, non_void_return_type, n_args, n_dflts, return)                       \
+        BOOST_PYTHON_GEN_MEM_FUNCTION(                                                  \
+            fname, void_return_type, n_args, n_dflts, ;)                                \
+                                                                                        \
+        BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts)                \
+    };
+
+# else // !defined(BOOST_NO_VOID_RETURNS)
+
+#  define BOOST_PYTHON_GEN_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts)   \
+    struct fstubs_name                                                          \
+        : public ::boost::python::detail::overloads_common<fstubs_name>         \
+    {                                                                           \
+        BOOST_PYTHON_GEN_FUNCTION(                                              \
+            fname, non_void_return_type, n_args, n_dflts, return)               \
+                                                                                \
+        typedef non_void_return_type void_return_type;                          \
+        BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts)        \
+    };
+
+
+#  define BOOST_PYTHON_GEN_MEM_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts)       \
+    struct fstubs_name                                                                  \
+        : public ::boost::python::detail::overloads_common<fstubs_name>                 \
+    {                                                                                   \
+        BOOST_PYTHON_GEN_MEM_FUNCTION(                                                  \
+            fname, non_void_return_type, n_args, n_dflts, return)                       \
+                                                                                        \
+        typedef non_void_return_type void_return_type;                                  \
+        BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts)                \
+    };
+
+# endif // !defined(BOOST_NO_VOID_RETURNS)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  MAIN MACROS
+//
+//      Given generator_name, fname, min_args and max_args, These macros
+//      generate function stubs that forward to a function or member function
+//      named fname. max_args is the arity of the function or member function
+//      fname. fname can have default arguments. min_args is the minimum
+//      arity that fname can accept.
+//
+//      There are two versions:
+//
+//          1. BOOST_PYTHON_FUNCTION_OVERLOADS for free functions
+//          2. BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS for member functions.
+//
+//      For instance, given a function:
+//
+//      int
+//      foo(int a, char b = 1, unsigned c = 2, double d = 3)
+//      {
+//          return a + b + c + int(d);
+//      }
+//
+//      The macro invocation:
+//
+//          BOOST_PYTHON_FUNCTION_OVERLOADS(foo_stubs, foo, 1, 4)
+//
+//      Generates this code:
+//
+//      struct foo_stubsNonVoid
+//      {
+//          static const int n_funcs = 4;
+//          static const int max_args = n_funcs;
+//
+//          template <typename SigT>
+//          struct gen
+//          {
+//              typedef typename ::boost::mpl::begin<SigT>::type    rt_iter;
+//              typedef typename rt_iter::type                      RT;
+//              typedef typename rt_iter::next                      iter0;
+//              typedef typename iter0::type                        T0;
+//              typedef typename iter0::next                        iter1;
+//              typedef typename iter1::type                        T1;
+//              typedef typename iter1::next                        iter2;
+//              typedef typename iter2::type                        T2;
+//              typedef typename iter2::next                        iter3;
+//              typedef typename iter3::type                        T3;
+//              typedef typename iter3::next                        iter4;
+//
+//              static RT func_0(T0 arg0)
+//              { return foo(arg0); }
+//
+//              static RT func_1(T0 arg0, T1 arg1)
+//              { return foo(arg0, arg1); }
+//
+//              static RT func_2(T0 arg0, T1 arg1, T2 arg2)
+//              { return foo(arg0, arg1, arg2); }
+//
+//              static RT func_3(T0 arg0, T1 arg1, T2 arg2, T3 arg3)
+//              { return foo(arg0, arg1, arg2, arg3); }
+//          };
+//      };
+//
+//      struct foo_overloads
+//          : public boost::python::detail::overloads_common<foo_overloads>
+//      {
+//          typedef foo_overloadsNonVoid    non_void_return_type;
+//          typedef foo_overloadsNonVoid    void_return_type;
+//
+//          foo_overloads(char const* doc = 0)
+//             : boost::python::detail::overloads_common<foo_overloads>(doc) {}
+//      };
+//
+//      The typedefs non_void_return_type and void_return_type are
+//      used to handle compilers that do not support void returns. The
+//      example above typedefs non_void_return_type and
+//      void_return_type to foo_overloadsNonVoid. On compilers that do
+//      not support void returns, there are two versions:
+//      foo_overloadsNonVoid and foo_overloadsVoid.  The "Void"
+//      version is almost identical to the "NonVoid" version except
+//      for the return type (void) and the lack of the return keyword.
+//
+//      See the overloads_common above for a description of the
+//      foo_overloads' base class.
+//
+///////////////////////////////////////////////////////////////////////////////
+#define BOOST_PYTHON_FUNCTION_OVERLOADS(generator_name, fname, min_args, max_args)          \
+    BOOST_PYTHON_GEN_FUNCTION_STUB(                                                         \
+        fname,                                                                              \
+        generator_name,                                                                     \
+        max_args,                                                                           \
+        BOOST_PP_SUB_D(1, max_args, min_args))
+
+#define BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(generator_name, fname, min_args, max_args)   \
+    BOOST_PYTHON_GEN_MEM_FUNCTION_STUB(                                                     \
+        fname,                                                                              \
+        generator_name,                                                                     \
+        max_args,                                                                           \
+        BOOST_PP_SUB_D(1, max_args, min_args))
+
+// deprecated macro names (to be removed)
+#define BOOST_PYTHON_FUNCTION_GENERATOR BOOST_PYTHON_FUNCTION_OVERLOADS
+#define BOOST_PYTHON_MEM_FUN_GENERATOR BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS
+
+///////////////////////////////////////////////////////////////////////////////
+#endif // DEFAULTS_GEN_JDG20020807_HPP
+
+
--- a/include/boost/python/detail/dependent.hpp
+++ b/include/boost/python/detail/dependent.hpp
@@ -0,0 +1,27 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef DEPENDENT_DWA200286_HPP
+# define DEPENDENT_DWA200286_HPP
+
+namespace boost { namespace python { namespace detail { 
+
+// A way to turn a concrete type T into a type dependent on U. This
+// keeps conforming compilers (those implementing proper 2-phase
+// name lookup for templates) from complaining about incomplete
+// types in situations where it would otherwise be inconvenient or
+// impossible to re-order code so that all types are defined in time.
+
+// One such use is when we must return an incomplete T from a member
+// function template (which must be defined in the class body to
+// keep MSVC happy).
+template <class T, class U>
+struct dependent
+{
+    typedef T type;
+};
+
+}}} // namespace boost::python::detail
+
+#endif // DEPENDENT_DWA200286_HPP
--- a/include/boost/python/detail/destroy.hpp
+++ b/include/boost/python/detail/destroy.hpp
@@ -0,0 +1,106 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef DESTROY_DWA2002221_HPP
+# define DESTROY_DWA2002221_HPP
+
+# include <boost/type_traits/is_array.hpp>
+# include <boost/detail/workaround.hpp>
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+#  include <boost/type_traits/is_enum.hpp>
+# endif 
+namespace boost { namespace python { namespace detail { 
+
+template <
+    bool array
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+  , bool enum_  // vc7 has a problem destroying enums
+# endif 
+    > struct value_destroyer;
+    
+template <>
+struct value_destroyer<
+    false
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+  , false
+# endif 
+    >
+{
+    template <class T>
+    static void execute(T const volatile* p)
+    {
+        p->T::~T();
+    }
+};
+
+template <>
+struct value_destroyer<
+    true
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+  , false
+# endif 
+    >
+{
+    template <class A, class T>
+    static void execute(A*, T const volatile* const first)
+    {
+        for (T const volatile* p = first; p != first + sizeof(A)/sizeof(T); ++p)
+        {
+            value_destroyer<
+                boost::is_array<T>::value
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+              , boost::is_enum<T>::value
+# endif 
+            >::execute(p);
+        }
+    }
+    
+    template <class T>
+    static void execute(T const volatile* p)
+    {
+        execute(p, *p);
+    }
+};
+
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+template <>
+struct value_destroyer<true,true>
+{
+    template <class T>
+    static void execute(T const volatile*)
+    {
+    }
+};
+
+template <>
+struct value_destroyer<false,true>
+{
+    template <class T>
+    static void execute(T const volatile*)
+    {
+    }
+};
+# endif 
+template <class T>
+inline void destroy_referent_impl(void* p, T& (*)())
+{
+    // note: cv-qualification needed for MSVC6
+    // must come *before* T for metrowerks
+    value_destroyer<
+         (boost::is_array<T>::value)
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+       , (boost::is_enum<T>::value)
+# endif 
+    >::execute((const volatile T*)p);
+}
+
+template <class T>
+inline void destroy_referent(void* p, T(*)() = 0)
+{
+    destroy_referent_impl(p, (T(*)())0);
+}
+
+}}} // namespace boost::python::detail
+
+#endif // DESTROY_DWA2002221_HPP
--- a/include/boost/python/detail/enable_if.hpp
+++ b/include/boost/python/detail/enable_if.hpp
@@ -0,0 +1,72 @@
+// Copyright David Abrahams 2004. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef ENABLE_IF_DWA2004722_HPP
+# define ENABLE_IF_DWA2004722_HPP
+
+# include <boost/python/detail/sfinae.hpp>
+# include <boost/detail/workaround.hpp>
+
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+#  include <boost/mpl/if.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+template <class T> struct always_void { typedef void type; };
+
+template <class C, class T = int>
+struct enable_if_arg
+{
+    typedef typename mpl::if_<C,T,int&>::type type;
+};
+             
+template <class C, class T = int>
+struct disable_if_arg
+{
+    typedef typename mpl::if_<C,int&,T>::type type;
+};
+             
+template <class C, class T = typename always_void<C>::type>
+struct enable_if_ret
+{
+    typedef typename mpl::if_<C,T,int[2]>::type type;
+};
+             
+template <class C, class T = typename always_void<C>::type>
+struct disable_if_ret
+{
+    typedef typename mpl::if_<C,int[2],T>::type type;
+};
+             
+}}} // namespace boost::python::detail
+
+# elif !defined(BOOST_NO_SFINAE)
+#  include <boost/utility/enable_if.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+template <class C, class T = int>
+struct enable_if_arg
+  : enable_if<C,T>
+{};
+             
+template <class C, class T = int>
+struct disable_if_arg
+  : disable_if<C,T>
+{};
+             
+template <class C, class T = void>
+struct enable_if_ret
+  : enable_if<C,T>
+{};
+             
+template <class C, class T = void>
+struct disable_if_ret
+  : disable_if<C,T>
+{};
+             
+}}} // namespace boost::python::detail
+
+# endif
+
+#endif // ENABLE_IF_DWA2004722_HPP
--- a/include/boost/python/detail/exception_handler.hpp
+++ b/include/boost/python/detail/exception_handler.hpp
@@ -0,0 +1,48 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef EXCEPTION_HANDLER_DWA2002810_HPP
+# define EXCEPTION_HANDLER_DWA2002810_HPP
+
+# include <boost/python/detail/config.hpp>
+# include <boost/function/function0.hpp>
+# include <boost/function/function2.hpp>
+
+namespace boost { namespace python { namespace detail {
+
+struct BOOST_PYTHON_DECL exception_handler;
+
+typedef function2<bool, exception_handler const&, function0<void> const&> handler_function;
+
+struct BOOST_PYTHON_DECL exception_handler
+{
+ private: // types
+    
+ public:
+    explicit exception_handler(handler_function const& impl);
+
+    inline bool handle(function0<void> const& f) const;
+    
+    bool operator()(function0<void> const& f) const;
+ 
+    static exception_handler* chain;
+    
+ private:
+    static exception_handler* tail;
+    
+    handler_function m_impl;
+    exception_handler* m_next;
+};
+
+
+inline bool exception_handler::handle(function0<void> const& f) const
+{
+    return this->m_impl(*this, f);
+}
+
+BOOST_PYTHON_DECL void register_exception_handler(handler_function const& f);
+
+}}} // namespace boost::python::detail
+
+#endif // EXCEPTION_HANDLER_DWA2002810_HPP
--- a/include/boost/python/detail/force_instantiate.hpp
+++ b/include/boost/python/detail/force_instantiate.hpp
@@ -0,0 +1,32 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef FORCE_INSTANTIATE_DWA200265_HPP
+# define FORCE_INSTANTIATE_DWA200265_HPP
+
+namespace boost { namespace python { namespace detail { 
+
+// Allows us to force the argument to be instantiated without
+// incurring unused variable warnings
+
+# if !defined(BOOST_MSVC) || BOOST_MSVC < 1300 || _MSC_FULL_VER > 13102196
+
+template <class T>
+inline void force_instantiate(T const&) {}
+
+# else
+
+#  pragma optimize("g", off)
+inline void force_instantiate_impl(...) {}
+#  pragma optimize("", on)
+template <class T>
+inline void force_instantiate(T const& x)
+{
+    detail::force_instantiate_impl(&x);
+}
+# endif
+
+}}} // namespace boost::python::detail
+
+#endif // FORCE_INSTANTIATE_DWA200265_HPP
--- a/include/boost/python/detail/if_else.hpp
+++ b/include/boost/python/detail/if_else.hpp
@@ -0,0 +1,116 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef IF_ELSE_DWA2002322_HPP
+# define IF_ELSE_DWA2002322_HPP
+# include <boost/config.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+template <class T> struct elif_selected;
+
+template <class T>
+struct if_selected
+{
+    template <bool b>
+    struct elif : elif_selected<T>
+    {
+    };
+
+    template <class U>
+    struct else_
+    {
+        typedef T type;
+    };
+};
+
+# if defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
+namespace msvc70_aux {
+
+template< bool > struct inherit_from
+{
+    template< typename T > struct result
+    {
+        typedef T type;
+    };
+};
+
+template<> struct inherit_from<true>
+{
+    template< typename T > struct result
+    {
+        struct type {};
+    };
+};
+
+template< typename T >
+struct never_true
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+} // namespace msvc70_aux
+
+#endif // # if defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
+
+template <class T>
+struct elif_selected
+{
+# if !(defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__MWERKS__) && __MWERKS__ <= 0x2407)
+    template <class U> class then;
+# elif defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
+    template <class U>
+    struct then : msvc70_aux::inherit_from< msvc70_aux::never_true<U>::value >
+        ::template result< if_selected<T> >::type
+    {
+    };
+# else
+    template <class U>
+    struct then : if_selected<T>
+    {
+    };
+# endif 
+};
+
+# if !(defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__MWERKS__) && __MWERKS__ <= 0x2407)
+template <class T>
+template <class U>
+class elif_selected<T>::then : public if_selected<T>
+{
+};
+# endif 
+
+template <bool b> struct if_
+{
+    template <class T>
+    struct then : if_selected<T>
+    {
+    };
+};
+
+struct if_unselected
+{
+    template <bool b> struct elif : if_<b>
+    {
+    };
+
+    template <class U>
+    struct else_
+    {
+        typedef U type;
+    };
+};
+
+template <>
+struct if_<false>
+{
+    template <class T>
+    struct then : if_unselected
+    {
+    };
+};
+
+}}} // namespace boost::python::detail
+
+#endif // IF_ELSE_DWA2002322_HPP
--- a/include/boost/python/detail/indirect_traits.hpp
+++ b/include/boost/python/detail/indirect_traits.hpp
@@ -0,0 +1,13 @@
+// Copyright David Abrahams 2004. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef INDIRECT_TRAITS_DWA2004915_HPP
+# define INDIRECT_TRAITS_DWA2004915_HPP
+
+# include <boost/detail/indirect_traits.hpp>
+
+namespace boost { namespace python {
+namespace indirect_traits = boost::detail::indirect_traits;
+}} // namespace boost::python::detail
+
+#endif // INDIRECT_TRAITS_DWA2004915_HPP
--- a/include/boost/python/detail/invoke.hpp
+++ b/include/boost/python/detail/invoke.hpp
@@ -0,0 +1,100 @@
+#if !defined(BOOST_PP_IS_ITERATING)
+
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+# ifndef INVOKE_DWA20021122_HPP
+#  define INVOKE_DWA20021122_HPP
+
+#  include <boost/python/detail/prefix.hpp>
+#  include <boost/python/detail/preprocessor.hpp>
+#  include <boost/python/detail/none.hpp>
+
+#  include <boost/type_traits/is_member_function_pointer.hpp>
+
+#  include <boost/preprocessor/iterate.hpp>
+#  include <boost/preprocessor/facilities/intercept.hpp>
+#  include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#  include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
+#  include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#  include <boost/python/to_python_value.hpp>
+
+// This file declares a series of overloaded invoke(...)  functions,
+// used to invoke wrapped C++ function (object)s from Python. Each one
+// accepts:
+//
+//   - a tag which identifies the invocation syntax (e.g. member
+//   functions must be invoked with a different syntax from regular
+//   functions)
+//
+//   - a pointer to a result converter type, used solely as a way of
+//   transmitting the type of the result converter to the function (or
+//   an int, if the return type is void).
+//
+//   - the "function", which may be a function object, a function or
+//   member function pointer, or a defaulted_virtual_fn.
+//
+//   - The arg_from_python converters for each of the arguments to be
+//   passed to the function being invoked.
+
+namespace boost { namespace python { namespace detail { 
+
+// This "result converter" is really just used as a dispatch tag to
+// invoke(...), selecting the appropriate implementation
+typedef int void_result_to_python;
+
+template <bool void_return, bool member>
+struct invoke_tag_ {};
+
+// A metafunction returning the appropriate tag type for invoking an
+// object of type F with return type R.
+template <class R, class F>
+struct invoke_tag
+  : invoke_tag_<
+        is_same<R,void>::value
+      , is_member_function_pointer<F>::value
+    >
+{
+};
+
+#  define BOOST_PP_ITERATION_PARAMS_1                                            \
+        (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/invoke.hpp>))
+#  include BOOST_PP_ITERATE()
+
+}}} // namespace boost::python::detail
+
+# endif // INVOKE_DWA20021122_HPP
+#else 
+
+# define N BOOST_PP_ITERATION()
+
+template <class RC, class F BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class AC)>
+inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(1, N, AC, & ac) )
+{
+    return rc(f( BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, ac, () BOOST_PP_INTERCEPT) ));
+}
+                 
+template <class RC, class F BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class AC)>
+inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(1, N, AC, & ac) )
+{
+    f( BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, ac, () BOOST_PP_INTERCEPT) );
+    return none();
+}
+
+template <class RC, class F, class TC BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class AC)>
+inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(1, N, AC, & ac) )
+{
+    return rc( (tc().*f)(BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, ac, () BOOST_PP_INTERCEPT)) );
+}
+                 
+template <class RC, class F, class TC BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class AC)>
+inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(1, N, AC, & ac) )
+{
+    (tc().*f)(BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, ac, () BOOST_PP_INTERCEPT));
+    return none();
+}
+
+# undef N
+
+#endif // BOOST_PP_IS_ITERATING 
--- a/include/boost/python/detail/is_auto_ptr.hpp
+++ b/include/boost/python/detail/is_auto_ptr.hpp
@@ -0,0 +1,30 @@
+// Copyright David Abrahams 2003.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef IS_AUTO_PTR_DWA2003224_HPP
+# define IS_AUTO_PTR_DWA2003224_HPP
+
+# ifndef BOOST_NO_AUTO_PTR
+#  include <boost/python/detail/is_xxx.hpp>
+#  include <memory>
+# endif
+
+namespace boost { namespace python { namespace detail { 
+
+# if !defined(BOOST_NO_AUTO_PTR)
+
+BOOST_PYTHON_IS_XXX_DEF(auto_ptr, std::auto_ptr, 1)
+
+# else
+
+template <class T>
+struct is_auto_ptr : mpl::false_
+{
+};
+
+# endif
+    
+}}} // namespace boost::python::detail
+
+#endif // IS_AUTO_PTR_DWA2003224_HPP
--- a/include/boost/python/detail/is_shared_ptr.hpp
+++ b/include/boost/python/detail/is_shared_ptr.hpp
@@ -0,0 +1,17 @@
+// Copyright David Abrahams 2003.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef IS_SHARED_PTR_DWA2003224_HPP
+# define IS_SHARED_PTR_DWA2003224_HPP
+
+# include <boost/python/detail/is_xxx.hpp>
+# include <boost/shared_ptr.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+BOOST_PYTHON_IS_XXX_DEF(shared_ptr, shared_ptr, 1)
+    
+}}} // namespace boost::python::detail
+
+#endif // IS_SHARED_PTR_DWA2003224_HPP
--- a/include/boost/python/detail/is_wrapper.hpp
+++ b/include/boost/python/detail/is_wrapper.hpp
@@ -0,0 +1,29 @@
+// Copyright David Abrahams 2004. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef IS_WRAPPER_DWA2004723_HPP
+# define IS_WRAPPER_DWA2004723_HPP
+
+# include <boost/python/detail/prefix.hpp>
+# include <boost/mpl/bool.hpp>
+
+namespace boost { namespace python {
+
+template <class T> class wrapper;
+
+namespace detail
+{
+  typedef char (&is_not_wrapper)[2];
+  is_not_wrapper is_wrapper_helper(...);
+  template <class T>
+  char is_wrapper_helper(wrapper<T> const volatile*);
+
+  // A metafunction returning true iff T is [derived from] wrapper<U> 
+  template <class T>
+  struct is_wrapper
+    : mpl::bool_<(sizeof(detail::is_wrapper_helper((T*)0)) == 1)>
+  {};
+
+}}} // namespace boost::python::detail
+
+#endif // IS_WRAPPER_DWA2004723_HPP
--- a/include/boost/python/detail/is_xxx.hpp
+++ b/include/boost/python/detail/is_xxx.hpp
@@ -0,0 +1,62 @@
+// Copyright David Abrahams 2003.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef IS_XXX_DWA2003224_HPP
+# define IS_XXX_DWA2003224_HPP
+
+# include <boost/config.hpp>
+# include <boost/mpl/bool.hpp>
+# include <boost/preprocessor/enum_params.hpp>
+
+# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+# include <boost/type_traits/is_reference.hpp>
+# include <boost/type_traits/add_reference.hpp>
+
+#  define BOOST_PYTHON_IS_XXX_DEF(name, qualified_name, nargs)          \
+template <class X_>                                                     \
+struct is_##name                                                        \
+{                                                                       \
+    typedef char yes;                                                   \
+    typedef char (&no)[2];                                              \
+                                                                        \
+    static typename add_reference<X_>::type dummy;                      \
+                                                                        \
+    struct helpers                                                      \
+    {                                                                   \
+        template < BOOST_PP_ENUM_PARAMS_Z(1, nargs, class U) >          \
+        static yes test(                                                \
+           qualified_name< BOOST_PP_ENUM_PARAMS_Z(1, nargs, U) >&, int  \
+        );                                                              \
+                                                                        \
+        template <class U>                                              \
+        static no test(U&, ...);                                        \
+    };                                                                  \
+                                                                        \
+    BOOST_STATIC_CONSTANT(                                              \
+        bool, value                                                     \
+        = !is_reference<X_>::value                                      \
+        & (sizeof(helpers::test(dummy, 0)) == sizeof(yes)));            \
+                                                                        \
+    typedef mpl::bool_<value> type;                                     \
+};
+
+# else
+
+#  define BOOST_PYTHON_IS_XXX_DEF(name, qualified_name, nargs)  \
+template <class T>                                              \
+struct is_##name : mpl::false_                                  \
+{                                                               \
+};                                                              \
+                                                                \
+template < BOOST_PP_ENUM_PARAMS_Z(1, nargs, class T) >          \
+struct is_##name<                                               \
+   qualified_name< BOOST_PP_ENUM_PARAMS_Z(1, nargs, T) >        \
+>                                                               \
+   : mpl::true_                                                 \
+{                                                               \
+};
+
+# endif
+
+#endif // IS_XXX_DWA2003224_HPP
--- a/include/boost/python/detail/make_keyword_range_fn.hpp
+++ b/include/boost/python/detail/make_keyword_range_fn.hpp
@@ -0,0 +1,69 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef MAKE_KEYWORD_RANGE_FN_DWA2002927_HPP
+# define MAKE_KEYWORD_RANGE_FN_DWA2002927_HPP
+
+# include <boost/python/make_function.hpp>
+# include <boost/python/args_fwd.hpp>
+
+# include <boost/python/object/make_holder.hpp>
+
+# include <boost/mpl/size.hpp>
+
+
+namespace boost { namespace python { namespace detail { 
+
+// Think of this as a version of make_function without a compile-time
+// check that the size of kw is no greater than the expected arity of
+// F. This version is needed when defining functions with default
+// arguments, because compile-time information about the number of
+// keywords is missing for all but the initial function definition.
+//
+// @group make_keyword_range_function {
+template <class F, class Policies>
+object make_keyword_range_function(
+    F f
+  , Policies const& policies
+  , keyword_range const& kw)
+{
+    return detail::make_function_aux(
+        f, policies, detail::get_signature(f), kw, mpl::int_<0>());
+}
+
+template <class F, class Policies, class Signature>
+object make_keyword_range_function(
+    F f
+  , Policies const& policies
+  , keyword_range const& kw
+  , Signature const& sig)
+{
+    return detail::make_function_aux(
+        f, policies, sig, kw, mpl::int_<0>());
+}
+// }
+
+// Builds an '__init__' function which inserts the given Holder type
+// in a wrapped C++ class instance. ArgList is an MPL type sequence
+// describing the C++ argument types to be passed to Holder's
+// constructor.
+//
+// Holder and ArgList are intended to be explicitly specified. 
+template <class ArgList, class Arity, class Holder, class CallPolicies>
+object make_keyword_range_constructor(
+    CallPolicies const& policies        // The CallPolicies with which to invoke the Holder's constructor
+    , detail::keyword_range const& kw   // The (possibly empty) set of associated argument keywords
+    , Holder* = 0                       
+    , ArgList* = 0, Arity* = 0)
+{
+    return detail::make_keyword_range_function(
+        objects::make_holder<Arity::value>
+            ::template apply<Holder,ArgList>::execute
+        , policies
+        , kw);
+}
+
+}}} // namespace boost::python::detail
+
+#endif // MAKE_KEYWORD_RANGE_FN_DWA2002927_HPP
--- a/include/boost/python/detail/make_tuple.hpp
+++ b/include/boost/python/detail/make_tuple.hpp
@@ -0,0 +1,32 @@
+# ifndef BOOST_PYTHON_SYNOPSIS 
+# // Copyright David Abrahams 2002.
+# // Distributed under the Boost Software License, Version 1.0. (See
+# // accompanying file LICENSE_1_0.txt or copy at
+# // http://www.boost.org/LICENSE_1_0.txt)
+
+#  if !defined(BOOST_PP_IS_ITERATING)
+#   error Boost.Python - do not include this file!
+#  endif
+
+#  define N BOOST_PP_ITERATION()
+
+#  define BOOST_PYTHON_MAKE_TUPLE_ARG(z, N, ignored)    \
+    PyTuple_SET_ITEM(                                   \
+        result.ptr()                                    \
+        , N                                             \
+        , python::incref(python::object(a##N).ptr())    \
+        );
+
+    template <BOOST_PP_ENUM_PARAMS_Z(1, N, class A)>
+    tuple
+    make_tuple(BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, A, const& a))
+    {
+        tuple result((detail::new_reference)::PyTuple_New(N));
+        BOOST_PP_REPEAT_1ST(N, BOOST_PYTHON_MAKE_TUPLE_ARG, _)
+        return result;
+    }
+
+#  undef BOOST_PYTHON_MAKE_TUPLE_ARG
+
+#  undef N
+# endif // BOOST_PYTHON_SYNOPSIS 
--- a/include/boost/python/detail/map_entry.hpp
+++ b/include/boost/python/detail/map_entry.hpp
@@ -0,0 +1,43 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef MAP_ENTRY_DWA2002118_HPP
+# define MAP_ENTRY_DWA2002118_HPP
+
+namespace boost { namespace python { namespace detail { 
+
+// A trivial type that works well as the value_type of associative
+// vector maps
+template <class Key, class Value>
+struct map_entry
+{
+    map_entry() {}
+    map_entry(Key k) : key(k), value() {}
+    map_entry(Key k, Value v) : key(k), value(v) {}
+    
+    bool operator<(map_entry const& rhs) const
+    {
+        return this->key < rhs.key;
+    }
+        
+    Key key;
+    Value value;
+};
+
+template <class Key, class Value>
+bool operator<(map_entry<Key,Value> const& e, Key const& k)
+{
+    return e.key < k;
+}
+
+template <class Key, class Value>
+bool operator<(Key const& k, map_entry<Key,Value> const& e)
+{
+    return k < e.key;
+}
+
+
+}}} // namespace boost::python::detail
+
+#endif // MAP_ENTRY_DWA2002118_HPP
--- a/include/boost/python/detail/mpl_lambda.hpp
+++ b/include/boost/python/detail/mpl_lambda.hpp
@@ -0,0 +1,12 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef MPL_LAMBDA_DWA2002122_HPP
+# define MPL_LAMBDA_DWA2002122_HPP
+
+// this header should go away soon
+# include <boost/mpl/aux_/lambda_support.hpp>
+# define BOOST_PYTHON_MPL_LAMBDA_SUPPORT BOOST_MPL_AUX_LAMBDA_SUPPORT
+
+#endif // MPL_LAMBDA_DWA2002122_HPP
--- a/include/boost/python/detail/msvc_typeinfo.hpp
+++ b/include/boost/python/detail/msvc_typeinfo.hpp
@@ -0,0 +1,75 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef MSVC_TYPEINFO_DWA200222_HPP
+# define MSVC_TYPEINFO_DWA200222_HPP
+
+#include <typeinfo>
+#include <boost/type.hpp>
+#include <boost/type_traits/config.hpp>
+
+//
+// Fix for MSVC's broken typeid() implementation which doesn't strip
+// decoration. This fix doesn't handle cv-qualified array types. It
+// could probably be done, but I haven't figured it out yet.
+//
+
+# if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(BOOST_INTEL_CXX_VERSION) && BOOST_INTEL_CXX_VERSION <= 700
+
+namespace boost { namespace python { namespace detail { 
+
+typedef std::type_info const& typeinfo;
+
+template <class T>
+static typeinfo typeid_nonref(T const volatile*) { return typeid(T); }
+
+template <class T>
+inline typeinfo typeid_ref_1(T&(*)())
+{
+    return detail::typeid_nonref((T*)0);
+}
+
+// A non-reference
+template <class T>
+inline typeinfo typeid_ref(type<T>*, T&(*)(type<T>))
+{
+    return detail::typeid_nonref((T*)0);
+}
+
+// A reference
+template <class T>
+inline typeinfo typeid_ref(type<T>*, ...)
+{
+    return detail::typeid_ref_1((T(*)())0);
+}
+
+template< typename T > T&(* is_ref_tester1(type<T>) )(type<T>) { return 0; }
+inline char BOOST_TT_DECL is_ref_tester1(...) { return 0; }
+
+template <class T>
+inline typeinfo msvc_typeid(boost::type<T>*)
+{
+    return detail::typeid_ref(
+        (boost::type<T>*)0, detail::is_ref_tester1(type<T>())
+        );
+}
+
+template <>
+inline typeinfo msvc_typeid<void>(boost::type<void>*)
+{
+    return typeid(void);
+}
+
+#  ifndef NDEBUG
+inline typeinfo assert_array_typeid_compiles()
+{
+    return msvc_typeid((boost::type<char const[3]>*)0)
+        , msvc_typeid((boost::type<char[3]>*)0);
+}
+#  endif
+
+}}} // namespace boost::python::detail
+
+# endif // BOOST_MSVC
+#endif // MSVC_TYPEINFO_DWA200222_HPP
--- a/include/boost/python/detail/none.hpp
+++ b/include/boost/python/detail/none.hpp
@@ -0,0 +1,20 @@
+//  (C) Copyright David Abrahams 2000.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
+//  producing this work.
+
+#ifndef NONE_DWA_052000_H_
+# define NONE_DWA_052000_H_
+
+# include <boost/python/detail/prefix.hpp>
+
+namespace boost { namespace python { namespace detail {
+
+inline PyObject* none() { Py_INCREF(Py_None); return Py_None; }
+    
+}}} // namespace boost::python::detail
+
+#endif // NONE_DWA_052000_H_
--- a/include/boost/python/detail/not_specified.hpp
+++ b/include/boost/python/detail/not_specified.hpp
@@ -0,0 +1,14 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef NOT_SPECIFIED_DWA2002321_HPP
+# define NOT_SPECIFIED_DWA2002321_HPP
+
+namespace boost { namespace python { namespace detail { 
+
+  struct not_specified {};
+
+}}} // namespace boost::python::detail
+
+#endif // NOT_SPECIFIED_DWA2002321_HPP
--- a/include/boost/python/detail/nullary_function_adaptor.hpp
+++ b/include/boost/python/detail/nullary_function_adaptor.hpp
@@ -0,0 +1,46 @@
+// Copyright David Abrahams 2003.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef NULLARY_FUNCTION_ADAPTOR_DWA2003824_HPP
+# define NULLARY_FUNCTION_ADAPTOR_DWA2003824_HPP
+
+# include <boost/python/detail/prefix.hpp>
+# include <boost/preprocessor/iteration/local.hpp>
+# include <boost/preprocessor/facilities/intercept.hpp>
+# include <boost/preprocessor/repetition/enum_params.hpp>
+# include <boost/preprocessor/repetition/enum_binary_params.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+// nullary_function_adaptor -- a class template which ignores its
+// arguments and calls a nullary function instead.  Used for building
+// error-reporting functions, c.f. pure_virtual
+template <class NullaryFunction>
+struct nullary_function_adaptor
+{
+    nullary_function_adaptor(NullaryFunction fn)
+      : m_fn(fn)
+    {}
+
+    void operator()() const { m_fn(); }
+
+# define BOOST_PP_LOCAL_MACRO(i)                                            \
+    template <BOOST_PP_ENUM_PARAMS_Z(1, i, class A)>                        \
+    void operator()(                                                        \
+        BOOST_PP_ENUM_BINARY_PARAMS_Z(1, i, A, const& BOOST_PP_INTERCEPT)   \
+    ) const                                                                 \
+    {                                                                       \
+        m_fn();                                                             \
+    }
+
+# define BOOST_PP_LOCAL_LIMITS (1, BOOST_PYTHON_MAX_ARITY)
+# include BOOST_PP_LOCAL_ITERATE()
+    
+ private:
+    NullaryFunction m_fn;
+};
+
+}}} // namespace boost::python::detail
+
+#endif // NULLARY_FUNCTION_ADAPTOR_DWA2003824_HPP
--- a/include/boost/python/detail/operator_id.hpp
+++ b/include/boost/python/detail/operator_id.hpp
@@ -0,0 +1,55 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef OPERATOR_ID_DWA2002531_HPP
+# define OPERATOR_ID_DWA2002531_HPP
+
+namespace boost { namespace python { namespace detail {
+
+enum operator_id
+{ 
+    op_add, 
+    op_sub, 
+    op_mul, 
+    op_div, 
+    op_mod, 
+    op_divmod,
+    op_pow, 
+    op_lshift, 
+    op_rshift, 
+    op_and, 
+    op_xor, 
+    op_or, 
+    op_neg, 
+    op_pos, 
+    op_abs, 
+    op_invert, 
+    op_int, 
+    op_long, 
+    op_float, 
+    op_str,
+    op_cmp,
+    op_gt,
+    op_ge,
+    op_lt,
+    op_le,
+    op_eq,
+    op_ne,
+    op_iadd,
+    op_isub,
+    op_imul,
+    op_idiv,
+    op_imod,
+    op_ilshift,
+    op_irshift,
+    op_iand,
+    op_ixor,
+    op_ior,
+    op_complex,
+    op_nonzero
+};
+
+}}} // namespace boost::python::detail
+
+#endif // OPERATOR_ID_DWA2002531_HPP
--- a/Show More
+++ b/Show More