Finalizing....

[SVN r15426]
renamed the stub bases to better reflect the intent.
2026-01-24 06:02:14 +00:00 · 2002-09-18 01:39:32 +00:00 · 2002-09-17 23:55:04 +00:00 · 2002-09-17 06:09:23 +00:00 · 2002-09-16 05:44:14 +00:00 · 2002-09-16 04:14:30 +00:00
324 changed files with 34179 additions and 4734 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/arg_from_python.hpp
+++ b/include/boost/python/arg_from_python.hpp
@@ -0,0 +1,52 @@
+// Copyright David Abrahams 2002. 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 ARG_FROM_PYTHON_DWA2002128_HPP
+# define ARG_FROM_PYTHON_DWA2002128_HPP
+
+# include <boost/python/converter/arg_from_python.hpp>
+
+namespace boost { namespace python { 
+
+template <class T>
+struct arg_from_python
+    : converter::select_arg_from_python<T>::type
+{
+    typedef typename converter::select_arg_from_python<T>::type base;
+    arg_from_python(PyObject*);
+};
+
+// specialization for PyObject*
+template <>
+struct arg_from_python<PyObject*>
+{
+    typedef PyObject* result_type;
+    
+    arg_from_python(PyObject*) {}
+    bool convertible() const { return true; }
+    PyObject* operator()(PyObject* source) const { return source; }
+};
+
+template <>
+struct arg_from_python<PyObject* const&>
+{
+    typedef PyObject* const& result_type;
+    arg_from_python(PyObject*) {}
+    bool convertible() const { return true; }
+    PyObject*const& operator()(PyObject*const& source) const { return 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,34 @@
+// Copyright David Abrahams 2002. 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 ARGS_DWA2002323_HPP
+# define ARGS_DWA2002323_HPP
+#  include <boost/config.hpp>
+#  include <boost/python/detail/preprocessor.hpp>
+#  include <boost/python/detail/type_list.hpp>
+
+namespace boost { namespace python {
+
+enum no_init_t { no_init };
+
+namespace detail
+{
+  template <class Args>
+  struct args_base {};
+}
+}}
+
+namespace boost { namespace python {
+
+// A type list for specifying arguments
+template < BOOST_PYTHON_ENUM_WITH_DEFAULT(BOOST_PYTHON_MAX_ARITY, typename A, mpl::void_) >
+struct args : detail::args_base<args<BOOST_PYTHON_UNARY_ENUM(BOOST_PYTHON_MAX_ARITY, A)> >
+      , detail::type_list< BOOST_PYTHON_UNARY_ENUM(BOOST_PYTHON_MAX_ARITY, A) >::type
+{};
+
+}} // namespace boost::python
+
+
+# endif // ARGS_DWA2002323_HPP
--- a/include/boost/python/back_reference.hpp
+++ b/include/boost/python/back_reference.hpp
@@ -0,0 +1,101 @@
+// Copyright David Abrahams 2002. 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 BACK_REFERENCE_DWA2002510_HPP
+# define BACK_REFERENCE_DWA2002510_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,36 @@
+// Copyright David Abrahams 2002. 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 BASE_TYPE_TRAITS_DWA2002614_HPP
+# define BASE_TYPE_TRAITS_DWA2002614_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;
+};
+
+}} // namespace boost::python
+
+#endif // BASE_TYPE_TRAITS_DWA2002614_HPP
--- a/include/boost/python/bases.hpp
+++ b/include/boost/python/bases.hpp
@@ -0,0 +1,60 @@
+// Copyright David Abrahams 2002. 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 BASES_DWA2002321_HPP
+# define BASES_DWA2002321_HPP
+# include <boost/type_traits/object_traits.hpp>
+# include <boost/python/detail/type_list.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/preprocessor/enum_params_with_a_default.hpp>
+# include <boost/preprocessor/enum_params.hpp>
+
+namespace boost { namespace python { 
+
+  // A type list for specifying bases
+  template < BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PYTHON_MAX_BASES, typename B, mpl::void_) >
+  struct bases : detail::type_list< BOOST_PP_ENUM_PARAMS(BOOST_PYTHON_MAX_BASES, B) >::type
+  {};
+
+  namespace detail
+  {
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    template <class T> struct specifies_bases
+    {
+        BOOST_STATIC_CONSTANT(bool, value = false);
+    };
+    template < BOOST_PP_ENUM_PARAMS(BOOST_PYTHON_MAX_BASES, class B) >
+    struct specifies_bases< bases< BOOST_PP_ENUM_PARAMS(BOOST_PYTHON_MAX_BASES, B) > >
+    {
+        BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+# else
+    template < BOOST_PP_ENUM_PARAMS(BOOST_PYTHON_MAX_BASES, class B) >
+    static char is_bases_helper(bases< BOOST_PP_ENUM_PARAMS(BOOST_PYTHON_MAX_BASES, B) > 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));
+    };
+# endif
+    template <class T, class Prev = bases<> >
+    struct select_bases
+        : mpl::if_c<
+                specifies_bases<T>::value
+                , T
+                , Prev
+          >
+    {
+    };
+  }
+}} // namespace boost::python
+
+#endif // BASES_DWA2002321_HPP
--- a/include/boost/python/borrowed.hpp
+++ b/include/boost/python/borrowed.hpp
@@ -0,0 +1,20 @@
+// Copyright David Abrahams 2002. 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 BORROWED_DWA2002614_HPP
+# define BORROWED_DWA2002614_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,64 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
+#if !defined(BOOST_PP_IS_ITERATING)
+
+// Copyright David Abrahams 2002. 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

-#ifndef CALL_DWA20011214_HPP
-# define CALL_DWA20011214_HPP
+# ifndef CALL_DWA2002411_HPP
+#  define CALL_DWA2002411_HPP

-# include <boost/python/detail/returning.hpp>
+#  include <boost/type.hpp>

-namespace boost { namespace python { 
+#  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>
-PyObject* call(R (*f)(), 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>

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

-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);
-}
+# 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>
-PyObject* call(R (*f)(A0, 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 (*f)(A0, 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 (*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
+# line BOOST_PP_LINE(__LINE__, call.hpp)
+
+# define N BOOST_PP_ITERATION()
+
+template <
+    class R
+    BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)
+    >
+typename detail::returnable<R>::type
+call(PyObject* callable
+    BOOST_PP_COMMA_IF(N) BOOST_PYTHON_BINARY_ENUM(N, A, const& a)
+    , boost::type<R>* = 0
+    )
+{
+    converter::return_from_python<R> converter;
+    return converter(
+        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)
+            ));
+}
+
+# undef N
+
+#endif
--- a/include/boost/python/call_method.hpp
+++ b/include/boost/python/call_method.hpp
@@ -0,0 +1,64 @@
+#if !defined(BOOST_PP_IS_ITERATING)
+
+// Copyright David Abrahams 2002. 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 CALL_METHOD_DWA2002411_HPP
+#  define CALL_METHOD_DWA2002411_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>
+
+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
+# line BOOST_PP_LINE(__LINE__, call_method.hpp)
+
+# define N BOOST_PP_ITERATION()
+
+template <
+    class R
+    BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)
+    >
+typename detail::returnable<R>::type
+call_method(PyObject* self, char const* name
+    BOOST_PP_COMMA_IF(N) BOOST_PYTHON_BINARY_ENUM(N, A, const& a)
+    , boost::type<R>* = 0
+    )
+{
+    converter::return_from_python<R> converter;
+    return converter(
+        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)
+            ));
+}
+
+# undef N
+
+#endif // BOOST_PP_IS_ITERATING
--- a/include/boost/python/callback.hpp
+++ b/include/boost/python/callback.hpp
@@ -0,0 +1,829 @@
+//  (C) Copyright David Abrahams 2000. 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.
+//
+//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
+//  producing this work.
+//
+//  This file was generated for 10-argument python callbacks by gen_callback.python
+
+#ifndef CALLBACK_DWA_052100_H_
+# define CALLBACK_DWA_052100_H_
+
+# include <boost/python/detail/config.hpp>
+# include <boost/python/conversions.hpp>
+
+namespace boost { namespace python {
+
+namespace detail {
+  template <class T>
+  inline void callback_adjust_refcount(PyObject*, type<T>) {}
+  
+  inline void callback_adjust_refcount(PyObject* p, type<PyObject*>)
+      { Py_INCREF(p); }
+}
+
+// Calling Python from C++
+template <class R>
+struct callback
+{
+    static R call_method(PyObject* self, const char* name)
+    {
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("()")));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    static R call(PyObject* self)
+    {
+        ref result(PyEval_CallFunction(self, const_cast<char*>("()")));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1>
+    static R call_method(PyObject* self, const char* name, const A1& a1)
+    {
+        ref p1(to_python(a1));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(O)"),
+                                     p1.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1>
+    static R call(PyObject* self, const A1& a1)
+    {
+        ref p1(to_python(a1));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(O)"),
+                                       p1.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2>
+    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OO)"),
+                                     p1.get(),
+                                     p2.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2>
+    static R call(PyObject* self, const A1& a1, const A2& a2)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OO)"),
+                                       p1.get(),
+                                       p2.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3>
+    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3>
+    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4>
+    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4>
+    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5>
+    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5>
+    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6>
+    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get(),
+                                     p6.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6>
+    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get(),
+                                       p6.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get(),
+                                     p6.get(),
+                                     p7.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get(),
+                                       p6.get(),
+                                       p7.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get(),
+                                     p6.get(),
+                                     p7.get(),
+                                     p8.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get(),
+                                       p6.get(),
+                                       p7.get(),
+                                       p8.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOOOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get(),
+                                     p6.get(),
+                                     p7.get(),
+                                     p8.get(),
+                                     p9.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get(),
+                                       p6.get(),
+                                       p7.get(),
+                                       p8.get(),
+                                       p9.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
+    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref p10(to_python(a10));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOOOOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get(),
+                                     p6.get(),
+                                     p7.get(),
+                                     p8.get(),
+                                     p9.get(),
+                                     p10.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
+    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref p10(to_python(a10));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get(),
+                                       p6.get(),
+                                       p7.get(),
+                                       p8.get(),
+                                       p9.get(),
+                                       p10.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+};
+
+// This specialization wouldn't be needed, but MSVC6 doesn't correctly allow the following:
+// void g();
+// void f() { return g(); }
+template <>
+struct callback<void>
+{
+
+    static void call_method(PyObject* self, const char* name)
+    {
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("()")));
+    }
+
+    static void call(PyObject* self)
+    {
+        ref result(PyEval_CallFunction(self, const_cast<char*>("()")));
+    }
+
+    template <class A1>
+    static void call_method(PyObject* self, const char* name, const A1& a1)
+    {
+        ref p1(to_python(a1));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(O)"),
+                                     p1.get()));
+    }
+
+    template <class A1>
+    static void call(PyObject* self, const A1& a1)
+    {
+        ref p1(to_python(a1));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(O)"),
+                                       p1.get()));
+    }
+
+    template <class A1, class A2>
+    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OO)"),
+                                     p1.get(),
+                                     p2.get()));
+    }
+
+    template <class A1, class A2>
+    static void call(PyObject* self, const A1& a1, const A2& a2)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OO)"),
+                                       p1.get(),
+                                       p2.get()));
+    }
+
+    template <class A1, class A2, class A3>
+    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get()));
+    }
+
+    template <class A1, class A2, class A3>
+    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4>
+    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4>
+    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5>
+    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5>
+    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6>
+    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get(),
+                                     p6.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6>
+    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get(),
+                                       p6.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get(),
+                                     p6.get(),
+                                     p7.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get(),
+                                       p6.get(),
+                                       p7.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get(),
+                                     p6.get(),
+                                     p7.get(),
+                                     p8.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get(),
+                                       p6.get(),
+                                       p7.get(),
+                                       p8.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOOOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get(),
+                                     p6.get(),
+                                     p7.get(),
+                                     p8.get(),
+                                     p9.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get(),
+                                       p6.get(),
+                                       p7.get(),
+                                       p8.get(),
+                                       p9.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
+    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref p10(to_python(a10));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOOOOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get(),
+                                     p6.get(),
+                                     p7.get(),
+                                     p8.get(),
+                                     p9.get(),
+                                     p10.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
+    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref p10(to_python(a10));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get(),
+                                       p6.get(),
+                                       p7.get(),
+                                       p8.get(),
+                                       p9.get(),
+                                       p10.get()));
+    }
+};
+
+// Make it a compile-time error to try to return a const char* from a virtual
+// function. The standard conversion
+//
+//      from_python(PyObject* string, boost::python::type<const char*>)
+//
+// returns a pointer to the character array which is internal to string. The
+// problem with trying to do this in a standard callback function is that the
+// Python string would likely be destroyed upon return from the calling function
+// (boost::python::callback<const char*>::call[_method]) when its reference count is
+// decremented. If you absolutely need to do this and you're sure it's safe (it
+// usually isn't), you can use
+//
+//      boost::python::string result(boost::python::callback<boost::python::string>::call[_method](...args...));
+//      ...result.c_str()... // access the char* array
+template <>
+struct callback<const char*>
+{
+    // Try hard to generate a readable error message
+    typedef struct unsafe_since_python_string_may_be_destroyed {} call, call_method;
+};
+
+}} // namespace boost::python
+
+#endif // CALLBACK_DWA_052100_H_
--- a/include/boost/python/caller.hpp
+++ b/include/boost/python/caller.hpp
--- a/include/boost/python/cast.hpp
+++ b/include/boost/python/cast.hpp
@@ -0,0 +1,106 @@
+// Copyright David Abrahams 2002. 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 CAST_DWA200269_HPP
+# define CAST_DWA200269_HPP
+
+# include <boost/python/detail/wrap_python.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;
+      static 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,450 @@
+// Copyright David Abrahams 2002. 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_DWA200216_HPP
+# define CLASS_DWA200216_HPP
+
+# include <boost/python/class_fwd.hpp>
+# include <boost/python/object/class.hpp>
+# include <boost/python/bases.hpp>
+# include <boost/python/args.hpp>
+
+# include <boost/python/object.hpp>
+
+# include <boost/python/type_id.hpp>
+# include <boost/python/detail/member_function_cast.hpp>
+# include <boost/python/object/class_converters.hpp>
+# include <boost/type_traits/ice.hpp>
+# include <boost/type_traits/same_traits.hpp>
+# include <boost/mpl/size.hpp>
+# include <boost/mpl/for_each.hpp>
+# include <boost/mpl/bool_c.hpp>
+# include <boost/python/object/select_holder.hpp>
+# include <boost/python/object/class_wrapper.hpp>
+# include <boost/python/object/make_instance.hpp>
+# include <boost/python/data_members.hpp>
+# include <boost/utility.hpp>
+# include <boost/python/detail/operator_id.hpp>
+# include <boost/python/object/pickle_support.hpp>
+# include <boost/python/make_function.hpp>
+# include <boost/python/object/add_to_namespace.hpp>
+# include <boost/python/detail/def_helper.hpp>
+# include <boost/python/detail/force_instantiate.hpp>
+# include <boost/python/detail/defaults_def.hpp>
+# include <boost/python/signature.hpp>
+# include <boost/python/init.hpp>
+
+namespace boost { namespace python {
+
+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, class Prev = detail::not_specified>
+  struct select_held_type;
+
+  template <class T1, class T2, class T3>
+  struct has_noncopyable;
+
+  template <detail::operator_id, class L, class R>
+  struct operator_;
+
+  // Register a to_python converter for a class T, depending on the
+  // type of the first (tag) argument. The 2nd argument is a pointer
+  // to the type of holder that must be created. The 3rd argument is a
+  // reference to the Python type object to be created.
+  template <class T, class SelectHolder>
+  static inline void register_copy_constructor(mpl::bool_c<true> const&, SelectHolder const& , T* = 0)
+  {
+      typedef typename SelectHolder::type holder;
+      force_instantiate(objects::class_wrapper<T,holder, objects::make_instance<T,holder> >());
+      SelectHolder::register_();
+  }
+
+  // Tag dispatched to have no effect.
+  template <class T, class SelectHolder>
+  static inline void register_copy_constructor(mpl::bool_c<false> const&, SelectHolder const&, T* = 0)
+  {
+      SelectHolder::register_();
+  }
+
+  template <class T> int assert_default_constructible(T const&);
+}
+
+//
+// class_<T,Bases,HolderGenerator>
+//
+//      This is the primary mechanism through which users will expose
+//      C++ classes to Python. The three template arguments are:
+//
+template <
+    class T // class being wrapped
+    , class X1 // = detail::not_specified
+    , class X2 // = detail::not_specified
+    , class X3 // = detail::not_specified
+    >
+class class_ : public objects::class_base
+{
+ private: // types
+   typedef objects::class_base base;
+
+    typedef class_<T,X1,X2,X3> self;
+    BOOST_STATIC_CONSTANT(bool, is_copyable = (!detail::has_noncopyable<X1,X2,X3>::value));
+
+    typedef typename detail::select_held_type<
+        X1, typename detail::select_held_type<
+        X2, typename detail::select_held_type<
+        X3
+    >::type>::type>::type held_type;
+
+    typedef objects::select_holder<T,held_type> holder_selector;
+
+    typedef typename detail::select_bases<X1
+            , typename detail::select_bases<X2
+              , typename boost::python::detail::select_bases<X3>::type
+              >::type
+            >::type bases;
+
+    // A helper class which will contain an array of id objects to be
+    // passed to the base class constructor
+    struct id_vector
+    {
+        id_vector()
+        {
+            // Stick the derived class id into the first element of the array
+            ids[0] = type_id<T>();
+
+            // 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:
+    // Automatically derive the class name - only works on some
+    // compilers because type_info::name is sometimes mangled (gcc)
+//    class_();           // With default-constructor init function
+//    class_(no_init_t);  // With no init function
+
+    // 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 no init() function
+    class_(char const* name, no_init_t);
+
+    // Construct with class name, docstring, and no init() function
+    class_(char const* name, char const* doc, no_init_t);
+
+    template <class DerivedT>
+    inline class_(char const* name, init_base<DerivedT> const& i)
+        : base(name, id_vector::size, id_vector().ids)
+    {
+        this->register_();
+        define_init(*this, i.derived());
+        this->set_instance_size(holder_selector::additional_size());
+    }
+
+    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->register_();
+        define_init(*this, i.derived());
+        this->set_instance_size(holder_selector::additional_size());
+    }
+
+    // Wrap a member function or a non-member function which can take
+    // a T, T cv&, or T cv* as its first parameter, or a callable
+    // python object.
+    template <class F>
+    self& def(char const* name, F f)
+    {
+        this->def_impl(name, f, default_call_policies(), 0, &f);
+        return *this;
+    }
+
+    template <class DerivedT>
+    self& def(init_base<DerivedT> const& i)
+    {
+        define_init(*this, i.derived());
+        return *this;
+    }
+
+    template <class Arg1T, class Arg2T>
+    self& def(char const* name, Arg1T arg1, Arg2T const& arg2)
+    {
+        //  The arguments may be:
+        //      def(name, function)
+        //      def(name, function, policy)
+        //      def(name, function, doc_string)
+        //      def(name, signature, stubs)
+
+        dispatch_def(&arg2, name, arg1, arg2);
+        return *this;
+    }
+
+    template <class Arg1T, class Arg2T, class Arg3T>
+    self& def(char const* name, Arg1T arg1, Arg2T const& arg2, Arg3T const& arg3)
+    {
+        //  The arguments are definitely:
+        //      def(name, function, policy, doc_string)
+        //      def(name, function, doc_string, policy)
+
+        dispatch_def(&arg2, name, arg1, arg2, arg3);
+        return *this;
+    }
+
+    template <detail::operator_id id, class L, class R>
+    self& def(detail::operator_<id,L,R> const& op)
+    {
+        typedef detail::operator_<id,L,R> op_t;
+        return this->def(op.name(), &op_t::template apply<T>::execute);
+    }
+
+    // Define the constructor with the given Args, which should be an
+    // MPL sequence of types.
+    template <class Args>
+    self& def_init(Args const&)
+    {
+        return this->def("__init__",
+            python::make_constructor<Args>(
+                // Using runtime type selection works around a CWPro7 bug.
+                holder_selector::execute((held_type*)0).get()
+                )
+            );
+    }
+
+    template <class Args, class CallPolicyOrDoc>
+    self& def_init(Args const&, CallPolicyOrDoc const& policy_or_doc, char const* doc = 0)
+    {
+        typedef detail::def_helper<CallPolicyOrDoc> helper;
+
+        return this->def(
+            "__init__",
+            python::make_constructor<Args>(
+                helper::get_policy(policy_or_doc)
+                // Using runtime type selection works around a CWPro7 bug.
+                , holder_selector::execute((held_type*)0).get()
+                )
+            , helper::get_doc(policy_or_doc, doc)
+            );
+    }
+
+    // Define the default constructor.
+    self& def_init()
+    {
+        this->def_init(mpl::list0<>::type());
+        return *this;
+    }
+
+    //
+    // Data member access
+    //
+    template <class D>
+    self& def_readonly(char const* name, D T::*pm)
+    {
+        this->add_property(name, make_getter(pm));
+        return *this;
+    }
+
+    template <class D>
+    self& def_readwrite(char const* name, D T::*pm)
+    {
+        return this->add_property(name, make_getter(pm), make_setter(pm));
+    }
+
+    // Property creation
+    template <class Get>
+    self& add_property(char const* name, Get const& fget)
+    {
+        base::add_property(name, object(fget));
+        return *this;
+    }
+
+    template <class Get, class Set>
+    self& add_property(char const* name, Get const& fget, Set const& fset)
+    {
+        base::add_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;
+    }
+
+ private: // helper functions
+
+    template <class Fn, class Policies>
+    inline void def_impl(char const* name, Fn fn, Policies const& policies
+                         , char const* doc, ...)
+    {
+        objects::add_to_namespace(
+            *this, name,
+            make_function(
+                    // This bit of nastiness casts F to a member function of T if possible.
+                detail::member_function_cast<T,Fn>::stage1(fn).stage2((T*)0).stage3(fn)
+                , policies)
+            , doc);
+    }
+
+    template <class F>
+    inline void def_impl(char const* name, F f, default_call_policies const&
+                         , char const* doc, object const*)
+    {
+        objects::add_to_namespace(*this, name, f, doc);
+    }
+
+    inline void register_() const;
+
+    template <class StubsT, class SigT>
+    void dispatch_def(
+        detail::overloads_base const*,
+        char const* name,
+        SigT sig,
+        StubsT const& stubs)
+    {
+        //  convert sig to a type_list (see detail::get_signature in signature.hpp)
+        //  before calling detail::define_with_defaults.
+        detail::define_with_defaults(
+            name, stubs, *this, detail::get_signature(sig));
+    }
+
+    template <class Fn, class CallPolicyOrDoc>
+    void dispatch_def(
+        void const*,
+        char const* name,
+        Fn fn,
+        CallPolicyOrDoc const& policy_or_doc)
+    {
+        typedef detail::def_helper<CallPolicyOrDoc> helper;
+        this->def_impl(
+            name, fn, helper::get_policy(policy_or_doc),
+            helper::get_doc(policy_or_doc, 0), &fn);
+
+    }
+
+    template <class Fn, class CallPolicyOrDoc1, class CallPolicyOrDoc2>
+    void dispatch_def(
+        void const*,
+        char const* name,
+        Fn fn,
+        CallPolicyOrDoc1 const& policy_or_doc1,
+        CallPolicyOrDoc2 const& policy_or_doc2)
+    {
+        typedef detail::def_helper<CallPolicyOrDoc1> helper;
+
+        this->def_impl(
+            name, fn, helper::get_policy(policy_or_doc1, policy_or_doc2),
+            helper::get_doc(policy_or_doc1, policy_or_doc2), &fn);
+    }
+};
+
+
+//
+// implementations
+//
+        // register converters
+template <class T, class X1, class X2, class X3>
+inline void class_<T,X1,X2,X3>::register_() const
+{
+    objects::register_class_from_python<T,bases>();
+
+    detail::register_copy_constructor<T>(
+        mpl::bool_c<is_copyable>()
+        , holder_selector::execute((held_type*)0)
+        );
+}
+
+template <class T, class X1, class X2, class X3>
+inline class_<T,X1,X2,X3>::class_(char const* name, char const* doc)
+    : base(name, id_vector::size, id_vector().ids, doc)
+{
+    this->register_();
+    detail::force_instantiate(sizeof(detail::assert_default_constructible(T())));
+    this->def_init();
+    this->set_instance_size(holder_selector::additional_size());
+}
+
+template <class T, class X1, class X2, class X3>
+inline class_<T,X1,X2,X3>::class_(char const* name, no_init_t)
+    : base(name, id_vector::size, id_vector().ids)
+{
+    this->register_();
+    this->def_no_init();
+}
+
+template <class T, class X1, class X2, class X3>
+inline class_<T,X1,X2,X3>::class_(char const* name, char const* doc, no_init_t)
+    : base(name, id_vector::size, id_vector().ids, doc)
+{
+    this->register_();
+    this->def_no_init();
+}
+
+namespace detail
+{
+  template <class T1, class T2, class T3>
+  struct has_noncopyable
+      : type_traits::ice_or<
+        is_same<T1,noncopyable>::value
+      , is_same<T2,noncopyable>::value
+      , is_same<T3,noncopyable>::value>
+  {};
+
+
+    template <class T, class Prev>
+    struct select_held_type
+        : mpl::if_c<
+            type_traits::ice_or<
+                 specifies_bases<T>::value
+               , is_same<T,noncopyable>::value
+            >::value
+            , Prev
+            , T
+          >
+    {
+    };
+}
+
+}} // namespace boost::python
+
+#endif // CLASS_DWA200216_HPP
--- a/include/boost/python/class_builder.hpp
+++ b/include/boost/python/class_builder.hpp
@@ -0,0 +1,182 @@
+// Revision History:
+// Mar 03 01  added: pickle safety measures (Ralf W. Grosse-Kunstleve)
+
+#ifndef CLASS_WRAPPER_DWA101000_H_
+# define CLASS_WRAPPER_DWA101000_H_
+
+#include <boost/python/detail/extension_class.hpp>
+#include <boost/python/operators.hpp>
+#include <boost/python/module_builder.hpp>
+#include <boost/python/conversions.hpp>
+#include <boost/python/detail/cast.hpp>
+#include <boost/python/reference.hpp>
+
+namespace boost { namespace python {
+
+// Syntactic sugar to make wrapping classes more convenient
+template <class T, class U = detail::held_instance<T> >
+class class_builder
+    : python_extension_class_converters<T, U> // Works around MSVC6.x/GCC2.95.2 bug described below
+{
+ public:
+    class_builder(module_builder& module, const char* name)
+        : m_class(new detail::extension_class<T, U>(name))
+    {
+        module.add(ref(as_object(m_class.get()), ref::increment_count), name);
+    }
+    
+  template <class OtherT, class OtherU>
+    class_builder(class_builder<OtherT, OtherU>& cls, const char* name)
+        : m_class(new detail::extension_class<T, U>(name))
+    {
+        cls.add(ref(as_object(m_class.get()), ref::increment_count), name);
+    }
+    
+  template <class OtherT, class OtherU>
+    class_builder(detail::extension_class<OtherT, OtherU>* cls,
+                  const char* name)
+        : m_class(new detail::extension_class<T, U>(name))
+    {
+        cls->set_attribute(name,
+                           ref(as_object(m_class.get()), ref::increment_count));
+    }
+    
+    ~class_builder()
+    {}
+
+    inline void dict_defines_state() {
+      add(ref(BOOST_PYTHON_CONVERSION::to_python(1)), "__dict_defines_state__");
+    }
+    inline void getstate_manages_dict() {
+      add(ref(BOOST_PYTHON_CONVERSION::to_python(1)), "__getstate_manages_dict__");
+    }
+    
+    // define constructors
+    template <class signature>
+    void def(const signature& s)
+        { m_class->def(s); }
+
+    // export heterogeneous reverse-argument operators 
+    // (type of lhs: 'left', of rhs: 'right')
+    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub), Foo>(),
+    //                       boost::python::left_operand<int const &>());
+    template <long which, class left, class right>
+    void def(operators<which, right> o1, left_operand<left> o2)
+        { m_class->def(o1, o2); }
+
+    // export heterogeneous operators (type of lhs: 'left', of rhs: 'right')
+    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub), Foo>(),
+    //                       boost::python::right_operand<int const &>());
+    template <long which, class left, class right>
+    void def(operators<which, left> o1, right_operand<right> o2)
+        { m_class->def(o1, o2); }
+
+    // define a function that passes Python arguments and keywords
+    // to C++ verbatim (as a 'tuple const &' and 'dictionary const &' 
+    // respectively). This is useful for manual argument passing.
+    // It's also the only possibility to pass keyword arguments to C++.
+    // Fn must have a signatur that is compatible to 
+    //     PyObject * (*)(PyObject * aTuple, PyObject * aDictionary)
+    template <class Fn>
+    void def_raw(Fn fn, const char* name)
+        { m_class->def_raw(fn, name); }
+
+    // define member functions. In fact this works for free functions, too -
+    // they act like static member functions, or if they start with the
+    // appropriate self argument (as a pointer or reference), they can be used
+    // just like ordinary member functions -- just like Python!
+    template <class Fn>
+    void def(Fn fn, const char* name)
+        { m_class->def(fn, name); }
+
+    // Define a virtual member function with a default implementation.
+    // default_fn should be a function which provides the default implementation.
+    // Be careful that default_fn does not in fact call fn virtually!
+    template <class Fn, class DefaultFn>
+    void def(Fn fn, const char* name, DefaultFn default_fn)
+        { m_class->def(fn, name, default_fn); }
+
+    // Provide a function which implements x.<name>, reading from the given
+    // member (pm) of the T obj
+    template <class MemberType>
+    void def_getter(MemberType T::*pm, const char* name)
+        { m_class->def_getter(pm, name); }
+    
+    // Provide a function which implements assignment to x.<name>, writing to
+    // the given member (pm) of the T obj
+    template <class MemberType>
+    void def_setter(MemberType T::*pm, const char* name)
+        { m_class->def_getter(pm, name); }
+    
+    // Expose the given member (pm) of the T obj as a read-only attribute
+    template <class MemberType>
+    void def_readonly(MemberType T::*pm, const char* name)
+        { m_class->def_readonly(pm, name); }
+    
+    // Expose the given member (pm) of the T obj as a read/write attribute
+    template <class MemberType>
+    void def_read_write(MemberType T::*pm, const char* name)
+        { m_class->def_read_write(pm, name); }
+        
+    // define the standard coercion needed for operator overloading
+    void def_standard_coerce()
+        { m_class->def_standard_coerce(); }
+    
+    // declare the given class a base class of this one and register 
+    // conversion functions
+    template <class S, class V>
+    void declare_base(class_builder<S, V> const & base)
+    {
+        m_class->declare_base(base.get_extension_class());
+    }
+
+    // declare the given class a base class of this one and register 
+    // upcast conversion function
+    template <class S, class V>
+    void declare_base(class_builder<S, V> const & base, without_downcast_t)
+    {
+        m_class->declare_base(base.get_extension_class(), without_downcast);
+    }
+
+    // get the embedded ExtensioClass object
+    detail::extension_class<T, U> * get_extension_class() const 
+    {
+        return m_class.get();
+    }
+
+    // set an arbitrary attribute. Useful for non-function class data members,
+    // e.g. enums
+    void add(PyObject* x, const char* name)
+        { m_class->set_attribute(name, x); }
+    void add(ref x, const char* name)
+        { m_class->set_attribute(name, x); }
+ private:
+    // declare the given class a base class of this one and register 
+    // conversion functions
+    template <class S, class V>
+    void declare_base(detail::extension_class<S, V> * base)
+    {
+        m_class->declare_base(base);
+    }
+        
+    // declare the given class a base class of this one and register 
+    // upcast conversion function
+    template <class S, class V>
+    void declare_base(detail::extension_class<S, V> * base, without_downcast_t)
+    {
+        m_class->declare_base(base, without_downcast);
+    }
+    
+    reference<detail::extension_class<T, U> > m_class;
+};
+
+// The bug mentioned at the top of this file is that on certain compilers static
+// global functions declared within the body of a class template will only be
+// generated when the class template is constructed, and when (for some reason)
+// the construction does not occur via a new-expression. Otherwise, we could
+// rely on the initialization of the m_class data member to cause all of the
+// to_/from_python functions to come into being.
+
+}} // namespace boost::python
+
+#endif // CLASS_WRAPPER_DWA101000_H_
--- a/include/boost/python/class_fwd.hpp
+++ b/include/boost/python/class_fwd.hpp
@@ -0,0 +1,30 @@
+// Copyright David Abrahams 2002. 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_FWD_DWA200222_HPP
+# define CLASS_FWD_DWA200222_HPP
+# include <boost/python/detail/not_specified.hpp>
+# include <boost/python/args.hpp>
+# include <boost/python/bases.hpp>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  struct empty_list;
+}
+
+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/classes.hpp
+++ b/include/boost/python/classes.hpp
@@ -0,0 +1,677 @@
+//  (C) Copyright David Abrahams 2000. 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.
+//
+//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
+//  producing this work.
+
+#ifndef SUBCLASS_DWA051500_H_
+# define SUBCLASS_DWA051500_H_
+
+# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/types.hpp>
+# include <boost/python/objects.hpp>
+# include <boost/python/detail/singleton.hpp>
+# include <boost/utility.hpp>
+# include <boost/python/conversions.hpp>
+# include <boost/python/callback.hpp>
+
+namespace boost { namespace python {
+
+// A simple type which acts something like a built-in Python class obj.
+class BOOST_PYTHON_DECL instance
+    : public boost::python::detail::python_object
+{
+ public:
+    instance(PyTypeObject* class_);
+    ~instance();
+
+    // Standard Python functions.
+    PyObject* repr();
+    int compare(PyObject*);
+    PyObject* str();
+    long hash();
+    PyObject* call(PyObject* args, PyObject* keywords);
+    PyObject* getattr(const char* name, bool use_special_function = true);
+    int setattr(const char* name, PyObject* value);
+
+    // Mapping methods
+    int length();
+    PyObject* get_subscript(PyObject* key);
+    void set_subscript(PyObject* key, PyObject* value);
+
+    // Sequence methods
+    PyObject* get_slice(int start, int finish);
+    void set_slice(int start, int finish, PyObject* value);
+
+    // Number methods
+    PyObject* add(PyObject* other);
+    PyObject* subtract(PyObject* other);
+    PyObject* multiply(PyObject* other);
+    PyObject* divide(PyObject* other);
+    PyObject* remainder(PyObject* other);
+    PyObject* divmod(PyObject* other);
+    PyObject* power(PyObject*, PyObject*);
+    PyObject* negative();
+    PyObject* positive();
+    PyObject* absolute();
+    int nonzero();
+    PyObject* invert();
+    PyObject* lshift(PyObject* other);
+    PyObject* rshift(PyObject* other);
+    PyObject* do_and(PyObject* other);
+    PyObject* do_xor(PyObject* other);
+    PyObject* do_or(PyObject* other);
+    int coerce(PyObject**, PyObject**);
+    PyObject* as_int();
+    PyObject* as_long();
+    PyObject* as_float();
+    PyObject* oct();
+    PyObject* hex();
+
+    // Rich comparisons
+    PyObject* lt(PyObject* other);
+    PyObject* le(PyObject* other);
+    PyObject* eq(PyObject* other);
+    PyObject* ne(PyObject* other);
+    PyObject* gt(PyObject* other);
+    PyObject* ge(PyObject* other);
+
+    // Inplace operations.
+    PyObject* inplace_add(PyObject* other);
+    PyObject* inplace_subtract(PyObject* other);
+    PyObject* inplace_multiply(PyObject* other);
+    PyObject* inplace_divide(PyObject* other);
+    PyObject* inplace_remainder(PyObject* other);
+    PyObject* inplace_power(PyObject* exponent, PyObject* modulus);
+    PyObject* inplace_lshift(PyObject* other);
+    PyObject* inplace_rshift(PyObject* other);
+    PyObject* inplace_and(PyObject* other);
+    PyObject* inplace_or(PyObject* other);
+    PyObject* inplace_xor(PyObject* other);
+
+ private: // noncopyable, without the size bloat
+    instance(const instance&);
+    void operator=(const instance&);
+
+ private: // helper functions
+    int setattr_dict(PyObject* value);
+    
+ private:
+    dictionary m_name_space;
+};
+
+template <class T> class meta_class;
+
+namespace detail {
+  class BOOST_PYTHON_DECL class_base : public type_object_base
+  {
+   public:
+      class_base(PyTypeObject* meta_class_obj, string name, tuple bases, const dictionary& name_space);
+      tuple bases() const;
+      string name() const;
+      dictionary& dict();
+      
+      // Standard Python functions.
+      PyObject* getattr(const char* name);
+      int setattr(const char* name, PyObject* value);
+      PyObject* repr() const;
+      void add_base(ref base);
+
+   protected:
+      bool initialize_instance(instance* obj, PyObject* args, PyObject* keywords);
+
+   private: // virtual functions
+      // Subclasses should override this to delete the particular obj type
+      virtual void delete_instance(PyObject*) const = 0;
+
+   private: // boost::python::type_object_base required interface implementation
+      void instance_dealloc(PyObject*) const; // subclasses should not override this
+    
+   private: // noncopyable, without the size bloat
+      class_base(const class_base&);
+      void operator=(const class_base&);
+      
+   private:
+      string m_name;
+      tuple m_bases;
+      dictionary m_name_space;
+  };
+
+  void enable_named_method(class_base* type_obj, const char* name);
+}
+
+// A type which acts a lot like a built-in Python class. T is the obj type,
+// so class_t<instance> is a very simple "class-alike".
+template <class T>
+class class_t : public boost::python::detail::class_base
+{
+ public:
+    class_t(meta_class<T>* meta_class_obj, string name, tuple bases, const dictionary& name_space);
+    ~class_t();
+    
+    // Standard Python functions.
+    PyObject* call(PyObject* args, PyObject* keywords);
+    
+ private: // Implement mapping methods on instances
+    PyObject* instance_repr(PyObject*) const;
+    int instance_compare(PyObject*, PyObject* other) const;
+    PyObject* instance_str(PyObject*) const;
+    long instance_hash(PyObject*) const;
+    int instance_mapping_length(PyObject*) const;
+    PyObject* instance_mapping_subscript(PyObject*, PyObject*) const;
+    int instance_mapping_ass_subscript(PyObject*, PyObject*, PyObject*) const;
+
+ private: // Implement sequence methods on instances
+    int instance_sequence_length(PyObject*) const;
+    PyObject* instance_sequence_item(PyObject* obj, int n) const;
+    int instance_sequence_ass_item(PyObject* obj, int n, PyObject* value) const;
+    PyObject* instance_sequence_slice(PyObject*, int start, int finish) const;
+    int instance_sequence_ass_slice(PyObject*, int start, int finish, PyObject* value) const;
+
+ private: // Implement number methods on instances
+    PyObject* instance_number_add(PyObject*, PyObject*) const;
+    PyObject* instance_number_subtract(PyObject*, PyObject*) const;
+    PyObject* instance_number_multiply(PyObject*, PyObject*) const;
+    PyObject* instance_number_divide(PyObject*, PyObject*) const;
+    PyObject* instance_number_remainder(PyObject*, PyObject*) const;
+    PyObject* instance_number_divmod(PyObject*, PyObject*) const;
+    PyObject* instance_number_power(PyObject*, PyObject*, PyObject*) const;
+    PyObject* instance_number_negative(PyObject*) const;
+    PyObject* instance_number_positive(PyObject*) const;
+    PyObject* instance_number_absolute(PyObject*) const;
+    int instance_number_nonzero(PyObject*) const;
+    PyObject* instance_number_invert(PyObject*) const;
+    PyObject* instance_number_lshift(PyObject*, PyObject*) const;
+    PyObject* instance_number_rshift(PyObject*, PyObject*) const;
+    PyObject* instance_number_and(PyObject*, PyObject*) const;
+    PyObject* instance_number_xor(PyObject*, PyObject*) const;
+    PyObject* instance_number_or(PyObject*, PyObject*) const;
+    int instance_number_coerce(PyObject*, PyObject**, PyObject**) const;
+    PyObject* instance_number_int(PyObject*) const;
+    PyObject* instance_number_long(PyObject*) const;
+    PyObject* instance_number_float(PyObject*) const;
+    PyObject* instance_number_oct(PyObject*) const;
+    PyObject* instance_number_hex(PyObject*) const;
+
+    PyObject* instance_number_inplace_add(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_subtract(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_multiply(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_divide(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_remainder(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_power(PyObject*, PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_lshift(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_rshift(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_and(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_or(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_xor(PyObject*, PyObject*) const;
+
+ private: // Implement rich comparisons
+    PyObject* instance_lt(PyObject*, PyObject*) const;
+    PyObject* instance_le(PyObject*, PyObject*) const;
+    PyObject* instance_eq(PyObject*, PyObject*) const;
+    PyObject* instance_ne(PyObject*, PyObject*) const;
+    PyObject* instance_gt(PyObject*, PyObject*) const;
+    PyObject* instance_ge(PyObject*, PyObject*) const;
+    
+ private: // Miscellaneous "special" methods
+    PyObject* instance_call(PyObject* obj, PyObject* args, PyObject* keywords) const;
+    PyObject* instance_getattr(PyObject* obj, const char* name) const;
+    int instance_setattr(PyObject* obj, const char* name, PyObject* value) const;
+
+ private: // Implementation of boost::python::detail::class_base required interface
+    void delete_instance(PyObject*) const;
+};
+
+// The type of a class_t<T> object.
+template <class T>
+class meta_class
+    : public boost::python::detail::reprable<
+                boost::python::detail::callable<
+                   boost::python::detail::getattrable<
+                      boost::python::detail::setattrable<
+                         boost::python::detail::type_object<class_t<T> > > > > >,
+      private boost::noncopyable
+{
+ public:
+    meta_class();
+
+    // Standard Python functions.
+    PyObject* call(PyObject* args, PyObject* keywords);
+    
+    struct type_object
+        : boost::python::detail::singleton<type_object,
+             boost::python::detail::callable<
+                boost::python::detail::type_object<meta_class> > >
+    {
+        type_object() : singleton_base(&PyType_Type) {}
+    };
+};
+
+//
+// Member function implementations.
+//
+template <class T>
+meta_class<T>::meta_class()
+    : properties(type_object::instance())
+{
+} 
+
+template <class T>
+class_t<T>::class_t(meta_class<T>* meta_class_obj, string name, tuple bases, const dictionary& name_space)
+    : boost::python::detail::class_base(meta_class_obj, name, bases, name_space)
+{
+}
+
+template <class T>
+class_t<T>::~class_t()
+{
+}
+
+template <class T>
+void class_t<T>::delete_instance(PyObject* obj) const
+{
+    delete downcast<T>(obj);
+}
+
+template <class T>
+PyObject* class_t<T>::call(PyObject* args, PyObject* keywords)
+{
+    reference<T> result(new T(this));
+    if (!this->initialize_instance(result.get(), args, keywords))
+        return 0;
+    else
+        return result.release();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_repr(PyObject* obj) const
+{
+    return downcast<T>(obj)->repr();
+}
+
+template <class T>
+int class_t<T>::instance_compare(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->compare(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_str(PyObject* obj) const
+{
+    return downcast<T>(obj)->str();
+}
+
+template <class T>
+long class_t<T>::instance_hash(PyObject* obj) const
+{
+    return downcast<T>(obj)->hash();
+}
+
+template <class T>
+int class_t<T>::instance_mapping_length(PyObject* obj) const
+{
+    return downcast<T>(obj)->length();
+}
+
+template <class T>
+int class_t<T>::instance_sequence_length(PyObject* obj) const
+{
+    return downcast<T>(obj)->length();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_mapping_subscript(PyObject* obj, PyObject* key) const
+{
+    return downcast<T>(obj)->get_subscript(key);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_sequence_item(PyObject* obj, int n) const
+{
+    ref key(to_python(n));
+    return downcast<T>(obj)->get_subscript(key.get());
+}
+
+template <class T>
+int class_t<T>::instance_sequence_ass_item(PyObject* obj, int n, PyObject* value) const
+{
+    ref key(to_python(n));
+    downcast<T>(obj)->set_subscript(key.get(), value);
+    return 0;
+}
+
+template <class T>
+int class_t<T>::instance_mapping_ass_subscript(PyObject* obj, PyObject* key, PyObject* value) const
+{
+    downcast<T>(obj)->set_subscript(key, value);
+    return 0;
+}
+
+bool BOOST_PYTHON_DECL adjust_slice_indices(PyObject* obj, int& start, int& finish);
+
+template <class T>
+PyObject* class_t<T>::instance_sequence_slice(PyObject* obj, int start, int finish) const
+{
+    if (!adjust_slice_indices(obj, start, finish))
+        return 0;
+    return downcast<T>(obj)->get_slice(start, finish);
+}
+
+template <class T>
+int class_t<T>::instance_sequence_ass_slice(PyObject* obj, int start, int finish, PyObject* value) const
+{
+    if (!adjust_slice_indices(obj, start, finish))
+        return -1;
+    downcast<T>(obj)->set_slice(start, finish, value);
+    return 0;
+}
+
+template <class T>
+PyObject* class_t<T>::instance_call(PyObject* obj, PyObject* args, PyObject* keywords) const
+{
+    return downcast<T>(obj)->call(args, keywords);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_getattr(PyObject* obj, const char* name) const
+{
+    return downcast<T>(obj)->getattr(name);
+}
+
+
+template <class T>
+int class_t<T>::instance_setattr(PyObject* obj, const char* name, PyObject* value) const
+{
+    return downcast<T>(obj)->setattr(name, value);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_add(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->add(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_subtract(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->subtract(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_multiply(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->multiply(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_divide(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->divide(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_remainder(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->remainder(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_divmod(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->divmod(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_power(PyObject* obj, PyObject* exponent, PyObject* modulus) const
+{
+    return downcast<T>(obj)->power(exponent, modulus);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_negative(PyObject* obj) const
+{
+    return downcast<T>(obj)->negative();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_positive(PyObject* obj) const
+{
+    return downcast<T>(obj)->positive();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_absolute(PyObject* obj) const
+{
+    return downcast<T>(obj)->absolute();
+}
+
+template <class T>
+int class_t<T>::instance_number_nonzero(PyObject* obj) const
+{
+    return downcast<T>(obj)->nonzero();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_invert(PyObject* obj) const
+{
+    return downcast<T>(obj)->invert();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_lshift(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->lshift(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_rshift(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->rshift(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_and(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->do_and(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_xor(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->do_xor(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_or(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->do_or(other);
+}
+
+template <class T>
+int class_t<T>::instance_number_coerce(PyObject* obj, PyObject** x, PyObject** y) const
+{
+    return downcast<T>(obj)->coerce(x, y);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_int(PyObject* obj) const
+{
+    return downcast<T>(obj)->as_int();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_long(PyObject* obj) const
+{
+    return downcast<T>(obj)->as_long();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_float(PyObject* obj) const
+{
+    return downcast<T>(obj)->as_float();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_oct(PyObject* obj) const
+{
+    return downcast<T>(obj)->oct();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_hex(PyObject* obj) const
+{
+    return downcast<T>(obj)->hex();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_add(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_add(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_subtract(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_subtract(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_multiply(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_multiply(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_divide(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_divide(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_remainder(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_remainder(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_power(PyObject* obj, PyObject* exponent, PyObject* modulus) const
+{
+    return downcast<T>(obj)->inplace_power(exponent, modulus);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_lshift(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_lshift(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_rshift(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_rshift(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_and(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_and(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_or(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_or(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_xor(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_xor(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_lt(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->lt(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_le(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->le(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_eq(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->eq(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_ne(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->ne(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_gt(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->gt(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_ge(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->ge(other);
+}
+
+namespace detail {
+  inline dictionary& class_base::dict()
+  {
+      return m_name_space;
+  }
+
+  inline tuple class_base::bases() const
+  {
+      return m_bases;
+  }
+}
+
+template <class T>
+PyObject* meta_class<T>::call(PyObject* args, PyObject* /*keywords*/)
+{
+    PyObject* name;
+    PyObject* bases;
+    PyObject* name_space;
+    
+    if (!PyArg_ParseTuple(args, const_cast<char*>("O!O!O!"),
+                          &PyString_Type, &name,
+                          &PyTuple_Type, &bases,
+                          &PyDict_Type, &name_space))
+    {
+        return 0;
+    }
+    
+    return as_object(
+        new class_t<T>(this, string(ref(name, ref::increment_count)),
+                  tuple(ref(bases, ref::increment_count)),
+                  dictionary(ref(name_space, ref::increment_count)))
+        );
+}
+
+namespace detail {
+  const string& setattr_string();
+  const string& getattr_string();
+  const string& delattr_string();
+
+  inline string class_base::name() const
+  {
+      return m_name;
+  }
+}
+
+
+}} // namespace boost::python
+#endif
--- a/include/boost/python/conversions.hpp
+++ b/include/boost/python/conversions.hpp
@@ -0,0 +1,415 @@
+//  (C) Copyright David Abrahams 2000. 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.
+//
+//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
+//  producing this work.
+//
+// Revision History:
+// 31 Jul 01  convert int/double to complex (Peter Bienstman)
+// 04 Mar 01  Fixed std::complex<> stuff to work with MSVC (David Abrahams)
+// 03 Mar 01  added: converters for [plain] char and std::complex
+//            (Ralf W. Grosse-Kunstleve)
+
+#ifndef METHOD_DWA122899_H_
+# define METHOD_DWA122899_H_
+
+# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/detail/none.hpp>
+# include <boost/python/detail/signatures.hpp>
+# include <boost/shared_ptr.hpp>
+# include <boost/python/errors.hpp>
+# include <string>
+
+# ifdef BOOST_MSVC6_OR_EARLIER
+#  pragma warning(push)
+#  pragma warning(disable:4275) // disable a bogus warning caused by <complex>
+# endif
+
+# include <complex>
+
+# ifdef BOOST_MSVC6_OR_EARLIER
+#  pragma warning(pop)
+# endif
+
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
+
+// This can be instantiated on an enum to provide the to_python/from_python
+// conversions, provided the values can fit in a long.
+template <class EnumType>
+class py_enum_as_int_converters
+{
+    friend EnumType from_python(PyObject* x, boost::python::type<EnumType>)
+    {
+        return static_cast<EnumType>(
+            from_python(x, boost::python::type<long>()));
+    }
+
+    friend EnumType from_python(PyObject* x, boost::python::type<const EnumType&>)
+    {
+        return static_cast<EnumType>(
+            from_python(x, boost::python::type<long>()));
+    }
+
+    friend PyObject* to_python(EnumType x)
+    {
+        return to_python(static_cast<long>(x));
+    }
+};
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
+
+namespace boost { namespace python {
+template <class EnumType> class enum_as_int_converters
+    : public BOOST_PYTHON_CONVERSION::py_enum_as_int_converters<EnumType> {};
+
+template <class P, class T> class wrapped_pointer;
+
+//#pragma warn_possunwant off
+inline void decref_impl(PyObject* p) { Py_DECREF(p); }
+inline void xdecref_impl(PyObject* p) { Py_XDECREF(p); }
+//#pragma warn_possunwant reset
+
+template <class T>
+inline void decref(T* p)
+{
+    char* const raw_p = reinterpret_cast<char*>(p);
+    char* const p_base = raw_p - offsetof(PyObject, ob_refcnt);
+    decref_impl(reinterpret_cast<PyObject*>(p_base));
+}
+
+template <class T>
+inline void xdecref(T* p)
+{
+    char* const raw_p = reinterpret_cast<char*>(p);
+    char* const p_base = raw_p - offsetof(PyObject, ob_refcnt);
+    xdecref_impl(reinterpret_cast<PyObject*>(p_base));
+}
+
+namespace detail {
+
+  void expect_complex(PyObject*);
+
+  template <class T>
+  std::complex<T> complex_from_python(PyObject* p, boost::python::type<T>)
+  {
+      if (PyInt_Check(p)) return std::complex<T>(PyInt_AS_LONG(p));
+      if (PyLong_Check(p)) return std::complex<T>(PyLong_AsDouble(p));
+      if (PyFloat_Check(p)) return std::complex<T>(PyFloat_AS_DOUBLE(p));
+
+      expect_complex(p);
+
+      return std::complex<T>(
+        static_cast<T>(PyComplex_RealAsDouble(p)),
+        static_cast<T>(PyComplex_ImagAsDouble(p)));
+  }
+
+  template <class T>
+  PyObject* complex_to_python(const std::complex<T>& sc) {
+      Py_complex pcc;
+      pcc.real = sc.real();
+      pcc.imag = sc.imag();
+      return PyComplex_FromCComplex(pcc);
+  }
+
+}
+
+}} // namespace boost::python
+
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
+//
+// Converters
+//
+PyObject* to_python(long);
+BOOST_PYTHON_DECL long from_python(PyObject* p, boost::python::type<long>);
+long from_python(PyObject* p, boost::python::type<const long&>);
+
+BOOST_PYTHON_DECL PyObject* to_python(unsigned long);
+BOOST_PYTHON_DECL unsigned long from_python(PyObject* p, boost::python::type<unsigned long>);
+unsigned long from_python(PyObject* p, boost::python::type<const unsigned long&>);
+
+PyObject* to_python(int);
+BOOST_PYTHON_DECL int from_python(PyObject*, boost::python::type<int>);
+int from_python(PyObject*, boost::python::type<const int&>);
+    
+BOOST_PYTHON_DECL PyObject* to_python(unsigned int);
+BOOST_PYTHON_DECL unsigned int from_python(PyObject*, boost::python::type<unsigned int>);
+unsigned int from_python(PyObject*, boost::python::type<const unsigned int&>);
+
+PyObject* to_python(short);
+BOOST_PYTHON_DECL short from_python(PyObject*, boost::python::type<short>);
+short from_python(PyObject*, boost::python::type<const short&>);
+    
+BOOST_PYTHON_DECL PyObject* to_python(unsigned short);
+BOOST_PYTHON_DECL unsigned short from_python(PyObject*, boost::python::type<unsigned short>);
+unsigned short from_python(PyObject*, boost::python::type<const unsigned short&>);
+
+BOOST_PYTHON_DECL PyObject* to_python(char);
+BOOST_PYTHON_DECL char from_python(PyObject*, boost::python::type<char>);
+char from_python(PyObject*, boost::python::type<const char&>);
+
+BOOST_PYTHON_DECL PyObject* to_python(signed char);
+BOOST_PYTHON_DECL signed char from_python(PyObject*, boost::python::type<signed char>);
+signed char from_python(PyObject*, boost::python::type<const signed char&>);
+
+BOOST_PYTHON_DECL PyObject* to_python(unsigned char);
+BOOST_PYTHON_DECL unsigned char from_python(PyObject*, boost::python::type<unsigned char>);
+unsigned char from_python(PyObject*, boost::python::type<const unsigned char&>);
+
+BOOST_PYTHON_DECL float from_python(PyObject*, boost::python::type<float>);
+BOOST_PYTHON_DECL double from_python(PyObject*, boost::python::type<double>);
+
+# if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
+PyObject* to_python(float);
+PyObject* to_python(double);
+# else
+BOOST_PYTHON_DECL PyObject* to_python(float);
+BOOST_PYTHON_DECL PyObject* to_python(double);
+# endif 
+float from_python(PyObject*, boost::python::type<const float&>);
+    
+double from_python(PyObject*, boost::python::type<const double&>);
+    
+PyObject* to_python(bool);
+BOOST_PYTHON_DECL bool from_python(PyObject*, boost::python::type<bool>);
+bool from_python(PyObject*, boost::python::type<const bool&>);
+
+BOOST_PYTHON_DECL PyObject* to_python(void);
+BOOST_PYTHON_DECL void from_python(PyObject*, boost::python::type<void>);
+
+PyObject* to_python(const char* s);
+BOOST_PYTHON_DECL const char* from_python(PyObject*, boost::python::type<const char*>);
+
+BOOST_PYTHON_DECL PyObject* to_python(const std::string& s);
+BOOST_PYTHON_DECL std::string from_python(PyObject*, boost::python::type<std::string>);
+std::string from_python(PyObject*, boost::python::type<const std::string&>);
+
+inline PyObject* to_python(const std::complex<float>& x)
+{
+    return boost::python::detail::complex_to_python<float>(x);
+}
+
+inline PyObject* to_python(const std::complex<double>& x)
+{
+    return boost::python::detail::complex_to_python<double>(x);
+}
+
+inline std::complex<double> from_python(PyObject* p,
+                                   boost::python::type<std::complex<double> >) {
+    return boost::python::detail::complex_from_python(p, boost::python::type<double>());
+}
+
+inline std::complex<double> from_python(PyObject* p,
+                                   boost::python::type<const std::complex<double>&>) {
+    return boost::python::detail::complex_from_python(p, boost::python::type<double>());
+}
+
+inline std::complex<float> from_python(PyObject* p,
+                                   boost::python::type<std::complex<float> >) {
+    return boost::python::detail::complex_from_python(p, boost::python::type<float>());
+}
+
+inline std::complex<float> from_python(PyObject* p,
+                                   boost::python::type<const std::complex<float>&>) {
+    return boost::python::detail::complex_from_python(p, boost::python::type<float>());
+}
+
+// For when your C++ function really wants to pass/return a PyObject*
+PyObject* to_python(PyObject*);
+PyObject* from_python(PyObject*, boost::python::type<PyObject*>);
+
+// Some standard conversions to/from smart pointer types. You can add your own
+// from these examples.  These are not generated using the friend technique from
+// wrapped_pointer because:
+//
+//      1. We want to be able to extend conversion to/from WrappedPointers using
+//      arbitrary smart pointer types.
+//
+//      2. It helps with compilation independence. This way, code which creates
+//      wrappers for functions accepting and returning smart_ptr<T> does not
+//      have to have already seen the invocation of wrapped_type<T>.
+//
+
+// Unfortunately, MSVC6 is so incredibly lame that we have to rely on the friend
+// technique to auto_generate standard pointer conversions for wrapped
+// types. This means that you need to write a non-templated function for each
+// specific smart_ptr<T> which you want to convert from_python. For example,
+//
+// namespace boost { namespace python {
+// #ifdef MUST_SUPPORT_MSVC
+//
+// MyPtr<Foo> from_python(PyObject*p, type<MyPtr<Foo> >)
+//     { return smart_ptr_from_python(p, type<MyPtr<Foo> >(), type<Foo>());}
+// }
+// 
+// MyPtr<Bar> from_python(PyObject*p, type<MyPtr<Bar> >)
+//     { return smart_ptr_from_python(p, type<MyPtr<Bar> >(), type<Bar>());}
+// 
+// ... // definitions for MyPtr<Baz>, MyPtr<Mumble>, etc.
+//
+// #else
+//
+// // Just once for all MyPtr<T>
+// template <class T>
+// MyPtr<T> from_python(PyObject*p, type<MyPtr<T> >)
+// {
+//    return smart_ptr_from_python(p, type<MyPtr<T> >(), type<T>());
+// }
+//
+// #endif
+// }} // namespace boost::python
+
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+template <class T>
+boost::shared_ptr<T> from_python(PyObject*p, boost::python::type<boost::shared_ptr<T> >)
+{
+    return smart_ptr_from_python(p, boost::python::type<boost::shared_ptr<T> >(), boost::python::type<T>());
+}
+#endif
+
+#if 0
+template <class T>
+PyObject* to_python(std::auto_ptr<T> p)
+{
+    return new boost::python::wrapped_pointer<std::auto_ptr<T>, T>(p);
+}
+
+template <class T>
+PyObject* to_python(boost::shared_ptr<T> p)
+{
+    return new boost::python::wrapped_pointer<boost::shared_ptr<T>, T>(p);
+}
+#endif
+
+//
+// inline implementations
+//
+
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
+inline PyObject* to_python(double d)
+{
+    return PyFloat_FromDouble(d);
+}
+
+inline PyObject* to_python(float f)
+{
+    return PyFloat_FromDouble(f);
+}
+#endif
+
+inline PyObject* to_python(long l)
+{
+    return PyInt_FromLong(l);
+}
+
+inline PyObject* to_python(int x)
+{
+    return PyInt_FromLong(x);
+}
+
+inline PyObject* to_python(short x)
+{
+    return PyInt_FromLong(x);
+}
+
+inline PyObject* to_python(bool b)
+{
+    return PyInt_FromLong(b);
+}
+
+inline PyObject* to_python(void)
+{
+    return boost::python::detail::none();
+}
+
+inline PyObject* to_python(const char* s)
+{
+    return PyString_FromString(s);
+}
+
+inline std::string from_python(PyObject* p, boost::python::type<const std::string&>)
+{
+    return from_python(p, boost::python::type<std::string>());
+}
+
+inline PyObject* to_python(PyObject* p)
+{
+    Py_INCREF(p);
+    return p;
+}
+
+inline PyObject* from_python(PyObject* p, boost::python::type<PyObject*>)
+{
+    return p;
+}
+
+inline const char* from_python(PyObject* p, boost::python::type<const char* const&>)
+{
+    return from_python(p, boost::python::type<const char*>());
+}
+
+inline double from_python(PyObject* p, boost::python::type<const double&>)
+{
+    return from_python(p, boost::python::type<double>());
+}
+
+inline float from_python(PyObject* p, boost::python::type<const float&>)
+{
+    return from_python(p, boost::python::type<float>());
+}
+
+inline int from_python(PyObject* p, boost::python::type<const int&>)
+{
+    return from_python(p, boost::python::type<int>());
+}
+
+inline short from_python(PyObject* p, boost::python::type<const short&>)
+{
+    return from_python(p, boost::python::type<short>());
+}
+
+inline long from_python(PyObject* p, boost::python::type<const long&>)
+{
+    return from_python(p, boost::python::type<long>());
+}
+
+inline bool from_python(PyObject* p, boost::python::type<const bool&>)
+{
+    return from_python(p, boost::python::type<bool>());
+}
+
+inline unsigned int from_python(PyObject* p, boost::python::type<const unsigned int&>)
+{
+    return from_python(p, boost::python::type<unsigned int>());
+}
+
+inline unsigned short from_python(PyObject* p, boost::python::type<const unsigned short&>)
+{
+    return from_python(p, boost::python::type<unsigned short>());
+}
+
+inline char from_python(PyObject* p, boost::python::type<const char&>)
+{
+    return from_python(p, boost::python::type<char>());
+}
+
+inline signed char from_python(PyObject* p, boost::python::type<const signed char&>)
+{
+    return from_python(p, boost::python::type<signed char>());
+}
+
+inline unsigned char from_python(PyObject* p, boost::python::type<const unsigned char&>)
+{
+    return from_python(p, boost::python::type<unsigned char>());
+}
+
+inline unsigned long from_python(PyObject* p, boost::python::type<const unsigned long&>)
+{
+    return from_python(p, boost::python::type<unsigned long>());
+}
+
+
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
+
+#endif // METHOD_DWA122899_H_
--- 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. 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 ARG_FROM_PYTHON_DWA2002127_HPP
+# define ARG_FROM_PYTHON_DWA2002127_HPP
+
+# include <boost/python/converter/from_python.hpp>
+# include <boost/python/detail/wrap_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/if.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()(PyObject*) 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()(PyObject*) 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()(PyObject*) 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<
+        typename boost::add_const<T>::type
+    >::type result_type;
+    
+    arg_rvalue_from_python(PyObject*);
+    bool convertible() const;
+    
+    result_type operator()(PyObject*);
+    
+ private:
+    rvalue_from_python_data<result_type> m_data;
+};
+
+
+// ==================
+
+// 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()(PyObject*);
+ private:
+    typedef boost::python::arg_from_python<typename T::type> base;
+};
+
+
+// ==================
+
+// This metafunction selects the appropriate arg_from_python converter
+// type for an argument of type T.
+template <class T>
+struct select_arg_from_python
+{
+    BOOST_STATIC_CONSTANT(
+        bool, obj_mgr = is_object_manager<T>::value);
+    
+    BOOST_STATIC_CONSTANT(
+        bool, obj_mgr_ref = is_reference_to_object_manager<T>::value);
+    
+    BOOST_STATIC_CONSTANT(
+        bool, ptr = is_pointer<T>::value);
+    
+    BOOST_STATIC_CONSTANT(
+        bool, ptr_cref
+            = boost::python::detail::is_reference_to_pointer<T>::value
+            && boost::python::detail::is_reference_to_const<T>::value
+            && !boost::python::detail::is_reference_to_volatile<T>::value);
+    
+    
+    BOOST_STATIC_CONSTANT(
+        bool, ref =
+        boost::python::detail::is_reference_to_non_const<T>::value
+        || boost::python::detail::is_reference_to_volatile<T>::value);
+
+    BOOST_STATIC_CONSTANT(
+        bool, back_ref =
+        boost::python::is_back_reference<T>::value);
+
+    typedef typename mpl::if_c<
+        obj_mgr
+        , object_manager_value_arg_from_python<T>
+        , typename mpl::if_c<
+            obj_mgr_ref
+            , object_manager_ref_arg_from_python<T>
+            , typename mpl::if_c<
+                ptr
+                , pointer_arg_from_python<T>
+                , typename mpl::if_c<
+                    ptr_cref
+                    , pointer_cref_arg_from_python<T>
+                    , typename mpl::if_c<
+                        ref
+                        , reference_arg_from_python<T>
+                        , typename mpl::if_c<
+                            back_ref
+                            , back_reference_arg_from_python<T>
+                            , arg_rvalue_from_python<T>
+                          >::type
+                      >::type
+                  >::type
+              >::type
+          >::type
+      >::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()(PyObject* p) const
+{
+    return (p == 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()(PyObject* p) const
+{
+    return (p == 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()(PyObject*) 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))
+{
+}
+
+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()(PyObject* p)
+{
+    if (m_data.stage1.construct != 0)
+        m_data.stage1.construct(p, &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)
+{
+}
+
+template <class T>
+inline T
+back_reference_arg_from_python<T>::operator()(PyObject* x)
+{
+    return T(x, base::operator()(x));
+}
+
+}}} // 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,247 @@
+// Copyright David Abrahams 2002. 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 ARG_TO_PYTHON_DWA200265_HPP
+# define ARG_TO_PYTHON_DWA200265_HPP
+
+# include <boost/python/ptr.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/to_python_indirect.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/type_traits/composite_traits.hpp>
+# include <boost/type_traits/function_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/base_type_traits.hpp>
+// Bring in specializations
+# include <boost/python/converter/builtin_converters.hpp>
+# include <boost/python/tag.hpp>
+# include <boost/python/object/function_handle.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+template <class T> struct is_object_manager;
+
+namespace detail
+{
+  BOOST_PYTHON_DECL void throw_no_class_registered();
+
+  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 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
+  {
+      // Special handling for char const[N]; interpret them as char
+      // const* for the sake of conversion
+      BOOST_STATIC_CONSTANT(
+          bool, is_string = python::detail::is_string_literal<T const>::value);
+      
+      BOOST_STATIC_CONSTANT(
+          bool, function = is_function<T>::value | python::detail::is_pointer_to_function<T>::value | is_member_function_pointer<T>::value);
+      
+      BOOST_STATIC_CONSTANT(
+          bool, manager = is_object_manager<T>::value);
+      
+      BOOST_STATIC_CONSTANT(
+          bool, ptr = is_pointer<T>::value);
+      
+      BOOST_STATIC_CONSTANT(
+          bool, ref_wrapper = is_reference_wrapper<T>::value);
+
+      BOOST_STATIC_CONSTANT(
+          bool, ptr_wrapper = is_pointer_wrapper<T>::value);
+
+      typedef typename unwrap_reference<T>::type unwrapped_referent;
+      typedef typename unwrap_pointer<T>::type unwrapped_ptr;
+
+      typedef typename mpl::if_c<
+          is_string
+          , arg_to_python<char const*>
+          , typename mpl::if_c<
+              function
+              , function_arg_to_python<T>
+              , typename mpl::if_c<
+                  manager
+                  , object_manager_arg_to_python<T>
+                  , typename mpl::if_c<
+                      ptr
+                      , pointer_deep_arg_to_python<T>
+                      , typename mpl::if_c<
+                          ptr_wrapper
+                          , pointer_shallow_arg_to_python<unwrapped_ptr>
+                          , typename mpl::if_c<
+                              ref_wrapper
+                              , reference_arg_to_python<unwrapped_referent>
+                              , value_arg_to_python<T>
+                            >::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;
+      if (!convert.convertible())
+          throw_no_class_registered();
+      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 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;
+      if (!convert.convertible())
+          throw_no_class_registered();
+      return x ? convert(x) : python::detail::none();
+  }
+}
+
+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,35 @@
+// Copyright David Abrahams 2002. 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 ARG_TO_PYTHON_BASE_DWA200237_HPP
+# define ARG_TO_PYTHON_BASE_DWA200237_HPP
+# include <boost/python/converter/to_python_function_type.hpp>
+# include <boost/python/detail/wrap_python.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/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,123 @@
+// Copyright David Abrahams 2002. 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 BUILTIN_CONVERTERS_DWA2002124_HPP
+# define BUILTIN_CONVERTERS_DWA2002124_HPP
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/detail/none.hpp>
+# include <boost/python/handle.hpp>
+# include <string>
+# include <complex>
+
+// 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
+  {
+      static bool convertible() { return true; }
+  };
+}
+
+// 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, PyInt_FromLong(x))
+
+// Bool is not signed.
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(bool, PyInt_FromLong(x))
+
+// 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 LONG_LONG, PyLong_FromLongLong(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned 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_FromString(x.c_str()))
+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()))
+
+namespace converter
+{ 
+
+  void initialize_builtin_converters();
+
+}
+
+}} // namespace boost::python::converter
+
+#endif // BUILTIN_CONVERTERS_DWA2002124_HPP
--- a/include/boost/python/converter/callback.hpp
+++ b/include/boost/python/converter/callback.hpp
@@ -0,0 +1,278 @@
+// Copyright David Abrahams 2002. 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 CALLBACK_DWA2002228_HPP
+# define CALLBACK_DWA2002228_HPP
+
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/converter/to_python_function.hpp>
+# include <boost/python/converter/pointee_to_python_function.hpp>
+# include <boost/python/converter/from_python.hpp>
+# include <boost/mpl/select_if.hpp>
+# include <boost/python/converter/callback_to_python_base.hpp>
+# include <boost/python/converter/callback_from_python_base.hpp>
+# include <boost/python/converter/builtin_converters.hpp>
+# include <boost/python/to_python_indirect.hpp>
+# include <boost/python/detail/none.hpp>
+# include <boost/python/ptr.hpp>
+# include <boost/python/errors.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+namespace detail
+{
+  template <class T>
+  struct pointer_callback_from_python
+  {
+      pointer_callback_from_python();
+      T operator()(PyObject*) const;
+  };
+  
+  template <class T>
+  struct reference_callback_from_python
+  {
+      reference_callback_from_python();
+      T operator()(PyObject*) const;
+  };
+  
+  template <class T>
+  struct rvalue_callback_from_python
+  {
+      rvalue_callback_from_python();
+      T const& operator()(PyObject*);
+   private:
+      rvalue_data<T> m_data;
+  };
+  
+  template <class T>
+  struct select_callback_from_python
+  {
+      BOOST_STATIC_CONSTANT(
+          bool, ptr = is_pointer<T>::value);
+    
+      BOOST_STATIC_CONSTANT(
+          bool, ref = is_reference<T>::value);
+
+      typedef typename mpl::select_if_c<
+          ptr
+          , pointer_callback_from_python<T>
+          , typename mpl::select_if_c<
+              ref
+              , reference_callback_from_python<T>
+              , rvalue_callback_from_python<T>
+            >::type
+          >::type type;
+  };
+
+
+  template <class T>
+  struct reference_callback_to_python : callback_to_python_holder
+  {
+      reference_callback_to_python(T& x);
+   private:
+      static PyObject* get_object(T& x);
+  };
+
+  template <class T>
+  struct value_callback_to_python : callback_to_python_base
+  {
+      // Throw an exception if the conversion can't succeed
+      value_callback_to_python(T const&);
+  };
+
+  template <class Ptr>
+  struct pointer_deep_callback_to_python : callback_to_python_base
+  {
+      // Throw an exception if the conversion can't succeed
+      pointer_deep_callback_to_python(Ptr);
+  };
+
+  template <class Ptr>
+  struct pointer_shallow_callback_to_python : callback_to_python_holder
+  {
+      // Throw an exception if the conversion can't succeed
+      pointer_shallow_callback_to_python(Ptr);
+   private:
+      static PyObject* get_object(Ptr p);
+  };
+
+  template <class T>
+  struct select_callback_to_python
+  {
+      BOOST_STATIC_CONSTANT(
+          bool, ptr = is_pointer<T>::value);
+      
+      BOOST_STATIC_CONSTANT(
+          bool, ref_wrapper = is_reference_wrapper<T>::value);
+
+      BOOST_STATIC_CONSTANT(
+          bool, ptr_wrapper = is_pointer_wrapper<T>::value);
+
+      typedef typename unwrap_reference<T>::type unwrapped_referent;
+      typedef typename unwrap_pointer<T>::type unwrapped_ptr;
+
+      typedef typename mpl::select_if_c<
+          ptr
+          , pointer_deep_callback_to_python<T>
+          , typename mpl::select_if_c<
+              ptr_wrapper
+              , pointer_shallow_callback_to_python<unwrapped_ptr>
+              , typename mpl::select_if_c<
+                  ref_wrapper
+                  , reference_callback_to_python<unwrapped_referent>
+                  , value_callback_to_python<T>
+                >::type
+            >::type
+        >::type type;
+  };
+}
+
+template <class T>
+struct callback_from_python
+    : detail::select_callback_from_python<T>::type
+{
+    typedef T result_type;
+};
+
+struct void_result
+{
+ private: 
+    void_result() {}
+    void operator=(void_result const&);
+    
+    // I would prefer to make this completely untouchable, but few
+    // compilers support template friends
+# if 0
+    void_result(void_result const&);
+# endif
+    friend struct callback_from_python<void>;
+};
+
+// Specialization as a convenience for call and call_method
+template <>
+struct callback_from_python<void>
+{
+    typedef void_result result_type;
+    result_type operator()(PyObject* x) const
+    {
+        Py_DECREF(expect_non_null(x));
+        return result_type();
+    }
+};
+
+template <class T>
+struct callback_to_python
+    : detail::select_callback_to_python<T>::type
+{
+    typedef typename detail::select_callback_to_python<T>::type base;
+ public: // member functions
+    // Throw an exception if the conversion can't succeed
+    callback_to_python(T const& x);
+};
+
+// Convenience macros for call<> and call_method<> code generation
+# define BOOST_PYTHON_CALLBACK_TO_PYTHON_GET(index,ignored)     \
+    converter::callback_to_python<BOOST_PP_CAT(A,index)>(       \
+        BOOST_PP_CAT(a,index)).get()
+
+# define BOOST_PYTHON_ARG_STRING(nargs)                         \
+    "(" BOOST_PP_REPEAT(nargs,BOOST_PYTHON_PROJECT_2ND,"O") ")"
+
+//
+// Implementations
+//
+namespace detail
+{
+  template <class T>
+  inline rvalue_callback_from_python<T>::rvalue_callback_from_python()
+      : m_data(rvalue_from_python_chain<T>::value)
+  {
+      throw_if_not_registered(m_data.stage1);
+  }
+  
+  template <class T>
+  inline T const& rvalue_callback_from_python<T>::operator()(PyObject* obj)
+  {
+      return *(T*)convert_rvalue(obj, m_data.stage1, m_data.storage.bytes);
+  }
+
+  BOOST_PYTHON_DECL void throw_no_class_registered();
+
+  template <class T>
+  inline reference_callback_from_python<T>::reference_callback_from_python()
+  {
+      detail::throw_if_not_registered(lvalue_from_python_chain<T,true>::value);
+  }
+  
+  template <class T>
+  inline T reference_callback_from_python<T>::operator()(PyObject* obj) const
+  {
+      return python::detail::void_ptr_to_reference(
+          callback_convert_reference(obj, lvalue_from_python_chain<T,true>::value)
+          , (T(*)())0);
+  }
+
+  template <class T>
+  inline pointer_callback_from_python<T>::pointer_callback_from_python()
+  {
+      detail::throw_if_not_registered(lvalue_from_python_chain<T,true>::value);
+  }
+  
+  template <class T>
+  inline T pointer_callback_from_python<T>::operator()(PyObject* obj) const
+  {
+      return T(callback_convert_pointer(obj, lvalue_from_python_chain<T,true>::value));
+  }
+
+  template <class T>
+  inline value_callback_to_python<T>::value_callback_to_python(T const& x)
+      : callback_to_python_base(&x, to_python_function<T>::value)
+  {
+  }
+
+  template <class Ptr>
+  inline pointer_deep_callback_to_python<Ptr>::pointer_deep_callback_to_python(Ptr x)
+      : callback_to_python_base(x, pointee_to_python_function<Ptr>::value)
+  {
+  }
+
+  template <class T>
+  inline PyObject* reference_callback_to_python<T>::get_object(T& x)
+  {
+      to_python_indirect<T&,python::detail::make_reference_holder> convert;
+      if (!convert.convertible())
+          throw_no_class_registered();
+      return convert(x);
+  }
+
+  template <class T>
+  inline reference_callback_to_python<T>::reference_callback_to_python(T& x)
+      : callback_to_python_holder(get_object(x))
+  {
+  }
+
+  template <class Ptr>
+  inline pointer_shallow_callback_to_python<Ptr>::pointer_shallow_callback_to_python(Ptr x)
+      : callback_to_python_holder(get_object(x))
+  {}
+
+  template <class Ptr>
+  inline PyObject* pointer_shallow_callback_to_python<Ptr>::get_object(Ptr x)
+  {
+      to_python_indirect<Ptr,python::detail::make_reference_holder> convert;
+      if (!convert.convertible())
+          throw_no_class_registered();
+      return x ? convert(x) : python::detail::none();
+  }
+}
+
+template <class T>
+inline callback_to_python<T>::callback_to_python(T const& x)
+    : base(x)
+{}
+
+}}} // namespace boost::python::converter
+
+#endif // CALLBACK_DWA2002228_HPP
--- a/include/boost/python/converter/callback_from_python_base.hpp
+++ b/include/boost/python/converter/callback_from_python_base.hpp
@@ -0,0 +1,25 @@
+// Copyright David Abrahams 2002. 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 CALLBACK_FROM_PYTHON_BASE_DWA200237_HPP
+# define CALLBACK_FROM_PYTHON_BASE_DWA200237_HPP
+
+namespace boost { namespace python { namespace converter { 
+
+namespace detail
+{
+
+  // Throw an exception
+  BOOST_PYTHON_DECL void throw_if_not_registered(rvalue_stage1_data const&);
+  BOOST_PYTHON_DECL void* convert_rvalue(PyObject*, rvalue_stage1_data& data, void* storage);
+  
+  BOOST_PYTHON_DECL void throw_if_not_registered(lvalue_from_python_registration*const&);
+  BOOST_PYTHON_DECL void* callback_convert_reference(PyObject*, lvalue_from_python_registration*const&);
+  BOOST_PYTHON_DECL void* callback_convert_pointer(PyObject*, lvalue_from_python_registration*const&);
+}
+
+}}} // namespace boost::python::converter
+
+#endif // CALLBACK_FROM_PYTHON_BASE_DWA200237_HPP
--- a/include/boost/python/converter/callback_to_python_base.hpp
+++ b/include/boost/python/converter/callback_to_python_base.hpp
@@ -0,0 +1,45 @@
+// Copyright David Abrahams 2002. 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 CALLBACK_TO_PYTHON_BASE_DWA200237_HPP
+# define CALLBACK_TO_PYTHON_BASE_DWA200237_HPP
+# include <boost/python/converter/to_python_function_type.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/reference.hpp>
+
+namespace boost { namespace python { namespace converter {
+
+namespace detail
+{
+  struct callback_to_python_holder
+  {
+      callback_to_python_holder(PyObject* obj);
+      inline PyObject* get() const;
+   private:
+      ref m_held;
+  };
+  
+  struct BOOST_PYTHON_DECL callback_to_python_base : callback_to_python_holder
+  {
+      callback_to_python_base(void const volatile* source, to_python_function_t);
+  };
+
+  //
+  // implmentation
+  //
+  inline callback_to_python_holder::callback_to_python_holder(PyObject* obj)
+      : m_held(obj)
+  {
+  }
+  
+  inline PyObject* callback_to_python_holder::get() const
+  {
+      return m_held.get();
+  }
+}
+
+}}} // namespace boost::python::converter
+
+#endif // CALLBACK_TO_PYTHON_BASE_DWA200237_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,18 @@
+// Copyright David Abrahams 2002. 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 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/convertible_function.hpp
+++ b/include/boost/python/converter/convertible_function.hpp
@@ -1,24 +1,15 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
+// Copyright David Abrahams 2002. 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
+#ifndef CONVERTIBLE_FUNCTION_DWA200278_HPP
+# define CONVERTIBLE_FUNCTION_DWA200278_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;
-};
-
+typedef void* (*convertible_function)(PyObject*);
+    
 }}} // namespace boost::python::converter

-#endif // SOURCE_HOLDER_DWA20011215_HPP
+#endif // CONVERTIBLE_FUNCTION_DWA200278_HPP
--- a/include/boost/python/converter/find_from_python.hpp
+++ b/include/boost/python/converter/find_from_python.hpp
@@ -0,0 +1,29 @@
+// Copyright David Abrahams 2002. 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 FIND_FROM_PYTHON_DWA2002223_HPP
+# define FIND_FROM_PYTHON_DWA2002223_HPP
+
+# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/converter/from_python_stage1_data.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct lvalue_from_python_registration;
+struct rvalue_from_python_registration;
+
+BOOST_PYTHON_DECL void* find(
+    PyObject* source, lvalue_from_python_registration const*);
+
+BOOST_PYTHON_DECL rvalue_stage1_data find(
+    PyObject* source, rvalue_from_python_registration const*);
+
+BOOST_PYTHON_DECL rvalue_from_python_registration const* find_chain(
+    PyObject* source, rvalue_from_python_registration const*);
+
+}}} // namespace boost::python::converter
+
+#endif // FIND_FROM_PYTHON_DWA2002223_HPP
--- a/include/boost/python/converter/from_python.hpp
+++ b/include/boost/python/converter/from_python.hpp
@@ -0,0 +1,43 @@
+// Copyright David Abrahams 2002. 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 FIND_FROM_PYTHON_DWA2002223_HPP
+# define FIND_FROM_PYTHON_DWA2002223_HPP
+
+# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/converter/rvalue_from_python_data.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct registration;
+struct rvalue_from_python_chain;
+
+BOOST_PYTHON_DECL void* get_lvalue_from_python(
+    PyObject* source, registration const&);
+
+BOOST_PYTHON_DECL rvalue_from_python_chain const* implicit_conversion_chain(
+    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/from_python_data.hpp
+++ b/include/boost/python/converter/from_python_data.hpp
@@ -0,0 +1,129 @@
+// Copyright David Abrahams 2002. 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 FROM_PYTHON_AUX_DATA_DWA2002128_HPP
+# define FROM_PYTHON_AUX_DATA_DWA2002128_HPP
+
+# include <boost/python/detail/char_array.hpp>
+# include <boost/mpl/select_if.hpp>
+# include <boost/type_traits/same_traits.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/static_assert.hpp>
+# include <boost/python/converter/from_python_stage1_data.hpp>
+# include <boost/type_traits/composite_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/python/detail/destroy.hpp>
+# include <boost/preprocessor/list/for_each_i.hpp>
+# include <boost/preprocessor/tuple/to_list.hpp>
+# include <boost/preprocessor/cat.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+namespace detail
+{
+  template <class T> struct referent_size;
+  
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+  
+  template <class T>
+  struct referent_size<T&>
+  {
+      BOOST_STATIC_CONSTANT(
+          std::size_t, value = sizeof(T));
+  };
+
+# else
+
+  template <class T> struct referent_size
+  {
+      static T f();
+      BOOST_STATIC_CONSTANT(std::size_t, value = sizeof(f()));
+  };
+  
+# endif
+  struct alignment_dummy;
+  typedef void (*function_ptr)();
+  typedef int (alignment_dummy::*member_ptr);
+  typedef int (alignment_dummy::*member_function_ptr)();
+
+# define BOOST_PYTHON_ALIGNMENT_TYPES BOOST_PP_TUPLE_TO_LIST( \
+        11, ( \
+        char, short, int, long, float, double, long double \
+        , void*, function_ptr, member_ptr, member_function_ptr))
+
+# define BOOST_PYTHON_CHOOSE_LOWER_SIZE(R,P,I,T) \
+        typename mpl::select_if_c< \
+           sizeof(T) <= target, T, char>::type BOOST_PP_CAT(t,I);
+           
+# define BOOST_PYTHON_CHOOSE_T(R,P,I,T) T BOOST_PP_CAT(t,I);
+           
+  template <std::size_t target>
+  union lower_size
+  {
+      BOOST_PP_LIST_FOR_EACH_I(
+          BOOST_PYTHON_CHOOSE_LOWER_SIZE
+          , ignored, BOOST_PYTHON_ALIGNMENT_TYPES)
+  };
+
+  template <class Align, std::size_t size>
+  union aligned_storage
+  {
+      Align align;
+      char bytes[size];
+  };
+
+  template <class Reference>
+  struct referent_storage
+  {
+      typedef lower_size<referent_size<Reference>::value> align_t;
+      typedef aligned_storage<align_t,referent_size<Reference>::value> type;
+  };
+}
+
+template <class T>
+struct rvalue_base_data
+{
+    rvalue_stage1_data stage1;
+    
+    typename detail::referent_storage<
+        typename add_reference<T>::type
+    >::type storage;
+};
+
+template <class T>
+struct rvalue_data : rvalue_base_data<T>
+{
+    rvalue_data(rvalue_stage1_data const&);
+    rvalue_data(void*);
+    ~rvalue_data();
+ private:
+    typedef typename add_reference<typename add_cv<T>::type>::type ref_type;
+};
+
+//
+// Implementataions
+//
+template <class T>
+inline rvalue_data<T>::rvalue_data(rvalue_stage1_data const& stage1)
+{
+    this->stage1 = stage1;
+}
+
+template <class T>
+inline rvalue_data<T>::rvalue_data(void* convertible)
+{
+    this->stage1.convertible = convertible;
+}
+
+template <class T>
+inline rvalue_data<T>::~rvalue_data()
+{
+    if (this->stage1.convertible == this->storage.bytes)
+        python::detail::destroy_reference<ref_type>(this->storage.bytes);
+}
+
+}}} // namespace boost::python::converter
+
+#endif // FROM_PYTHON_AUX_DATA_DWA2002128_HPP
--- a/include/boost/python/converter/from_python_function.hpp
+++ b/include/boost/python/converter/from_python_function.hpp
@@ -0,0 +1,18 @@
+// Copyright David Abrahams 2002. 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 FROM_PYTHON_FUNCTION_DWA2002128_HPP
+# define FROM_PYTHON_FUNCTION_DWA2002128_HPP
+
+# include <boost/python/detail/wrap_python.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct rvalue_stage1_data;
+typedef void (*constructor_function)(PyObject* source, rvalue_stage1_data*);
+
+}}} // namespace boost::python::converter
+
+#endif // FROM_PYTHON_FUNCTION_DWA2002128_HPP
--- a/include/boost/python/converter/from_python_stage1_data.hpp
+++ b/include/boost/python/converter/from_python_stage1_data.hpp
@@ -0,0 +1,21 @@
+// Copyright David Abrahams 2002. 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 FROM_PYTHON_STAGE1_DATA_DWA2002223_HPP
+# define FROM_PYTHON_STAGE1_DATA_DWA2002223_HPP
+
+# include <boost/python/converter/from_python_function.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct rvalue_stage1_data
+{
+    void* convertible;
+    constructor_function construct;
+};
+
+}}} // namespace boost::python::converter
+
+#endif // FROM_PYTHON_STAGE1_DATA_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,57 @@
+// Copyright David Abrahams 2002. 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 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>
+
+namespace boost { namespace python { namespace converter { 
+
+template <class Source, class Target>
+struct implicit
+{
+    static void* convertible(PyObject* obj)
+    {
+        // Find a converter chain 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 const_cast<rvalue_from_python_chain*>(
+            converter::implicit_conversion_chain(obj, registered<Source>::converters));
+    }
+      
+    static void construct(PyObject* obj, rvalue_from_python_stage1_data* data)
+    {
+        // This is the chain we got from the convertible step
+        rvalue_from_python_chain const* chain
+            = static_cast<rvalue_from_python_chain*>(data->convertible);
+
+        // Call the convertible function again
+        rvalue_from_python_data<Source> intermediate_data(chain->convertible(obj));
+          
+        // Use the result to construct the source type if the first
+        // converter was an rvalue converter.
+        if (chain->construct != 0)
+            chain->construct(obj, &intermediate_data.stage1);
+          
+        void* storage = ((rvalue_from_python_storage<Target>*)data)->storage.bytes;
+#   if !defined(BOOST_MSVC) || _MSC_FULL_VER != 13012108 // vc7.01 alpha workaround
+        new (storage) Target(*static_cast<Source*>(intermediate_data.stage1.convertible));
+#   else
+        Target x(*static_cast<Source*>(intermediate_data.stage1.convertible));
+        new (storage) Target(x);
+#   endif 
+
+        // record successful construction
+        data->convertible = storage;
+          
+    }
+};
+
+}}} // namespace boost::python::converter
+
+#endif // IMPLICIT_DWA2002326_HPP
--- a/include/boost/python/converter/lvalue_from_python_chain.hpp
+++ b/include/boost/python/converter/lvalue_from_python_chain.hpp
@@ -0,0 +1,70 @@
+// Copyright David Abrahams 2002. 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 LVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP
+# define LVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP
+
+# include <boost/python/converter/pointer_type_id.hpp>
+# include <boost/python/converter/registry.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+// Given T == U*cv&, T == U*, or T == U&, lvalue_from_python_chain<T>
+// declares a "templated global reference" to the lvalue from_python
+// converter chain for U. The optional bool second argument callback,
+// when true, removes special treatment for T == U*cv& so that the
+// converter for U* is found.
+namespace detail
+{
+  template <class T>
+  struct ptr_or_ptr_ref_lvalue_from_python_chain
+  {
+      static lvalue_from_python_registration*const& value;
+  };
+    
+  template <class T>
+  lvalue_from_python_registration*const&
+  ptr_or_ptr_ref_lvalue_from_python_chain<T>::value
+     = registry::lvalue_converters(pointer_type_id<T>());
+
+  template <class T>
+  struct ref_lvalue_from_python_chain
+  {
+      static lvalue_from_python_registration*const& value;
+  };
+
+  template <class T>
+  lvalue_from_python_registration*const&
+  ref_lvalue_from_python_chain<T>::value
+     = registry::lvalue_converters(undecorated_type_id<T>());
+
+  template <class T, bool callback>
+  struct select_lvalue_from_python_chain
+  {
+      BOOST_STATIC_CONSTANT(
+          bool, ptr
+          = !callback && boost::python::detail::is_reference_to_pointer<T>::value
+            || is_pointer<T>::value);
+
+      typedef typename add_reference<typename add_cv<T>::type>::type normalized;
+
+      typedef typename mpl::select_if_c<
+          ptr
+          , ptr_or_ptr_ref_lvalue_from_python_chain<normalized>
+          , ref_lvalue_from_python_chain<normalized>
+          >::type type;
+  };
+}
+
+template <class T, bool callback = false>
+struct lvalue_from_python_chain
+    : detail::select_lvalue_from_python_chain<T,callback>::type
+{
+};
+
+}}} // namespace boost::python::converter
+
+#endif // LVALUE_FROM_PYTHON_CHAIN_DWA200237_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,116 @@
+// Copyright David Abrahams 2002. 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 OBJ_MGR_ARG_FROM_PYTHON_DWA2002628_HPP
+# define OBJ_MGR_ARG_FROM_PYTHON_DWA2002628_HPP
+
+# include <boost/python/detail/wrap_python.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()(PyObject*) 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()(PyObject*) 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()(PyObject* x) const
+{
+    return T(python::detail::borrowed_reference(x));
+}
+
+template <class Ref>
+inline object_manager_ref_arg_from_python<Ref>::object_manager_ref_arg_from_python(PyObject* x)
+{
+    python::detail::construct_referent<Ref>(&m_result.bytes, python::detail::borrowed_reference(x));
+}
+
+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()(PyObject*) 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,232 @@
+// Copyright David Abrahams 2002. 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 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>
+
+// 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
+{
+    BOOST_STATIC_CONSTANT(
+        bool, value = object_manager_traits<T>::is_specialized);
+};
+
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template <class T>
+struct is_reference_to_object_manager
+{
+    BOOST_STATIC_CONSTANT(bool, value = 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_c<
+          is_object_manager<T>::value
+          , 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
+  {
+      BOOST_STATIC_CONSTANT(bool, value = 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)
+          )
+        );
+  };
+}
+
+template <class T>
+struct is_reference_to_object_manager
+{
+    typedef typename mpl::if_c<
+        is_reference<T>::value
+        , detail::is_reference_to_object_manager_ref<T>
+        , detail::is_reference_to_object_manager_nonref<T>
+    > chooser;
+
+    BOOST_STATIC_CONSTANT(bool, value = chooser::type::value);
+};
+# endif 
+
+}}} // namespace boost::python::converter
+
+#endif // OBJECT_MANAGER_DWA2002614_HPP
--- a/include/boost/python/converter/pointee_to_python_function.hpp
+++ b/include/boost/python/converter/pointee_to_python_function.hpp
@@ -0,0 +1,51 @@
+// Copyright David Abrahams 2002. 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 POINTEE_TO_PYTHON_FUNCTION_DWA2002128_HPP
+# define POINTEE_TO_PYTHON_FUNCTION_DWA2002128_HPP
+
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/converter/registry.hpp>
+# include <boost/python/converter/to_python_function_type.hpp>
+# include <boost/python/converter/pointer_type_id.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+// pointee_to_python_function --
+//
+// essentially a "templated global reference" which holds the
+// converter for converting a type to Python by-value. We "normalize"
+// T by adding "const volatile&" so that fewer global variables and
+// associated static initializations are generated.
+namespace detail
+{
+  template <class T>
+  struct pointee_to_python_function_base
+  {
+      static to_python_function_t const& value;
+  };
+  
+  template <class T>
+  to_python_function_t const&
+  pointee_to_python_function_base<T>::value
+        = converter::registry::get_to_python_function(pointer_type_id<T>());
+}
+
+template <class T>
+struct pointee_to_python_function
+    : detail::pointee_to_python_function_base<
+        typename add_reference<
+          typename add_cv<T>::type
+        >::type
+      >
+{
+};
+
+}}} // namespace boost::python::converter
+
+#endif // POINTEE_TO_PYTHON_FUNCTION_DWA2002128_HPP
--- a/include/boost/python/converter/pointer_type_id.hpp
+++ b/include/boost/python/converter/pointer_type_id.hpp
@@ -0,0 +1,69 @@
+// Copyright David Abrahams 2002. 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 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,42 @@
+// Copyright David Abrahams 2002. 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 PYOBJECT_TRAITS_DWA2002720_HPP
+# define PYOBJECT_TRAITS_DWA2002720_HPP
+
+# include <boost/python/detail/wrap_python.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,36 @@
+// Copyright David Abrahams 2002. 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 PYOBJECT_TYPE_DWA2002720_HPP
+# define PYOBJECT_TYPE_DWA2002720_HPP
+
+# include <boost/python/detail/wrap_python.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_arg_from_python.hpp
+++ b/include/boost/python/converter/pytype_arg_from_python.hpp
@@ -0,0 +1,99 @@
+// Copyright David Abrahams 2002. 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 PYTYPE_ARG_FROM_PYTHON_DWA2002628_HPP
+# define PYTYPE_ARG_FROM_PYTHON_DWA2002628_HPP
+
+# include <boost/python/detail/wrap_python.hpp>
+
+//
+// arg_from_python converters for Python type wrappers, to be used as
+// base classes for specializations.
+//
+namespace boost { namespace python { namespace converter { 
+
+template <PyTypeObject* python_type>
+struct pytype_arg_from_python
+{
+    pytype_arg_from_python(PyObject*);
+    bool convertible() const;
+ private:
+    PyObject* m_src;
+};
+
+// rvalue converter base
+template <class Wrapper, PyTypeObject* python_type>
+struct pytype_wrapper_value_arg_from_python
+    : pytype_arg_from_python<python_type>
+{
+    typedef Wrapper result_type;
+    
+    pytype_wrapper_value_arg_from_python(PyObject*);
+    Wrapper operator()(PyObject*) const;
+};
+
+// Special case for Wrapper& - must store an lvalue internally. This
+// OK because the entire state of the object is actually in the Python
+// object.
+template <class Wrapper, PyTypeObject* python_type>
+struct pytype_wrapper_ref_arg_from_python
+    : pytype_arg_from_python<python_type>
+{
+    typedef Wrapper& result_type;
+    
+    pytype_wrapper_ref_arg_from_python(PyObject*);
+    Wrapper& operator()(PyObject*) const;
+ private:
+    mutable Wrapper m_result;
+};
+
+//
+// implementations
+//
+
+template <PyTypeObject* python_type>
+inline pytype_arg_from_python<python_type>::pytype_arg_from_python(PyObject* x)
+    : m_src(x)
+{
+}
+
+template <PyTypeObject* python_type>
+inline bool pytype_arg_from_python<python_type>::convertible() const
+{
+    return PyObject_IsInstance(m_src, (PyObject*)python_type);
+}
+
+template <class Wrapper, PyTypeObject* python_type>
+pytype_wrapper_value_arg_from_python<Wrapper,python_type>::pytype_wrapper_value_arg_from_python(
+    PyObject* p)
+    : pytype_arg_from_python<python_type>(p)
+{
+}
+
+template <class Wrapper, PyTypeObject* python_type>
+Wrapper pytype_wrapper_value_arg_from_python<Wrapper,python_type>::operator()(
+    PyObject* x) const
+{
+    return Wrapper(python::detail::borrowed_reference(x));
+}
+
+template <class Wrapper, PyTypeObject* python_type>
+pytype_wrapper_ref_arg_from_python<Wrapper,python_type>::pytype_wrapper_ref_arg_from_python(
+    PyObject* p)
+    : pytype_arg_from_python<python_type>(p)
+      , m_result(python::detail::borrowed_reference(p))
+{
+}
+
+template <class Wrapper, PyTypeObject* python_type>
+Wrapper& pytype_wrapper_ref_arg_from_python<Wrapper,python_type>::operator()(
+    PyObject* x) const
+{
+    return m_result;
+}
+
+}}} // namespace boost::python::converter
+
+#endif // PYTYPE_ARG_FROM_PYTHON_DWA2002628_HPP
--- a/include/boost/python/converter/pytype_object_mgr_traits.hpp
+++ b/include/boost/python/converter/pytype_object_mgr_traits.hpp
@@ -0,0 +1,43 @@
+// Copyright David Abrahams 2002. 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 PYTYPE_OBJECT_MANAGER_TRAITS_DWA2002716_HPP
+# define PYTYPE_OBJECT_MANAGER_TRAITS_DWA2002716_HPP
+
+# include <boost/python/detail/raw_pyobject.hpp>
+# include <boost/python/cast.hpp>
+# include <boost/python/detail/wrap_python.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,54 @@
+// Copyright David Abrahams 2002. 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 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>
+
+namespace boost { 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
+    >
+{
+};
+
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+// collapses a few more types to the same static instance
+template <class T>
+struct registered<T&> : registered<T> {};
+# endif
+
+//
+// implementations
+//
+namespace detail
+{
+  template <class T>
+  registration const& registered_base<T>::converters
+     = registry::lookup(type_id<T>());
+}
+}}} // 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,63 @@
+// Copyright David Abrahams 2002. 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 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,67 @@
+// Copyright David Abrahams 2002. 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 REGISTRATIONS_DWA2002223_HPP
+# define REGISTRATIONS_DWA2002223_HPP
+
+# include <boost/python/detail/wrap_python.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/python/type_id.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 registration
+{
+    explicit registration(type_info);
+    
+    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 unique to_python converter for the associated C++ type.
+    to_python_function_t to_python;
+
+    // The class object associated with this type
+    PyTypeObject* class_object;
+};
+
+//
+// implementations
+//
+inline registration::registration(type_info target_type)
+    : target_type(target_type)
+      , lvalue_chain(0)
+      , rvalue_chain(0)
+      , to_python(0)
+      , class_object(0)
+{}
+
+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
@@ -5,68 +5,46 @@
 //  to its suitability for any purpose.
 #ifndef REGISTRY_DWA20011127_HPP
 # define REGISTRY_DWA20011127_HPP
+# include <boost/python/type_id.hpp>
+# include <boost/python/detail/config.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/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 neccessary
+  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;
-
-      // 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,151 @@
+// Copyright David Abrahams 2002. 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 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/detail/void_ptr.hpp>
+# include <boost/call_traits.hpp>
+# include <boost/python/detail/void_return.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 typename call_traits<T>::param_type 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)
+  {
+      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(obj)
+          );
+  }
+}
+  
+}}} // namespace boost::python::converter
+
+#endif // RETURN_FROM_PYTHON_DWA200265_HPP
--- a/include/boost/python/converter/rvalue_from_python_chain.hpp
+++ b/include/boost/python/converter/rvalue_from_python_chain.hpp
@@ -0,0 +1,39 @@
+// Copyright David Abrahams 2002. 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 RVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP
+# define RVALUE_FROM_PYTHON_CHAIN_DWA200237_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 { 
+
+namespace detail
+{
+  template <class T>
+  struct rvalue_from_python_chain_impl
+  {
+      static rvalue_from_python_registration*const& value;
+  };
+
+  template <class T>
+  rvalue_from_python_registration*const& rvalue_from_python_chain_impl<T>::value
+      = registry::rvalue_converters(undecorated_type_id<T>());
+}
+
+template <class T>
+struct rvalue_from_python_chain
+    : detail::rvalue_from_python_chain_impl<
+        typename add_reference<
+          typename add_cv<T>::type
+        >::type
+      >
+{
+};
+
+}}} // namespace boost::python::converter
+
+#endif // RVALUE_FROM_PYTHON_CHAIN_DWA200237_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. 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 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)
+    // This must always be a POD struct with m_data its first member.
+    BOOST_STATIC_ASSERT(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/smart_ptr.hpp
+++ b/include/boost/python/converter/smart_ptr.hpp
@@ -0,0 +1,70 @@
+// Copyright David Abrahams 2002. 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 SMART_PTR_DWA2002123_HPP
+# define SMART_PTR_DWA2002123_HPP
+
+# include <boost/python/converter/class.hpp>
+# include <boost/python/object/pointer_holder.hpp>
+namespace boost { namespace python { namespace converter { 
+
+template <class Pointer, class Value>
+class smart_ptr_wrapper
+    : wrapper<Pointer const&>
+{
+    smart_ptr_wrapper(ref const& type_)
+        : m_class_object(type_)
+    {
+        assert(type_->ob_type == (PyTypeObject*)class_metatype().get());
+    }
+    
+    PyObject* convert(Pointer x) const;
+    
+ private:
+    ref m_class_object;
+    
+    smart_ptr_converters();
+}
+
+
+//
+// implementations
+//
+
+template <class Pointer, class Value>
+PyObject* smart_ptr_wrapper<Pointer,Value>::convert(Pointer x) const
+{
+    if (x.operator->() == 0)
+        return detail::none();
+        
+    // Don't call the type to do the construction, since that
+    // would require the registration of an __init__ copy
+    // constructor. Instead, just construct the object in place.
+    PyObject* raw_result = (PyObject*)PyObject_New(
+        instance, (PyTypeObject*)m_class_object.get());
+        
+    if (raw_result == 0)
+        return 0;
+
+    // Everything's OK; Bypass NULL checks but guard against
+    // exceptions.
+    ref result(raw_result, ref::allow_null());
+
+    // Build a value_holder to contain the object using the copy
+    // constructor
+    objects::pointer_holder<Pointer,Value>*
+        p = new objects::pointer_holder<Pointer,Value>(x);
+
+    // Install it in the instance
+    p->install(raw_result);
+
+    // Return the new result
+    return result.release();
+}
+    
+
+}}} // namespace boost::python::converter
+
+#endif // SMART_PTR_DWA2002123_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/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.hpp
+++ b/include/boost/python/converter/to_python_function.hpp
@@ -0,0 +1,50 @@
+// Copyright David Abrahams 2002. 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 TO_PYTHON_FUNCTION_DWA2002128_HPP
+# define TO_PYTHON_FUNCTION_DWA2002128_HPP
+
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/converter/registry.hpp>
+# include <boost/python/converter/to_python_function_type.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+// to_python_function --
+//
+// essentially a "templated global reference" which holds the
+// converter for converting a type to Python by-value. We "normalize"
+// T by adding "const volatile&" so that fewer global variables and
+// associated static initializations are generated.
+namespace detail
+{
+  template <class T>
+  struct to_python_function_base
+  {
+      static to_python_function_t const& value;
+  };
+  
+  template <class T>
+  to_python_function_t const&
+  to_python_function_base<T>::value
+        = converter::registry::get_to_python_function(undecorated_type_id<T>());
+}
+
+template <class T>
+struct to_python_function
+    : detail::to_python_function_base<
+        typename add_reference<
+          typename add_cv<T>::type
+        >::type
+      >
+{
+};
+
+}}} // namespace boost::python::converter
+
+#endif // TO_PYTHON_FUNCTION_DWA2002128_HPP
--- a/include/boost/python/converter/to_python_function_type.hpp
+++ b/include/boost/python/converter/to_python_function_type.hpp
@@ -0,0 +1,30 @@
+// Copyright David Abrahams 2002. 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 TO_PYTHON_FUNCTION_TYPE_DWA200236_HPP
+# define TO_PYTHON_FUNCTION_TYPE_DWA200236_HPP
+# include <boost/python/detail/wrap_python.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*);
+
+// 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
+{
+    static PyObject* convert(void const* x)
+    {
+        return ToPython::convert(*(T const*)x);
+    }
+};
+
+}}} // 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
@@ -5,13 +5,14 @@
 //  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/python/detail/config.hpp>
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/python/detail/msvc_typeinfo.hpp>
 # include <boost/type_traits/cv_traits.hpp>
 # include <boost/type_traits/composite_traits.hpp>
-# include <boost/python/export.hpp>
+# include <boost/mpl/select_if.hpp>
 # include <boost/operators.hpp>
+# include <boost/type.hpp>
 # include <typeinfo>
 # include <iosfwd>
 # include <cstring>
@@ -19,13 +20,6 @@

 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.
@@ -33,167 +27,149 @@ namespace detail
 #  define BOOST_PYTHON_TYPE_ID_NAME
 # endif 

-# if 1
+// type ids which represent the same information as std::type_info
+// (i.e. the top-level reference and cv-qualifiers are stripped), but
+// which works across shared libraries.
+struct undecorated_type_id_t : totally_ordered<undecorated_type_id_t>
+{
+    undecorated_type_id_t(std::type_info const&);
+    
+    // default constructor needed to build arrays, etc.
+    undecorated_type_id_t();
+
+    bool operator<(undecorated_type_id_t const& rhs) const;
+    bool operator==(undecorated_type_id_t const& rhs) const;
+
+    char const* name() const;
+    friend BOOST_PYTHON_DECL std::ostream& operator<<(
+        std::ostream&, undecorated_type_id_t const&);
+    
+ private: // data members
+#  ifdef BOOST_PYTHON_TYPE_ID_NAME
+    typedef char const* base_id_t;
+#  else
+    typedef std::type_info const* base_id_t;
+#  endif
+    
+    base_id_t m_base_type;
+};
+
 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);
+    type_id_t(undecorated_type_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&);
+
+    friend BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, type_id_t const&);
+
+    operator undecorated_type_id_t const&() const;
+ private: // type
+    typedef undecorated_type_id_t base_id_t;
    
- private:
+ private: // data members
    decoration m_decoration;
    base_id_t m_base_type;
 };

-#  ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <class T>
-struct is_reference_to_const
+inline undecorated_type_id_t undecorated_type_id(boost::type<T>* = 0)
 {
-    BOOST_STATIC_CONSTANT(bool, value = false);
-};
+    return undecorated_type_id_t(
+#  if (!defined(BOOST_MSVC) || BOOST_MSVC > 1300) && (!defined(BOOST_INTEL_CXX_VERSION) || BOOST_INTEL_CXX_VERSION > 600)
+        typeid(T)
+#  else // strip the decoration which msvc and Intel mistakenly leave in
+        python::detail::msvc_typeid<T>()
+#  endif 
+        );
+}

 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)
+inline type_id_t type_id(boost::type<T>* = 0)
 {
    return type_id_t(
-#  ifdef BOOST_PYTHON_TYPE_ID_NAME
-        typeid(T).name()
-#  else
-        &typeid(T)
-#  endif 
+        undecorated_type_id<T>()
        , type_id_t::decoration(
-            (is_const<T>::value || is_reference_to_const<T>::value
+            (is_const<T>::value || python::detail::is_reference_to_const<T>::value
             ? type_id_t::const_ : 0)
-            | (is_volatile<T>::value || is_reference_to_volatile<T>::value
+            | (is_volatile<T>::value || python::detail::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)
+inline undecorated_type_id_t::undecorated_type_id_t(std::type_info const& id)
+    : m_base_type(
+#  ifdef BOOST_PYTHON_TYPE_ID_NAME
+        id.name()
+#  else
+        &id
+#  endif
+        )
+{
+}
+
+inline undecorated_type_id_t::undecorated_type_id_t()
+    : m_base_type()
+{
+}
+
+inline type_id_t::type_id_t(undecorated_type_id_t base_t, decoration decoration)
    : m_decoration(decoration)
    , m_base_type(base_t)
 {
 }

+inline bool undecorated_type_id_t::operator<(undecorated_type_id_t const& rhs) const
+{
+#  ifdef BOOST_PYTHON_TYPE_ID_NAME
+    return std::strcmp(m_base_type, rhs.m_base_type) < 0;
+#  else
+    return 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
        || m_decoration == rhs.m_decoration
+           && m_base_type < rhs.m_base_type;
+}
+
+inline bool undecorated_type_id_t::operator==(undecorated_type_id_t const& rhs) const
+{
 #  ifdef BOOST_PYTHON_TYPE_ID_NAME
-           && std::strcmp(m_base_type, rhs.m_base_type) < 0;
+    return !std::strcmp(m_base_type, rhs.m_base_type);
 #  else
-           && m_base_type->before(*rhs.m_base_type);
+    return *m_base_type == *rhs.m_base_type;
 #  endif 
 }

 inline bool type_id_t::operator==(type_id_t const& rhs) const
 {
-    return m_decoration == rhs.m_decoration
+    return m_decoration == rhs.m_decoration && m_base_type == rhs.m_base_type;
+}
+
+inline type_id_t::operator undecorated_type_id_t const&() const
+{
+    return m_base_type;
+}
+
+inline char const* undecorated_type_id_t::name() const
+{
 #  ifdef BOOST_PYTHON_TYPE_ID_NAME
-        && !std::strcmp(m_base_type, rhs.m_base_type);
+    return m_base_type;
 #  else
-        && *m_base_type == *rhs.m_base_type;
+    return m_base_type->name();
 #  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&);
+BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, undecorated_type_id_t const&);
+BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, type_id_t const&);

 }}} // namespace boost::python::converter

--- 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,42 @@
+// Copyright David Abrahams 2002. 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 COPY_CONST_REFERENCE_DWA2002131_HPP
+# define COPY_CONST_REFERENCE_DWA2002131_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<
+            detail::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_mutable_reference.hpp
+++ b/include/boost/python/copy_mutable_reference.hpp
@@ -0,0 +1,41 @@
+// Copyright David Abrahams 2002. 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 COPY_MUTABLE_REFERENCE_DWA2002131_HPP
+# define COPY_MUTABLE_REFERENCE_DWA2002131_HPP
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/mpl/select_if.hpp>
+# include <boost/python/to_python_value.hpp>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  template <class R>
+  struct copy_mutable_reference_expects_a_reference_to_non_const_return_type
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
+  {}
+# endif
+  ;
+}
+
+template <class T> struct to_python_value;
+
+struct copy_mutable_reference
+{
+    template <class T>
+    struct apply
+    {
+        typedef typename mpl::select_if_c<
+            detail::is_reference_to_non_const<T>::value
+            , to_python_value<T>
+            , detail::copy_mutable_reference_expects_a_reference_to_non_const_return_type<T>
+        >::type type;
+    };
+};
+
+}} // namespace boost::python
+
+#endif // COPY_MUTABLE_REFERENCE_DWA2002131_HPP
--- a/include/boost/python/copy_non_const_reference.hpp
+++ b/include/boost/python/copy_non_const_reference.hpp
@@ -0,0 +1,42 @@
+// Copyright David Abrahams 2002. 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 COPY_NON_CONST_REFERENCE_DWA2002131_HPP
+# define COPY_NON_CONST_REFERENCE_DWA2002131_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<
+            boost::python::detail::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/cross_module.hpp
+++ b/include/boost/python/cross_module.hpp
@@ -0,0 +1,329 @@
+/* (C) Copyright Ralf W. Grosse-Kunstleve 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.
+
+   Revision History:
+     17 Apr 01 merged into boost CVS trunk (Ralf W. Grosse-Kunstleve)
+*/
+
+/* Implementation of Boost.Python cross-module support.
+   See root/libs/python/doc/cross_module.html for details.
+*/
+
+#ifndef CROSS_MODULE_HPP
+# define CROSS_MODULE_HPP
+
+# include <boost/python/class_builder.hpp>
+
+namespace boost { namespace python {
+
+struct BOOST_PYTHON_DECL import_error: error_already_set {};
+struct BOOST_PYTHON_DECL export_error : error_already_set {};
+
+void BOOST_PYTHON_DECL throw_import_error();
+void BOOST_PYTHON_DECL throw_export_error();
+
+namespace detail
+{
+
+// Concept: throw exception if api_major is changed
+//          show warning on stderr if api_minor is changed
+  const int export_converters_api_major = 4;
+  const int export_converters_api_minor = 1;
+  extern BOOST_PYTHON_DECL const char* converters_attribute_name;
+  BOOST_PYTHON_DECL void* import_converter_object(const std::string& module_name,
+                                const std::string& py_class_name,
+                                const std::string& attribute_name);
+  BOOST_PYTHON_DECL void check_export_converters_api(const int importing_major,
+                                   const int importing_minor,
+                                   const int imported_major,
+                                   const int imported_minor);
+
+}
+
+}} // namespace boost::python
+
+// forward declaration
+namespace boost { namespace python { namespace detail {
+template <class T> class import_extension_class;
+}}}
+
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
+
+/* This class template is instantiated by import_converters<T>.
+   This class is a look-alike of class python_extension_class_converters.
+   The converters in this class are wrappers that call converters
+   imported from another module.
+   To ensure that the dynamic loader resolves all symbols in the
+   intended way, the signature of all friend functions is changed with
+   respect to the original functions in class
+   python_extension_class_converters by adding an arbitrary additional
+   parameter with a default value, in this case "bool sig = false".
+   See also: comments for class export_converter_object_base below.
+ */
+template <class T>
+class python_import_extension_class_converters
+{
+ public:
+
+    friend python_import_extension_class_converters py_extension_class_converters(boost::python::type<T>, bool sig = false) {
+        return python_import_extension_class_converters();
+    }
+
+    PyObject* to_python(const T& x) const {
+        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
+    }
+
+    friend T* from_python(PyObject* p, boost::python::type<T*> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_Ts(p, t);
+    }
+    friend const T* from_python(PyObject* p, boost::python::type<const T*> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_cTs(p, t);
+    }
+    friend const T* from_python(PyObject* p, boost::python::type<const T*const&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_cTscr(p, t);
+    }
+    friend T* from_python(PyObject* p, boost::python::type<T* const&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_Tscr(p, t);
+    }
+    friend T& from_python(PyObject* p, boost::python::type<T&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_Tr(p, t);
+    }
+    friend const T& from_python(PyObject* p, boost::python::type<const T&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_cTr(p, t);
+    }
+    friend const T& from_python(PyObject* p, boost::python::type<T> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_T(p, t);
+    }
+
+    friend std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<std::auto_ptr<T>&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_aTr(p, t);
+    }
+    friend std::auto_ptr<T> from_python(PyObject* p, boost::python::type<std::auto_ptr<T> > t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_aT(p, t);
+    }
+    friend const std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<const std::auto_ptr<T>&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_caTr(p, t);
+    }
+    friend PyObject* to_python(std::auto_ptr<T> x, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
+    }
+
+    friend boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T>&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_sTr(p, t);
+    }
+    friend const boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T> > t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_sT(p, t);
+    }
+    friend const boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<const boost::shared_ptr<T>&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_csTr(p, t);
+    }
+    friend PyObject* to_python(boost::shared_ptr<T> x, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
+    }
+};
+
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
+
+namespace boost { namespace python {
+
+BOOST_PYTHON_IMPORT_CONVERSION(python_import_extension_class_converters);
+
+/* This class template is instantiated by export_converters().
+   A pointer to this class is exported/imported via the Python API.
+   Using the Python API ensures maximum portability.
+   All member functions are virtual. This is, what we export/import
+   is essentially just a pointer to a vtbl.
+   To work around a deficiency of Visual C++ 6.0, the name of each
+   from_python() member functions is made unique by appending a few
+   characters (derived in a ad-hoc manner from the corresponding type).
+ */
+template <class T>
+struct export_converter_object_base
+{
+    virtual int get_api_major() const { return detail::export_converters_api_major; }
+    virtual int get_api_minor() const { return detail::export_converters_api_minor; }
+
+    virtual PyObject* to_python(const T& x) = 0;
+
+    virtual T* from_python_Ts(PyObject* p, boost::python::type<T*> t) = 0;
+    virtual const T* from_python_cTs(PyObject* p, boost::python::type<const T*> t) = 0;
+    virtual const T* from_python_cTscr(PyObject* p, boost::python::type<const T*const&> t) = 0;
+    virtual T* from_python_Tscr(PyObject* p, boost::python::type<T* const&> t) = 0;
+    virtual T& from_python_Tr(PyObject* p, boost::python::type<T&> t) = 0;
+    virtual const T& from_python_cTr(PyObject* p, boost::python::type<const T&> t) = 0;
+    virtual const T& from_python_T(PyObject* p, boost::python::type<T> t) = 0;
+
+    virtual std::auto_ptr<T>& from_python_aTr(PyObject* p, boost::python::type<std::auto_ptr<T>&> t) = 0;
+    virtual std::auto_ptr<T> from_python_aT(PyObject* p, boost::python::type<std::auto_ptr<T> > t) = 0;
+    virtual const std::auto_ptr<T>& from_python_caTr(PyObject* p, boost::python::type<const std::auto_ptr<T>&> t) = 0;
+    virtual PyObject* to_python(std::auto_ptr<T> x) = 0;
+
+    virtual boost::shared_ptr<T>& from_python_sTr(PyObject* p, boost::python::type<boost::shared_ptr<T>&> t) = 0;
+    virtual const boost::shared_ptr<T>& from_python_sT(PyObject* p, boost::python::type<boost::shared_ptr<T> > t) = 0;
+    virtual const boost::shared_ptr<T>& from_python_csTr(PyObject* p, boost::python::type<const boost::shared_ptr<T>&> t) = 0;
+    virtual PyObject* to_python(boost::shared_ptr<T> x) = 0;
+};
+
+// Converters to be used if T is not copyable.
+template <class T>
+struct export_converter_object_noncopyable : export_converter_object_base<T>
+{
+    virtual PyObject* to_python(const T& x) {
+        PyErr_SetString(PyExc_RuntimeError,
+          "to_python(const T&) converter not exported");
+        throw_import_error();
+        return 0;
+    }
+
+    virtual T* from_python_Ts(PyObject* p, boost::python::type<T*> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const T* from_python_cTs(PyObject* p, boost::python::type<const T*> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const T* from_python_cTscr(PyObject* p, boost::python::type<const T*const&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual T* from_python_Tscr(PyObject* p, boost::python::type<T* const&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual T& from_python_Tr(PyObject* p, boost::python::type<T&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const T& from_python_cTr(PyObject* p, boost::python::type<const T&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const T& from_python_T(PyObject* p, boost::python::type<T> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+
+    virtual std::auto_ptr<T>& from_python_aTr(PyObject* p, boost::python::type<std::auto_ptr<T>&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual std::auto_ptr<T> from_python_aT(PyObject* p, boost::python::type<std::auto_ptr<T> > t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const std::auto_ptr<T>& from_python_caTr(PyObject* p, boost::python::type<const std::auto_ptr<T>&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual PyObject* to_python(std::auto_ptr<T> x) {
+        return BOOST_PYTHON_CONVERSION::to_python(x);
+    }
+
+    virtual boost::shared_ptr<T>& from_python_sTr(PyObject* p, boost::python::type<boost::shared_ptr<T>&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const boost::shared_ptr<T>& from_python_sT(PyObject* p, boost::python::type<boost::shared_ptr<T> > t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const boost::shared_ptr<T>& from_python_csTr(PyObject* p, boost::python::type<const boost::shared_ptr<T>&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual PyObject* to_python(boost::shared_ptr<T> x) {
+        return BOOST_PYTHON_CONVERSION::to_python(x);
+    }
+};
+
+// The addditional to_python() converter that can be used if T is copyable.
+template <class T>
+struct export_converter_object : export_converter_object_noncopyable<T>
+{
+    virtual PyObject* to_python(const T& x) {
+        return BOOST_PYTHON_CONVERSION::py_extension_class_converters(boost::python::type<T>()).to_python(x);
+    }
+};
+
+namespace detail
+{
+
+/* This class template is instantiated by import_converters<T>.
+   Its purpose is to import the converter_object via the Python API.
+   The actual import is only done once. The pointer to the
+   imported converter object is kept in the static data member
+   imported_converters.
+*/
+  template <class T>
+  class import_extension_class
+      : public python_import_extension_class_converters<T>
+  {
+   public:
+      inline import_extension_class(const char* module, const char* py_class) {
+          m_module = module;
+          m_py_class = py_class;
+      }
+
+      static boost::python::export_converter_object_base<T>* get_converters();
+
+   private:
+      static std::string m_module;
+      static std::string m_py_class;
+      static boost::python::export_converter_object_base<T>* imported_converters;
+  };
+
+  template <class T> std::string import_extension_class<T>::m_module;
+  template <class T> std::string import_extension_class<T>::m_py_class;
+  template <class T>
+  boost::python::export_converter_object_base<T>*
+  import_extension_class<T>::imported_converters = 0;
+
+  template <class T>
+  boost::python::export_converter_object_base<T>*
+  import_extension_class<T>::get_converters() {
+      if (imported_converters == 0) {
+          void* cobject
+              = import_converter_object(m_module, m_py_class,
+                                        converters_attribute_name);
+          imported_converters
+              = static_cast<boost::python::export_converter_object_base<T>*>(cobject);
+          check_export_converters_api(
+              export_converters_api_major,
+              export_converters_api_minor,
+              imported_converters->get_api_major(),
+              imported_converters->get_api_minor());
+      }
+      return imported_converters;
+  }
+}}} // namespace boost::python::detail
+
+namespace boost { namespace python {
+
+// Implementation of export_converters().
+template <class T, class U>
+void export_converters(class_builder<T, U>& cb)
+{
+    static export_converter_object<T> export_cvts;
+    cb.add(
+      ref(PyCObject_FromVoidPtr(reinterpret_cast<void*>(&export_cvts), NULL)),
+      detail::converters_attribute_name);
+}
+
+// Implementation of export_converters_noncopyable().
+template <class T, class U>
+void export_converters_noncopyable(class_builder<T, U>& cb)
+{
+    static export_converter_object_noncopyable<T> export_cvts;
+    cb.add(
+      ref(PyCObject_FromVoidPtr(reinterpret_cast<void*>(&export_cvts), NULL)),
+      detail::converters_attribute_name);
+}
+
+// Implementation of import_converters<T>.
+template <class T>
+class import_converters
+    : python_import_extension_class_converters<T> // Works around MSVC6.x/GCC2.95.2 bug described
+                                                  // at the bottom of class_builder.hpp.
+{
+ public:
+    import_converters(const char* module, const char* py_class)
+        : m_class(new detail::import_extension_class<T>(module, py_class))
+    { }
+ private:
+    boost::shared_ptr<detail::import_extension_class<T> > m_class;
+};
+
+}} // namespace boost::python
+
+#endif // CROSS_MODULE_HPP
--- a/include/boost/python/data_members.hpp
+++ b/include/boost/python/data_members.hpp
@@ -0,0 +1,111 @@
+// Copyright David Abrahams 2002. 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 DATA_MEMBERS_DWA2002328_HPP
+# define DATA_MEMBERS_DWA2002328_HPP
+
+# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/python/return_value_policy.hpp>
+# include <boost/python/copy_non_const_reference.hpp>
+# include <boost/python/object/function_object.hpp>
+# include <boost/python/arg_from_python.hpp>
+# include <boost/bind.hpp>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  template <class Data, class Class, class Policies>
+  struct member
+  {
+      static PyObject* get(Data Class::*pm, PyObject* args_, PyObject*, Policies const& policies)
+      {
+          arg_from_python<Class*> c0(PyTuple_GET_ITEM(args_, 0));
+          if (!c0.convertible()) return 0;
+
+          // find the result converter
+          typedef typename Policies::result_converter result_converter;
+          typedef typename boost::add_reference<Data>::type source;
+          typename mpl::apply1<result_converter,source>::type cr;
+          if (!cr.convertible()) return 0;
+        
+          if (!policies.precall(args_)) return 0;
+
+          PyObject* result = cr( (c0(PyTuple_GET_ITEM(args_, 0)))->*pm );
+        
+          return policies.postcall(args_, result);
+      }
+  
+      static PyObject* set(Data Class::*pm, PyObject* args_, PyObject*, Policies const& policies)
+      {
+          // check that each of the arguments is convertible
+          arg_from_python<Class*> c0(PyTuple_GET_ITEM(args_, 0));
+          if (!c0.convertible()) return 0;
+
+          typedef typename add_const<Data>::type target1;
+          typedef typename add_reference<target1>::type target;
+          arg_from_python<target> c1(PyTuple_GET_ITEM(args_, 1));
+      
+          if (!c1.convertible()) return 0;
+
+          if (!policies.precall(args_)) return 0;
+
+          (c0(PyTuple_GET_ITEM(args_, 0)))->*pm = c1(PyTuple_GET_ITEM(args_, 1));
+        
+          return policies.postcall(args_, detail::none());
+      }
+  };
+}
+
+template <class C, class D>
+object make_getter(D C::*pm)
+{
+    typedef return_value_policy<copy_non_const_reference> default_policy;
+    
+    return objects::function_object(
+        ::boost::bind(
+            &detail::member<D,C,default_policy>::get, pm, _1, _2
+            , default_policy())
+        , 1);
+        
+}
+
+template <class C, class D, class Policies>
+object make_getter(D C::*pm, Policies const& policies)
+{
+    return objects::function_object(
+            ::boost::bind(
+                &detail::member<D,C,Policies>::get, pm, _1, _2
+                , policies)
+        , 1);
+}
+
+template <class C, class D>
+object make_setter(D C::*pm)
+{
+    return objects::function_object(
+        ::boost::bind(
+            &detail::member<D,C,default_call_policies>::set, pm, _1, _2
+            , default_call_policies())
+        , 2);
+}
+
+template <class C, class D, class Policies>
+object make_setter(D C::*pm, Policies const& policies)
+{
+    return objects::function_object(
+        ::boost::bind(
+            &detail::member<D,C,Policies>::set, pm, _1, _2
+            , policies)
+        , 2);
+}
+
+    
+}} // namespace boost::python
+
+#endif // DATA_MEMBERS_DWA2002328_HPP
--- a/include/boost/python/def.hpp
+++ b/include/boost/python/def.hpp
@@ -0,0 +1,109 @@
+// Copyright David Abrahams 2002. 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 DEF_DWA200292_HPP
+# define DEF_DWA200292_HPP
+
+# include <boost/python/object_fwd.hpp>
+# include <boost/python/make_function.hpp>
+# include <boost/python/detail/def_helper.hpp>
+# include <boost/python/detail/defaults_def.hpp>
+# include <boost/python/scope.hpp>
+# include <boost/python/signature.hpp>
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  void BOOST_PYTHON_DECL scope_setattr_doc(char const* name, object const& obj, char const* doc);
+
+    template <class Fn, class CallPolicyOrDoc>
+    void
+    dispatch_def(
+        void const*,
+        char const* name,
+        Fn fn,
+        CallPolicyOrDoc const& policy_or_doc)
+    {
+        typedef detail::def_helper<CallPolicyOrDoc> helper;
+
+        detail::scope_setattr_doc(
+            name, boost::python::make_function(fn, helper::get_policy(policy_or_doc)),
+            helper::get_doc(policy_or_doc, 0));
+    }
+
+    template <class Fn, class CallPolicyOrDoc1, class CallPolicyOrDoc2>
+    void dispatch_def(
+        void const*,
+        char const* name,
+        Fn fn,
+        CallPolicyOrDoc1 const& policy_or_doc1,
+        CallPolicyOrDoc2 const& policy_or_doc2)
+    {
+        typedef detail::def_helper<CallPolicyOrDoc1> helper;
+
+        detail::scope_setattr_doc(
+            name, boost::python::make_function(
+                fn, helper::get_policy(policy_or_doc1, policy_or_doc2)),
+            helper::get_doc(policy_or_doc1, policy_or_doc2));
+    }
+
+    template <class StubsT, class SigT>
+    void dispatch_def(
+        detail::overloads_base const*,
+        char const* name,
+        SigT sig,
+        StubsT const& stubs)
+    {
+        //  convert sig to a type_list (see detail::get_signature in signature.hpp)
+        //  before calling detail::define_with_defaults.
+
+        scope current;
+        detail::define_with_defaults(
+            name, stubs, current, detail::get_signature(sig));
+    }
+}
+
+template <class Fn>
+void def(char const* name, Fn fn)
+{
+    detail::scope_setattr_doc(name, boost::python::make_function(fn), 0);
+}
+
+template <class Arg1T, class Arg2T>
+void def(char const* name, Arg1T arg1, Arg2T const& arg2)
+{
+    //  The arguments may be:
+    //      def(name, function)
+    //      def(name, function, policy)
+    //      def(name, function, doc_string)
+    //      def(name, signature, stubs)
+
+    detail::dispatch_def(&arg2, name, arg1, arg2);
+}
+
+template <class Arg1T, class Arg2T, class Arg3T>
+void def(char const* name, Arg1T arg1, Arg2T const& arg2, Arg3T const& arg3)
+{
+    //  The arguments are definitely:
+    //      def(name, function, policy, doc_string) // TODO: exchange policy, doc_string position
+
+    detail::dispatch_def(&arg2, name, arg1, arg2, arg3);
+}
+
+//template <class Arg1T, class Arg2T, class Arg3T>
+//void def(char const* name, Arg1T arg1, Arg2T const& arg2, Arg3T const& arg3, char const* doc)
+//{
+//    //  The arguments are definitely:
+//    //  arg1:   signature
+//    //  arg2:   stubs
+//    //  arg3:   policy
+//
+//    detail::dispatch_def(&arg2, name, arg1, arg2, arg3, doc);
+//}
+
+}} // namespace boost::python
+
+#endif // DEF_DWA200292_HPP
--- a/include/boost/python/default_call_policies.hpp
+++ b/include/boost/python/default_call_policies.hpp
@@ -0,0 +1,78 @@
+// Copyright David Abrahams 2002. 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 DEFAULT_CALL_POLICIES_DWA2002131_HPP
+# define DEFAULT_CALL_POLICIES_DWA2002131_HPP
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/python/to_python_value.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+
+namespace boost { namespace python { 
+
+template <class T> struct to_python_value;
+
+namespace detail
+{
+// for "readable" error messages
+  template <class T> struct specify_a_result_policy_to_wrap_functions_returning
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
+  {}
+# endif 
+  ;
+}
+
+struct default_result_converter;
+
+struct default_call_policies
+{
+    // Nothing to do
+    static bool precall(PyObject*)
+    {
+        return true;
+    }
+
+    // Pass the result through
+    static PyObject* postcall(PyObject*, PyObject* result)
+    {
+        return result;
+    }
+
+    typedef default_result_converter result_converter;
+};
+
+struct default_result_converter
+{
+    template <class R>
+    struct apply
+    {
+        BOOST_STATIC_CONSTANT(bool, is_illegal = is_reference<R>::value || is_pointer<R>::value);
+        
+        typedef typename mpl::if_c<
+            is_illegal
+            , detail::specify_a_result_policy_to_wrap_functions_returning<R>
+            , boost::python::to_python_value<
+                typename add_reference<typename add_const<R>::type>::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,24 @@
+// Copyright David Abrahams 2002. 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 AIX_INIT_MODULE_DWA2002529_HPP
+# define AIX_INIT_MODULE_DWA2002529_HPP
+# ifdef _AIX
+# include <boost/python/detail/wrap_python.hpp>
+# include <cstdio>
+
+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,14 @@
+#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,3 +1,5 @@
+#if !defined(BOOST_PP_IS_ITERATING)
+
 //  (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
@@ -9,7 +11,16 @@
 //  functions by gen_arg_tuple_size.python

 #ifndef ARG_TUPLE_SIZE_DWA20011201_HPP
-# define ARG_TUPLE_SIZE_DWA20011201_HPP
+# define ARG_TUPLE_SIZE_DWA20011201_HPP 
+
+# include <boost/config.hpp>
+
+# include <boost/python/detail/char_array.hpp>
+# include <boost/python/detail/preprocessor.hpp>
+
+# include <boost/preprocessor/comma_if.hpp>
+# include <boost/preprocessor/iterate.hpp>
+# include <boost/preprocessor/debug/line.hpp>

 namespace boost { namespace python { namespace detail {

@@ -18,216 +29,99 @@ namespace boost { namespace python { namespace detail {
 // (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 (*)());
+// Specializations for function pointers
+# define BOOST_PP_ITERATION_PARAMS_1 \
+     (4, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/arg_tuple_size.hpp>, BOOST_PYTHON_FUNCTION_POINTER))
+# include BOOST_PP_ITERATE()

-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);
+// Specializations for member function pointers
+# define BOOST_PP_ITERATION_PARAMS_1 \
+    (4, (0, BOOST_PYTHON_CV_COUNT - 1, <boost/python/detail/arg_tuple_size.hpp>, BOOST_PYTHON_POINTER_TO_MEMBER))
+# include BOOST_PP_ITERATE()

+# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

 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);
+        = 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

+// --------------- function pointers --------------- //
+#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_FUNCTION_POINTER
+# line BOOST_PP_LINE(__LINE__, arg_tuple_size.hpp(function pointers))
+
+# define N BOOST_PP_ITERATION()
+
+# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template <class R BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)>
+struct arg_tuple_size<R (*)(BOOST_PYTHON_UNARY_ENUM(N, A))>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = N);
+};
+
+# else
+
+template<class R BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)>
+char_array<N> arg_tuple_size_helper(
+        R (*)(BOOST_PYTHON_UNARY_ENUM(N, A)));
+
+# endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+# undef N
+
+// --------------- pointers-to-members --------------- //
+#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_POINTER_TO_MEMBER
+// Outer iteration over cv-qualifications
+
+# define BOOST_PP_ITERATION_PARAMS_2 \
+    (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/arg_tuple_size.hpp>))
+# include BOOST_PP_ITERATE()
+
+#elif BOOST_PP_ITERATION_DEPTH() == 2 && BOOST_PP_RELATIVE_FLAGS(1) == BOOST_PYTHON_POINTER_TO_MEMBER
+# line BOOST_PP_LINE(__LINE__, arg_tuple_size.hpp(pointers-to-members))
+// Inner iteration over arities
+    
+# define N BOOST_PP_ITERATION()
+# define Q BOOST_PYTHON_CV_QUALIFIER(BOOST_PP_RELATIVE_ITERATION(1))
+
+# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template <class R, class T BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)>
+struct arg_tuple_size<R (T::*)(BOOST_PYTHON_UNARY_ENUM(N, A)) Q>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = N + 1U);
+};
+
+# else
+
+template <class R, class T BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)>
+char_array<N + 1> arg_tuple_size_helper(
+    R (T::*)(BOOST_PYTHON_UNARY_ENUM(N, A)) Q);
+
+# endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+# undef Q
+# undef N
+
+#endif // !defined(BOOST_PP_IS_ITERATING)
--- a/include/boost/python/detail/base_object.hpp
+++ b/include/boost/python/detail/base_object.hpp
@@ -0,0 +1,60 @@
+//  (C) Copyright David Abrahams 2000. 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.
+//
+//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
+//  producing this work.
+//
+// Revision History:
+// Mar 01 01  Use PyObject_INIT() instead of trying to hand-initialize (David Abrahams)
+
+#ifndef BASE_OBJECT_DWA051600_H_
+# define BASE_OBJECT_DWA051600_H_
+
+# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <cstring>
+
+namespace boost { namespace python { namespace detail {
+
+// base_object - adds a constructor and non-virtual destructor to a
+// base Python type (e.g. PyObject, PyTypeObject).
+template <class PythonType>
+struct base_object : PythonType
+{
+    typedef PythonType base_python_type;
+
+    // Initializes type and reference count. All other fields of base_python_type are 0
+    base_object(PyTypeObject* type_obj);
+
+    // Decrements reference count on the type
+    ~base_object();
+};
+
+// Easy typedefs for common usage
+typedef base_object<PyObject> python_object;
+typedef base_object<PyTypeObject> python_type;
+
+
+//
+// base_object member function implementations 
+//
+template <class PythonType>
+base_object<PythonType>::base_object(PyTypeObject* type_obj)
+{
+    base_python_type* bp = this;
+    BOOST_CSTD_::memset(bp, 0, sizeof(base_python_type));
+    Py_INCREF(type_obj);
+    PyObject_INIT(bp, type_obj);
+}
+
+template <class PythonType>
+inline base_object<PythonType>::~base_object()
+{
+    Py_DECREF(ob_type);
+}
+
+}}} // namespace boost::python::detail
+
+#endif // BASE_OBJECT_DWA051600_H_
--- a/include/boost/python/detail/borrowed_ptr.hpp
+++ b/include/boost/python/detail/borrowed_ptr.hpp
@@ -0,0 +1,112 @@
+#ifndef BORROWED_PTR_DWA20020601_HPP
+# define BORROWED_PTR_DWA20020601_HPP
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+# include <boost/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/call_object.hpp
+++ b/include/boost/python/detail/call_object.hpp
@@ -0,0 +1,66 @@
+// 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 CALL_OBJECT_DWA20011222_HPP
+# define CALL_OBJECT_DWA20011222_HPP
+# include <boost/python/errors.hpp>
+# include <boost/python/detail/types.hpp>
+# include <boost/bind.hpp>
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  // A function object adaptor which turns a function returning R into
+  // an "equivalent" function returning void, but taking an R& in
+  // which the adapted function's result is stored.
+  template <class R, class F>
+  struct return_by_reference
+  {
+      typedef void return_type;
+      
+      return_by_reference(R& result, F f)
+          : m_result(result)
+          , m_f(f)
+      {
+      }
+      
+      void operator()() const
+      {
+          m_result = m_f();
+      }
+      
+      R& m_result;
+      F m_f;
+  };
+
+  // An object generator for the above adaptors
+  template <class R, class F>
+  return_by_reference<R,F> bind_return(R& result, F f)
+  {
+      return return_by_reference<R,F>(result, f);
+  }
+
+  // Given a function object f with signature
+  //
+  //    R f(PyTypeObject*,PyObject*)
+  //
+  // calls f inside of handle_exception_impl, placing f's result in
+  // ret. Returns true iff an exception is thrown by f, leaving ret
+  // unmodified.
+  template <class R, class F>
+  bool call_object(R& ret, PyObject* obj, F f)
+  {
+      return handle_exception(
+          detail::bind_return(
+              ret
+              , boost::bind<R>(
+                  f, static_cast<type_object_base*>(obj->ob_type), obj)));
+  }
+} // namespace detail
+
+}} // namespace boost::python
+
+#endif // CALL_OBJECT_DWA20011222_HPP
--- a/include/boost/python/detail/caller.hpp
+++ b/include/boost/python/detail/caller.hpp
@@ -1,27 +1,105 @@
-// 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>
+//  (C) Copyright David Abrahams 2000. 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.
+//
+//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
+//  producing this work.
+//
+//  This file generated for 10-argument member functions and 11-argument free
+//  functions by gen_caller.python

-namespace boost { namespace python { namespace detail { 
+# ifndef CALLER_DWA20011214_HPP
+#  define CALLER_DWA20011214_HPP
+
+#  include <boost/python/detail/wrap_python.hpp>
+#  include <boost/python/detail/returning.hpp>
+#  include <boost/python/detail/preprocessor.hpp>
+
+#  include <boost/type_traits/composite_traits.hpp>
+#  include <boost/type_traits/same_traits.hpp>
+
+#  include <boost/preprocessor/comma_if.hpp>
+#  include <boost/preprocessor/iterate.hpp>
+#  include <boost/preprocessor/debug/line.hpp>
+
+namespace boost { namespace python
+{
+    template <class T> struct to_python;
+}}
+
+namespace boost { namespace python { namespace detail {

 struct caller
 {
    typedef PyObject* result_type;
-    
-    template <class F>
-    PyObject* operator()(F f, PyObject* args, PyObject* keywords)
-    {
-        return call(f, args, keywords);
-    }
+
+    // function pointers
+#  define BOOST_PP_ITERATION_PARAMS_1 \
+    (4, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/caller.hpp>, BOOST_PYTHON_FUNCTION_POINTER))
+#  include BOOST_PP_ITERATE()
+
+    // pointers-to-members
+#  define BOOST_PP_ITERATION_PARAMS_1 \
+    (4, (0, 3, <boost/python/detail/caller.hpp>, BOOST_PYTHON_POINTER_TO_MEMBER))
+#  include BOOST_PP_ITERATE()
+
 };

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

-#endif // CALLER_DWA20011214_HPP
+# endif // CALLER_DWA20011214_HPP
+
+/* ---------- function pointers --------- */
+#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_FUNCTION_POINTER
+# line BOOST_PP_LINE(__LINE__, detail/caller.hpp(function pointers))
+
+# define N BOOST_PP_ITERATION()
+
+template <
+    class P, class R
+    BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)
+    >
+PyObject* operator()(
+    R (*pf)(BOOST_PYTHON_UNARY_ENUM(N, A))
+    , PyObject* args
+    , PyObject* keywords
+    , P const& policies) const
+{
+    return returning<R>::call(pf, args, keywords, &policies);
+}
+
+# undef N
+
+/* ---------- pointers-to-members ---------- */
+#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_POINTER_TO_MEMBER
+// outer over cv-qualifiers
+
+# define BOOST_PP_ITERATION_PARAMS_2 (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/caller.hpp>))
+# include BOOST_PP_ITERATE()
+
+#elif BOOST_PP_ITERATION_DEPTH() == 2
+// inner over arities
+
+#define N BOOST_PP_ITERATION()
+#define Q BOOST_PYTHON_CV_QUALIFIER(BOOST_PP_RELATIVE_ITERATION(1))
+
+template <
+    class P, class R, class T
+    BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)
+    >
+PyObject* operator()(
+    R (T::*pmf)(BOOST_PYTHON_UNARY_ENUM(N, A)) Q
+    , PyObject* args, PyObject* keywords
+    , P const& policies
+    ) const
+{
+    return returning<R>::call(pmf, args, keywords, &policies);
+}
+
+#undef N
+#undef Q
+
+#endif
--- a/include/boost/python/detail/cast.hpp
+++ b/include/boost/python/detail/cast.hpp
@@ -0,0 +1,81 @@
+//  (C) Copyright David Abrahams 2000. 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.
+//
+//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
+//  producing this work.
+
+#ifndef CAST_DWA052500_H_
+# define CAST_DWA052500_H_
+
+# ifndef BOOST_PYTHON_V2
+#  include <boost/python/detail/wrap_python.hpp>
+#  include <boost/operators.hpp>
+
+namespace boost { namespace python {
+
+namespace detail {
+  inline PyTypeObject* as_base_object(const PyTypeObject*, PyObject* p)
+  {
+      return reinterpret_cast<PyTypeObject*>(p);
+  }
+
+  inline PyObject* as_base_object(const PyObject*, PyObject* p)
+  {
+      return p;
+  }
+
+  inline const PyTypeObject* as_base_object(const PyTypeObject*, const PyObject* p)
+  {
+      return reinterpret_cast<const PyTypeObject*>(p);
+  }
+
+  inline const PyObject* as_base_object(const PyObject*, const PyObject* p)
+  {
+      return p;
+  }
+} // namespace detail
+
+// Convert a pointer to any type derived from PyObject or PyTypeObject to a PyObject*
+inline PyObject* as_object(PyObject* p) { return p; }
+inline PyObject* as_object(PyTypeObject* p) { return reinterpret_cast<PyObject*>(p); }
+
+// If I didn't have to support stupid MSVC6 we could just use a simple template function:
+// template <class T> T* downcast(PyObject*).
+template <class T>
+struct downcast
+{
+    downcast(PyObject* p)
+        : m_p(static_cast<T*>(detail::as_base_object((T*)0, p)))
+        {}
+    
+    downcast(const PyObject* p)
+        : m_p(static_cast<T*>(detail::as_base_object((const T*)0, p)))
+        {}
+    
+    downcast(PyTypeObject* p)
+        : m_p(static_cast<T*>(p))
+        {}
+    
+    downcast(const PyTypeObject* p)
+        : m_p(static_cast<T*>(p))
+        {}
+    
+    operator T*() const { return m_p; }
+
+    // MSVC doesn't like boost::dereferencable unless T has a default
+    // constructor, so operator-> must be defined by hand :(
+    T* operator->() const { return &**this; }
+    
+    T* get() const { return m_p; }
+    T& operator*() const { return *m_p; }
+ private:
+    T* m_p;
+};
+
+}} // namespace boost::python
+
+# endif // BOOST_PYTHON_V2
+
+#endif // CAST_DWA052500_H_
--- a/include/boost/python/detail/char_array.hpp
+++ b/include/boost/python/detail/char_array.hpp
@@ -0,0 +1,23 @@
+// Copyright David Abrahams 2002. 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 CHAR_ARRAY_DWA2002129_HPP
+# define CHAR_ARRAY_DWA2002129_HPP
+
+namespace boost { namespace python { namespace detail { 
+
+// 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];
+};
+
+}}} // namespace boost::python::detail
+
+#endif // CHAR_ARRAY_DWA2002129_HPP
--- a/include/boost/python/detail/config.hpp
+++ b/include/boost/python/detail/config.hpp
@@ -0,0 +1,117 @@
+//  (C) Copyright David Abrahams 2000. 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.
+//
+//  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>
+
+# 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 <= 1200
+#   define BOOST_MSVC6_OR_EARLIER 1
+#  endif
+
+#  pragma warning (disable : 4786)
+
+# 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_MSVC_STD_ITERATOR)
+#  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(__MWERKS__) \
+  || (defined(__DECCXX_VER) && __DECCXX_VER <= 60590002) \
+  || (defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+# define BOOST_PYTHON_NO_TEMPLATE_EXPORT
+#endif
+
+#if defined(BOOST_PYTHON_DYNAMIC_LIB) && defined(_WIN32)
+#  if defined(BOOST_PYTHON_SOURCE)
+#     define BOOST_PYTHON_DECL __declspec(dllexport)
+#     define BOOST_PYTHON_BUILD_DLL
+#  else
+#     define BOOST_PYTHON_DECL __declspec(dllimport)
+#  endif
+
+// MinGW, at least, has some problems exporting template instantiations
+#  if defined(__GNUC__) && __GNUC__ < 3 && !defined(__CYGWIN__)
+#   define BOOST_PYTHON_NO_TEMPLATE_EXPORT
+#  endif
+
+#endif
+
+#ifndef BOOST_PYTHON_DECL
+#  define BOOST_PYTHON_DECL
+#endif
+
+#ifndef BOOST_PYTHON_EXPORT
+# define BOOST_PYTHON_EXPORT extern
+#endif 
+
+#if !defined(BOOST_PYTHON_NO_TEMPLATE_EXPORT)
+# define BOOST_PYTHON_EXPORT_CLASS_TEMPLATE(instantiation) BOOST_PYTHON_EXPORT template class BOOST_PYTHON_DECL instantiation
+#else
+# define BOOST_PYTHON_EXPORT_CLASS_TEMPLATE(instantiation) struct ThIsTyPeNeVeRuSeD
+#endif
+
+#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730
+// Work around a compiler bug.
+// boost::python::detail::function has to be seen by the compiler before the
+// boost::function class template.
+namespace boost { namespace python { namespace detail {
+class function;
+}}}
+#endif
+
+#if (defined(__DECCXX_VER) && __DECCXX_VER <= 60590014)
+// 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,43 @@
+// Copyright David Abrahams 2002. 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 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,39 @@
+// Copyright David Abrahams 2002. 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 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/cv_category.hpp
+++ b/include/boost/python/detail/cv_category.hpp
@@ -0,0 +1,34 @@
+// Copyright David Abrahams 2002. 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 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<c,v> type;
+};
+
+}}} // namespace boost::python::detail
+
+#endif // CV_CATEGORY_DWA200222_HPP
--- a/include/boost/python/detail/decorated_type_id.hpp
+++ b/include/boost/python/detail/decorated_type_id.hpp
@@ -0,0 +1,77 @@
+// Copyright David Abrahams 2002. 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 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 || python::detail::is_reference_to_const<T>::value
+             ? decorated_type_info::const_ : 0)
+            | (is_volatile<T>::value || python::detail::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/def_helper.hpp
+++ b/include/boost/python/detail/def_helper.hpp
@@ -0,0 +1,77 @@
+// Copyright David Abrahams 2002. 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 DEF_HELPER_DWA200287_HPP
+# define DEF_HELPER_DWA200287_HPP
+
+# include <boost/type_traits/ice.hpp>
+# include <boost/type_traits/same_traits.hpp>
+# include <boost/python/detail/string_literal.hpp>
+
+namespace boost { namespace python { namespace detail {
+
+//
+// def_helper<T> --
+//
+//      A helper for def() functions which determines how to interpret
+//      an argument of type T which could be either CallPolicies or a
+//      string literal representing a docstring.
+//
+//      Generates two static functions:
+//
+//        get_policy(x), where x is of type T, returns a policies
+//        object: either a reference to x or default_call_policies()
+//        if x is a string literal.
+//
+//        get_doc(x, s), where s convertible to char const*, returns x
+//        if x is a string literal, s otherwise.
+
+template <bool is_string = false>
+struct def_helper_impl
+{
+    template <class P>
+    static P const&
+    get_policy(P const& x) { return x; }
+
+    template <class P1, class P2>
+    static P1 const&
+    get_policy(P1 const& x, P2 const&) { return x; } // select left
+
+    template <class P>
+    static char const*
+    get_doc(P const&, char const* doc) { return doc; } // select right
+};
+
+template <>
+struct def_helper_impl<true>
+{
+    static python::default_call_policies
+    get_policy(char const*)
+    { return default_call_policies(); }
+
+    template <class P1, class P2>
+    static P2 const&
+    get_policy(P1 const&, P2 const& y) { return y; } // select right
+
+    template <class P>
+    static char const*
+    get_doc(char const* doc, P const&) // select left
+    { return doc; }
+};
+
+template <class T>
+struct def_helper
+    : def_helper_impl<
+    type_traits::ice_or<
+    is_string_literal<T const>::value
+    , is_same<T, char const*>::value
+    , is_same<T, char*>::value
+>::value
+>
+{};
+
+}}} // namespace boost::python::detail
+
+#endif // DEF_HELPER_DWA200287_HPP
--- a/include/boost/python/detail/defaults_def.hpp
+++ b/include/boost/python/detail/defaults_def.hpp
@@ -0,0 +1,249 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright David Abrahams 2002. 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.
+//
+///////////////////////////////////////////////////////////////////////////////
+#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/object/function.hpp>
+#include <boost/python/scope.hpp>
+#include <boost/preprocessor/debug/line.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace python {
+
+struct module;
+
+namespace objects
+{
+  struct class_base;
+}
+
+namespace detail {
+
+template <class Func, class CallPolicies, class NameSpaceT>
+static void name_space_def(
+    NameSpaceT& name_space,
+    char const* name,
+    Func f,
+    CallPolicies const& policies,
+    char const* doc,
+    objects::class_base*
+    )
+{
+    name_space.def(
+        name, f, policies, doc);
+}
+
+template <class Func, class CallPolicies>
+static void name_space_def(
+    object& name_space,
+    char const* name,
+    Func f,
+    CallPolicies const& policies,
+    char const* doc,
+    ...
+    )
+{
+    scope within(name_space);
+
+    def(name, f, policies, doc);
+}
+
+// For backward compatibility
+template <class Func, class CallPolicies, class NameSpaceT>
+static void name_space_def(
+    NameSpaceT& name_space,
+    char const* name,
+    Func f,
+    CallPolicies const& policies,
+    char const* doc,
+    module*
+    )
+{
+    name_space.def(
+        name, f, policies, doc);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  This Boost PP code generates expansions for
+//
+//      template <typename StubsT, typename NameSpaceT>
+//      inline void
+//      define_stub_function(
+//          char const* name, StubsT s, NameSpaceT& name_space, mpl::int_c<N>)
+//      {
+//          name_space.def(name, &StubsT::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. StubsT:              a function stubs struct (see defaults_gen.hpp)
+//      3. NameSpaceT& name_space:     a python::class_ or python::module instance
+//      4. int_t<N>:            the Nth overloaded function (StubsT::func_N)
+//                                  (see defaults_gen.hpp)
+//      5. char const* name:    doc string
+//
+///////////////////////////////////////////////////////////////////////////////
+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()
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  define_with_defaults_helper<N>
+//
+//  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. StubsT:              a function stubs 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,
+            CallPolicies const& policies,
+            NameSpaceT& name_space,
+            char const* doc)
+        {
+            //  define the NTH stub function of stubs
+            define_stub_function<N>::define(name, stubs, policies, name_space, doc);
+            //  call the next define_with_defaults_helper
+            define_with_defaults_helper<N-1>::def(name, stubs, 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,
+            CallPolicies const& policies,
+            NameSpaceT& name_space,
+            char const* doc)
+        {
+            //  define the Oth stub function of stubs
+            define_stub_function<0>::define(name, stubs, policies, name_space, doc);
+            //  return
+        }
+    };
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  define_with_defaults
+//
+//      1. char const* name:        function name that will be visible to python
+//      2. StubsT:                  a function stubs 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::list<int, int>
+//      void bar(int, int)  mpl::list<void, int, int>
+//      void C::foo(int)    mpl::list<void, C, int>
+//
+///////////////////////////////////////////////////////////////////////////////
+    template <class StubsT, class NameSpaceT, class SigT>
+    inline void
+    define_with_defaults(
+        char const* name,
+        StubsT const& stubs,
+        NameSpaceT& name_space,
+        SigT sig)
+    {
+        typedef typename mpl::front<SigT>::type return_type;
+        typedef typename StubsT::void_return_type void_return_type;
+        typedef typename StubsT::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(), stubs.call_policies(), name_space, stubs.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,
+        CallPolicies const& policies,
+        NameSpaceT& name_space,
+        char const* doc)
+    {
+        detail::name_space_def(name_space,
+            name,
+            &StubsT::BOOST_PP_CAT(func_, BOOST_PP_ITERATION()),
+            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,357 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright David Abrahams 2002. 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 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/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/at.hpp>
+#include <boost/mpl/front.hpp>
+
+namespace boost { namespace python {
+
+    //  overloads_base is used as a base class for all function
+    //  stubs. This class holds the doc_string of the stubs.
+
+    namespace detail
+    {
+        struct overloads_base
+        {
+            overloads_base(char const* doc_)
+            : doc(doc_) {}
+
+            char const* doc_string() const
+            { return doc; }
+
+            char const* doc;
+        };
+    }
+
+//  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 detail::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)
+    : detail::overloads_base(doc), 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 detail::overloads_base {
+
+    overloads_common(char const* doc)
+    : detail::overloads_base(doc) {}
+
+    default_call_policies
+    call_policies() const
+    { return default_call_policies(); }
+
+    template <class CallPoliciesT>
+    ::boost::python::overloads_proxy<CallPoliciesT, DerivedT>
+    operator[](CallPoliciesT const& policies) const
+    {
+        return overloads_proxy<CallPoliciesT, DerivedT>
+            (policies, doc);
+    }
+};
+
+}} // namespace boost::python
+
+///////////////////////////////////////////////////////////////////////////////
+#define BOOST_PYTHON_TYPEDEF_GEN(z, index, data)                                \
+    typedef typename BOOST_PP_CAT(iter, index)::next                            \
+        BOOST_PP_CAT(iter, BOOST_PP_INC(index));                                \
+    typedef typename 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_PYTHON_BINARY_ENUM(                                               \
+            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 rt_iter::type RT;                                  \
+            typedef typename rt_iter::next iter0;                               \
+                                                                                \
+            BOOST_PP_REPEAT_2ND(                                                \
+                n_args,                                                         \
+                BOOST_PYTHON_TYPEDEF_GEN,                                       \
+                0)                                                              \
+                                                                                \
+            BOOST_PP_REPEAT_FROM_TO(                                            \
+                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_PYTHON_BINARY_ENUM(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 rt_iter::type RT;                                  \
+                                                                                \
+            typedef typename rt_iter::next class_iter;                          \
+            typedef typename class_iter::type ClassT;                           \
+            typedef typename class_iter::next iter0;                            \
+                                                                                \
+            BOOST_PP_REPEAT_2ND(                                                \
+                n_args,                                                         \
+                BOOST_PYTHON_TYPEDEF_GEN,                                       \
+                0)                                                              \
+                                                                                \
+            BOOST_PP_REPEAT_FROM_TO(                                            \
+                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))               \
+        };                                                                      \
+    };
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(BOOST_NO_VOID_RETURNS)
+
+#define BOOST_PYTHON_GEN_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts)     \
+    BOOST_PYTHON_GEN_FUNCTION                                                   \
+        (fname, BOOST_PP_CAT(fstubs_name, _NV), n_args, n_dflts, return)        \
+    BOOST_PYTHON_GEN_FUNCTION                                                   \
+        (fname, BOOST_PP_CAT(fstubs_name, _V), n_args, n_dflts, ;)              \
+    struct fstubs_name                                                          \
+    : public boost::python::overloads_common<fstubs_name>                       \
+    {                                                                           \
+        typedef BOOST_PP_CAT(fstubs_name, _NV)  non_void_return_type;           \
+        typedef BOOST_PP_CAT(fstubs_name, _V)   void_return_type;               \
+                                                                                \
+        fstubs_name(char const* doc = 0)                                        \
+        : boost::python::                                                       \
+            overloads_common<fstubs_name>(doc) {}                               \
+    };                                                                          \
+
+///////////////////////////////////////////////////////////////////////////////
+#define BOOST_PYTHON_GEN_MEM_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts) \
+    BOOST_PYTHON_GEN_MEM_FUNCTION                                               \
+        (fname, BOOST_PP_CAT(fstubs_name, _NV), n_args, n_dflts, return)        \
+    BOOST_PYTHON_GEN_MEM_FUNCTION                                               \
+        (fname, BOOST_PP_CAT(fstubs_name, _V), n_args, n_dflts, ;)              \
+    struct fstubs_name                                                          \
+    : public boost::python::overloads_common<fstubs_name>                       \
+    {                                                                           \
+        typedef BOOST_PP_CAT(fstubs_name, _NV)  non_void_return_type;           \
+        typedef BOOST_PP_CAT(fstubs_name, _V)   void_return_type;               \
+                                                                                \
+        fstubs_name(char const* doc = 0)                                        \
+        : boost::python::                                                       \
+            overloads_common<fstubs_name>(doc) {}                               \
+    };                                                                          \
+
+#else
+
+///////////////////////////////////////////////////////////////////////////////
+#define BOOST_PYTHON_GEN_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts)     \
+    BOOST_PYTHON_GEN_FUNCTION                                                   \
+        (fname, BOOST_PP_CAT(fstubs_name, _NV), n_args, n_dflts, return)        \
+    struct fstubs_name                                                          \
+    : public boost::python::overloads_common<fstubs_name>                       \
+    {                                                                           \
+        typedef BOOST_PP_CAT(fstubs_name, _NV)  non_void_return_type;           \
+        typedef BOOST_PP_CAT(fstubs_name, _NV)  void_return_type;               \
+                                                                                \
+        fstubs_name(char const* doc = 0)                                        \
+        : boost::python::                                                       \
+            overloads_common<fstubs_name>(doc) {}                               \
+    };                                                                          \
+
+///////////////////////////////////////////////////////////////////////////////
+#define BOOST_PYTHON_GEN_MEM_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts) \
+    BOOST_PYTHON_GEN_MEM_FUNCTION                                               \
+        (fname, BOOST_PP_CAT(fstubs_name, _NV), n_args, n_dflts, return)        \
+    struct fstubs_name                                                          \
+    : public boost::python::overloads_common<fstubs_name>                       \
+    {                                                                           \
+        typedef BOOST_PP_CAT(fstubs_name, _NV)  non_void_return_type;           \
+        typedef BOOST_PP_CAT(fstubs_name, _NV)  void_return_type;               \
+                                                                                \
+        fstubs_name(char const* doc = 0)                                        \
+        : boost::python::                                                       \
+            overloads_common<fstubs_name>(doc) {}                               \
+    };                                                                          \
+
+#endif // defined(BOOST_MSVC)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  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_stubs_NV  {
+//
+//          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_stubs
+//      : public boost::python::overloads_common<foo_stubs>
+//
+//          typedef foo_stubs_NV    non_void_return_type;
+//          typedef foo_stubs_NV    void_return_type;
+//
+//          fstubs_name(char const* doc = 0)
+//          : boost::python::
+//              overloads_common<foo_stubs>(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_stubs_NV. On compilers that do not support
+//      void returns, there are two versions: foo_stubs_NV and foo_stubs_V.
+//      The "V" version is almost identical to the "NV" 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_stubs'
+//      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,28 @@
+// Copyright David Abrahams 2002. 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 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,83 @@
+// Copyright David Abrahams 2002. 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 DESTROY_DWA2002221_HPP
+# define DESTROY_DWA2002221_HPP
+
+# include <boost/type_traits/composite_traits.hpp>
+# include <boost/type_traits/object_traits.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+template <bool array, bool trivial_destructor> struct value_destroyer;
+
+template <>
+struct value_destroyer<false,false>
+{
+    template <class T>
+    static void execute(T const volatile* p)
+    {
+        p->T::~T();
+    }
+};
+
+template <>
+struct value_destroyer<true,false>
+{
+    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
+                ,boost::has_trivial_destructor<T>::value
+                >::execute(p);
+    }
+    
+    template <class T>
+    static void execute(T const volatile* p)
+    {
+        execute(p, *p);
+    }
+};
+
+template <>
+struct value_destroyer<true,true>
+{
+    template <class T>
+    static void execute(T const volatile* p)
+    {
+    }
+};
+
+template <>
+struct value_destroyer<false,true>
+{
+    template <class T>
+    static void execute(T const volatile* p)
+    {
+    }
+};
+
+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)
+        ,(boost::has_trivial_destructor<T>::value)
+        >::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/exception_handler.hpp
+++ b/include/boost/python/detail/exception_handler.hpp
@@ -0,0 +1,48 @@
+// Copyright David Abrahams 2002. 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 EXCEPTION_HANDLER_DWA2002810_HPP
+# define EXCEPTION_HANDLER_DWA2002810_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/extension_class.hpp
+++ b/include/boost/python/detail/extension_class.hpp
--- a/include/boost/python/detail/force_instantiate.hpp
+++ b/include/boost/python/detail/force_instantiate.hpp
@@ -0,0 +1,33 @@
+// Copyright David Abrahams 2002. 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 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 == 1200 || _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/functions.hpp
+++ b/include/boost/python/detail/functions.hpp
@@ -0,0 +1,311 @@
+//  (C) Copyright David Abrahams 2000. 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.
+//
+//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
+//  producing this work.
+
+#ifndef FUNCTIONS_DWA051400_H_
+# define FUNCTIONS_DWA051400_H_
+
+# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/reference.hpp>
+# include <boost/python/detail/signatures.hpp>
+# include <boost/python/caller.hpp>
+# include <boost/call_traits.hpp>
+# include <boost/python/objects.hpp>
+# include <boost/python/detail/base_object.hpp>
+# include <typeinfo>
+# include <vector>
+
+namespace boost { namespace python { namespace detail {
+
+// forward declaration
+class extension_instance;
+
+
+// function --
+//      the common base class for all overloadable function and method objects
+//      supplied by the library.
+class BOOST_PYTHON_DECL function : public python_object
+{
+ public:
+    function();
+    // function objects are reasonably rare, so we guess we can afford a virtual table.
+    // This cuts down on the number of distinct type objects which need to be defined.
+    virtual ~function() {}
+
+    PyObject* call(PyObject* args, PyObject* keywords) const;
+    static void add_to_namespace(reference<function> f, const char* name, PyObject* dict);
+    
+ private:
+    virtual PyObject* do_call(PyObject* args, PyObject* keywords) const = 0;
+    virtual const char* description() const = 0;
+ private:
+    struct type_object;
+ private:
+    reference<function> m_overloads; // A linked list of the function overloads
+};
+
+// wrapped_function_pointer<> --
+//      A single function or member function pointer wrapped and presented to
+//      Python as a callable object.
+//
+//   Template parameters:
+//      R - the return type of the function pointer
+//      F - the complete type of the wrapped function pointer
+template <class R, class F>
+struct wrapped_function_pointer : function
+{
+    typedef F ptr_fun; // pointer-to--function or pointer-to-member-function
+    
+    wrapped_function_pointer(ptr_fun pf)
+        : m_pf(pf) {}
+
+ private:
+    PyObject* do_call(PyObject* args, PyObject* keywords) const
+        {
+            // This is where the boundary between the uniform Python function
+            // interface and the statically-checked C++ function interface is
+            // crossed.
+            return caller<R>::call(m_pf, args, keywords);
+        }
+    
+    const char* description() const
+        { return typeid(F).name(); }
+    
+ private:
+    const ptr_fun m_pf;
+};
+
+// raw_arguments_function
+//      A function that passes the Python argument tuple and keyword dictionary 
+//      verbatim to C++ (useful for customized argument parsing and variable
+//      argument lists)
+template <class Ret, class Args, class Keywords>
+struct raw_arguments_function : function
+{
+    typedef Ret (*ptr_fun)(Args, Keywords); 
+    
+    raw_arguments_function(ptr_fun pf)
+        : m_pf(pf) {}
+
+ private:
+    PyObject* do_call(PyObject* args, PyObject* keywords) const
+    { 
+        ref dict(keywords ? 
+                 ref(keywords, ref::increment_count) :
+                 ref(PyDict_New()));
+            
+        return to_python(
+            (*m_pf)(from_python(args, boost::python::type<Args>()),
+                    from_python(dict.get(), boost::python::type<Keywords>()))); 
+    }
+    
+    const char* description() const
+        { return typeid(ptr_fun).name(); }
+    
+ private:
+    const ptr_fun m_pf;
+};
+
+// virtual_function<> --
+//      A virtual function with a default implementation wrapped and presented
+//      to Python as a callable object.
+//
+//   Template parameters:
+//      T - the type of the target class
+//      R - the return type of the function pointer
+//      V - the virtual function pointer being wrapped
+//          (should be of the form R(T::*)(<args>), or R (*)(T, <args>))
+//      D - a function which takes a T&, const T&, T*, or const T* first
+//          parameter and calls T::f on it /non-virtually/, where V
+//          approximates &T::f.
+template <class T, class R, class V, class D>
+class virtual_function : public function
+{
+ public:
+    virtual_function(V virtual_function_ptr, D default_implementation)
+        : m_virtual_function_ptr(virtual_function_ptr),
+          m_default_implementation(default_implementation)
+        {}
+
+ private:
+    PyObject* do_call(PyObject* args, PyObject* keywords) const;
+    
+    const char* description() const
+        { return typeid(V).name(); }
+    
+ private:
+    const V m_virtual_function_ptr;
+    const D m_default_implementation;
+};
+
+// A helper function for new_member_function(), below.  Implements the core
+// functionality once the return type has already been deduced. R is expected to
+// be type<X>, where X is the actual return type of pmf.
+template <class F, class R>
+function* new_wrapped_function_aux(R, F pmf)
+{
+    // We can't just use "typename R::Type" below because MSVC (incorrectly) pukes.
+    typedef typename R::type return_type;
+    return new wrapped_function_pointer<return_type, F>(pmf);
+}
+
+// Create and return a new member function object wrapping the given
+// pointer-to-member function
+template <class F>
+inline function* new_wrapped_function(F pmf)
+{
+    // Deduce the return type and pass it off to the helper function above
+    return new_wrapped_function_aux(return_value(pmf), pmf);
+}
+
+template <class R, class Args, class keywords>
+function* new_raw_arguments_function(R (*pmf)(Args, keywords))
+{
+    return new raw_arguments_function<R, Args, keywords>(pmf);
+}
+
+
+// A helper function for new_virtual_function(), below.  Implements the core
+// functionality once the return type has already been deduced. R is expected to
+// be type<X>, where X is the actual return type of V.
+template <class T, class R, class V, class D>
+inline function* new_virtual_function_aux(
+    type<T>, R, V virtual_function_ptr, D default_implementation
+    )
+{
+    // We can't just use "typename R::Type" below because MSVC (incorrectly) pukes.
+    typedef typename R::type return_type;
+    return new virtual_function<T, return_type, V, D>(
+        virtual_function_ptr, default_implementation);
+}
+
+// Create and return a new virtual_function object wrapping the given
+// virtual_function_ptr and default_implementation
+template <class T, class V, class D>
+inline function* new_virtual_function(
+    type<T>, V virtual_function_ptr, D default_implementation
+    )
+{
+    // Deduce the return type and pass it off to the helper function above
+    return new_virtual_function_aux(
+        type<T>(), return_value(virtual_function_ptr),
+        virtual_function_ptr, default_implementation);
+}
+
+// A function with a bundled "bound target" object. This is what is produced by
+// the expression a.b where a is an instance or extension_instance object and b
+// is a callable object not found in the obj namespace but on its class or
+// a base class.
+class BOOST_PYTHON_DECL bound_function : public python_object
+{
+ public:
+    static bound_function* create(const ref& target, const ref& fn);
+    
+    bound_function(const ref& target, const ref& fn);
+    PyObject* call(PyObject*args, PyObject* keywords) const;
+    PyObject* getattr(const char* name) const;
+    
+ private:
+    struct type_object;
+    friend struct type_object;
+    
+    ref m_target;
+    ref m_unbound_function;
+    
+ private: // data members for allocation/deallocation optimization
+    bound_function* m_free_list_link;
+
+    static bound_function* free_list;
+};
+
+// Special functions designed to access data members of a wrapped C++ object.
+template <class ClassType, class MemberType>
+class getter_function : public function
+{
+ public:
+    typedef MemberType ClassType::* pointer_to_member;
+    
+    getter_function(pointer_to_member pm)
+        : m_pm(pm) {}
+
+ private:
+    PyObject* do_call(PyObject* args, PyObject* keywords) const;
+    
+    const char* description() const
+        { return typeid(MemberType (*)(const ClassType&)).name(); }
+ private:
+    pointer_to_member m_pm;
+};
+
+template <class ClassType, class MemberType>
+class setter_function : public function
+{
+ public:
+    typedef MemberType ClassType::* pointer_to_member;
+    
+    setter_function(pointer_to_member pm)
+        : m_pm(pm) {}
+
+ private:
+    PyObject* do_call(PyObject* args, PyObject* keywords) const;
+    
+    const char* description() const
+        { return typeid(void (*)(const ClassType&, const MemberType&)).name(); }
+ private:
+    pointer_to_member m_pm;
+};
+
+template <class ClassType, class MemberType>
+PyObject* getter_function<ClassType, MemberType>::do_call(
+    PyObject* args, PyObject* /* keywords */) const
+{
+    PyObject* self;
+    if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &self))
+        return 0;
+
+    return to_python(
+        from_python(self, type<const ClassType*>())->*m_pm);
+}
+
+template <class ClassType, class MemberType>
+PyObject* setter_function<ClassType, MemberType>::do_call(
+    PyObject* args, PyObject* /* keywords */) const
+{
+    PyObject* self;
+    PyObject* value;
+    if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &self, &value))
+        return 0;
+    
+    typedef typename boost::call_traits<MemberType>::const_reference extract_type;
+    from_python(self, type<ClassType*>())->*m_pm
+        = from_python(value, type<extract_type>());
+    
+    return none();
+}
+
+template <class T, class R, class V, class D>
+PyObject* virtual_function<T,R,V,D>::do_call(PyObject* args, PyObject* keywords) const
+{
+    // If the target object is held by pointer, we must call through the virtual
+    // function pointer to the most-derived override.
+    PyObject* target = PyTuple_GetItem(args, 0);
+    if (target != 0)
+    {
+        extension_instance* self = get_extension_instance(target);
+        if (self->wrapped_objects().size() == 1
+            && !self->wrapped_objects()[0]->held_by_value())
+        {
+            return caller<R>::call(m_virtual_function_ptr, args, keywords);
+        }
+    }
+    return caller<R>::call(m_default_implementation, args, keywords);
+}
+    
+}}} // namespace boost::python::detail
+
+#endif // FUNCTIONS_DWA051400_H_
--- a/include/boost/python/detail/if_else.hpp
+++ b/include/boost/python/detail/if_else.hpp
@@ -0,0 +1,117 @@
+// Copyright David Abrahams 2002. 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 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,395 @@
+// Copyright David Abrahams 2002. 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 INDIRECT_TRAITS_DWA2002131_HPP
+# define INDIRECT_TRAITS_DWA2002131_HPP
+# include <boost/type_traits/is_function.hpp>
+# include <boost/type_traits/detail/ice_and.hpp>
+# include <boost/type_traits/is_reference.hpp>
+# include <boost/type_traits/is_pointer.hpp>
+# include <boost/type_traits/is_class.hpp>
+# include <boost/type_traits/is_const.hpp>
+# include <boost/type_traits/is_volatile.hpp>
+# include <boost/type_traits/remove_cv.hpp>
+# include <boost/type_traits/remove_reference.hpp>
+# include <boost/type_traits/remove_pointer.hpp>
+# include <boost/mpl/if.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+#  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);
+};
+
+#   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
+template<class T>
+struct is_reference_to_const<T const volatile&>
+{
+    static const bool value = true;
+};
+#   endif 
+
+#   if 0 // Corresponding code doesn't work on MSVC yet
+template <class T>
+struct is_reference_to_function
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template <class T>
+struct is_reference_to_function<T&>
+{
+    BOOST_STATIC_CONSTANT(bool, value = is_function<T>::value);
+};
+
+template <class T>
+struct is_reference_to_function<T const&>
+{
+    BOOST_STATIC_CONSTANT(bool, value = is_function<T>::value);
+};
+
+template <class T>
+struct is_reference_to_function<T volatile&>
+{
+    BOOST_STATIC_CONSTANT(bool, value = is_function<T>::value);
+};
+
+template <class T>
+struct is_reference_to_function<T const volatile&>
+{
+    BOOST_STATIC_CONSTANT(bool, value = is_function<T>::value);
+};
+#   endif
+
+template <class T>
+struct is_pointer_to_function
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template <class T>
+struct is_pointer_to_function<T*>
+{
+    // There's no such thing as a pointer-to-cv-function, so we don't need specializations for those
+    BOOST_STATIC_CONSTANT(bool, value = is_function<T>::value);
+};
+
+template <class T>
+struct is_reference_to_non_const
+{
+    BOOST_STATIC_CONSTANT(
+        bool, value = (
+            ::boost::type_traits::ice_and<
+            ::boost::is_reference<T>::value
+            , ::boost::type_traits::ice_not<
+                ::boost::python::detail::is_reference_to_const<T>::value>::value
+            >::value)
+        );
+};
+
+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);
+};
+
+#   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
+template <class T>
+struct is_reference_to_volatile<T const volatile&>
+{
+    static const bool value = true;
+};
+#   endif 
+
+
+template <class T>
+struct is_reference_to_pointer
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template <class T>
+struct is_reference_to_pointer<T*&>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template <class T>
+struct is_reference_to_pointer<T* const&>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template <class T>
+struct is_reference_to_pointer<T* volatile&>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template <class T>
+struct is_reference_to_pointer<T* const volatile&>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template <class T>
+struct is_reference_to_class
+{
+    BOOST_STATIC_CONSTANT(
+        bool, value
+        = (boost::type_traits::ice_and<
+           is_reference<T>::value
+           , is_class<
+                typename remove_cv<
+                    typename remove_reference<T>::type
+                >::type
+             >::value
+         >::value)
+        );
+};
+
+template <class T>
+struct is_pointer_to_class
+{
+    BOOST_STATIC_CONSTANT(
+        bool, value
+        = (boost::type_traits::ice_and<
+           is_pointer<T>::value
+           , is_class<
+                typename remove_cv<
+                    typename remove_pointer<T>::type
+                >::type
+             >::value
+         >::value)
+        );
+};
+
+#  else
+
+typedef char (&inner_yes_type)[3];
+typedef char (&inner_no_type)[2];
+typedef char (&outer_no_type)[1];
+
+template <typename V>
+struct is_const_help
+{
+    typedef typename mpl::if_c<
+        is_const<V>::value
+        , inner_yes_type
+        , inner_no_type
+        >::type type;
+};
+
+template <typename V>
+struct is_volatile_help
+{
+    typedef typename mpl::if_c<
+        is_volatile<V>::value
+        , inner_yes_type
+        , inner_no_type
+        >::type type;
+};
+
+template <typename V>
+struct is_pointer_help
+{
+    typedef typename mpl::if_c<
+        is_pointer<V>::value
+        , inner_yes_type
+        , inner_no_type
+        >::type type;
+};
+
+template <typename V>
+struct is_class_help
+{
+    typedef typename mpl::if_c<
+        is_class<V>::value
+        , inner_yes_type
+        , inner_no_type
+        >::type type;
+};
+
+#   if 0 // doesn't seem to work yet
+template <class T>
+struct is_reference_to_function
+{
+    static T t;
+    BOOST_STATIC_CONSTANT(
+        bool, value
+        = sizeof(::boost::type_traits::is_function_ptr_tester(t)) == sizeof(::boost::type_traits::yes_type));
+#   endif
+
+template <class T>
+struct is_pointer_to_function
+{
+    static T t;
+    BOOST_STATIC_CONSTANT(
+        bool, value
+        = sizeof(::boost::type_traits::is_function_ptr_tester(t)) == sizeof(::boost::type_traits::yes_type));
+};
+
+struct false_helper1
+{
+    template <class T>
+    struct apply
+    {
+        BOOST_STATIC_CONSTANT(bool, value = false);
+    };
+};
+
+template <typename V>
+typename is_const_help<V>::type reference_to_const_helper(V&);    
+outer_no_type
+reference_to_const_helper(...);
+
+template <bool ref = true>
+struct is_reference_to_const_helper1
+{
+    template <class T>
+    struct apply
+    {
+        static T t;
+        BOOST_STATIC_CONSTANT(
+            bool, value
+            = sizeof(reference_to_const_helper(t)) == sizeof(inner_yes_type));
+    };
+};
+
+template <>
+struct is_reference_to_const_helper1<false> : false_helper1
+{
+};
+
+
+template <class T>
+struct is_reference_to_const
+    : is_reference_to_const_helper1<is_reference<T>::value>::template apply<T>
+{
+};
+
+
+
+template <bool ref = true>
+struct is_reference_to_non_const_helper1
+{
+    template <class T>
+    struct apply
+    {
+        static T t;
+        BOOST_STATIC_CONSTANT(
+            bool, value
+            = sizeof(reference_to_const_helper(t)) == sizeof(inner_no_type));
+    };
+};
+
+template <>
+struct is_reference_to_non_const_helper1<false> : false_helper1
+{
+};
+
+
+template <class T>
+struct is_reference_to_non_const
+    : is_reference_to_non_const_helper1<is_reference<T>::value>::template apply<T>
+{
+};
+
+
+template <typename V>
+typename is_volatile_help<V>::type reference_to_volatile_helper(V&);    
+outer_no_type
+reference_to_volatile_helper(...);
+
+template <bool ref = true>
+struct is_reference_to_volatile_helper1
+{
+    template <class T>
+    struct apply
+    {
+        static T t;
+        BOOST_STATIC_CONSTANT(
+            bool, value
+            = sizeof(reference_to_volatile_helper(t)) == sizeof(inner_yes_type));
+    };
+};
+
+template <>
+struct is_reference_to_volatile_helper1<false> : false_helper1
+{
+};
+
+
+template <class T>
+struct is_reference_to_volatile
+    : is_reference_to_volatile_helper1<is_reference<T>::value>::template apply<T>
+{
+};
+
+
+template <typename V>
+typename is_pointer_help<V>::type reference_to_pointer_helper(V&);
+outer_no_type reference_to_pointer_helper(...);
+
+template <class T>
+struct is_reference_to_pointer
+{
+    static T t;
+    BOOST_STATIC_CONSTANT(
+        bool, value
+        = (is_reference<T>::value
+           && sizeof(reference_to_pointer_helper(t)) == sizeof(inner_yes_type))
+        );
+};
+
+template <typename V>
+typename is_class_help<V>::type reference_to_class_helper(V const volatile&);
+outer_no_type reference_to_class_helper(...);
+
+template <class T>
+struct is_reference_to_class
+{
+    static T t;
+    BOOST_STATIC_CONSTANT(
+        bool, value
+        = (is_reference<T>::value
+           && sizeof(reference_to_class_helper(t)) == sizeof(inner_yes_type))
+        );
+};
+
+template <typename V>
+typename is_class_help<V>::type pointer_to_class_helper(V const volatile*);
+outer_no_type pointer_to_class_helper(...);
+
+template <class T>
+struct is_pointer_to_class
+{
+    static T t;
+    BOOST_STATIC_CONSTANT(
+        bool, value
+        = (is_pointer<T>::value
+           && sizeof(pointer_to_class_helper(t)) == sizeof(inner_yes_type))
+        );
+};
+#  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION 
+
+}}} // namespace boost::python::detail
+
+#endif // INDIRECT_TRAITS_DWA2002131_HPP
--- a/include/boost/python/detail/init_function.hpp
+++ b/include/boost/python/detail/init_function.hpp
@@ -0,0 +1,562 @@
+//  (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.
+//
+//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
+//  producing this work.
+//
+//  This file was generated for %d-argument constructors by gen_init_function.python
+
+#ifndef INIT_FUNCTION_DWA052000_H_
+# define INIT_FUNCTION_DWA052000_H_
+
+# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/functions.hpp>
+# include <boost/python/detail/signatures.hpp>
+# include <typeinfo>
+
+namespace boost { namespace python {
+
+namespace detail {
+
+  // parameter_traits - so far, this is a way to pass a const T& when we can be
+  // sure T is not a reference type, and a raw T otherwise. This should be
+  // rolled into boost::call_traits. Ordinarily, parameter_traits would be
+  // written:
+  //
+  //    template <class T> struct parameter_traits
+  //    {
+  //        typedef const T& const_reference;
+  //    };
+  //
+  //    template <class T> struct parameter_traits<T&>
+  //    {
+  //        typedef T& const_reference;
+  //    };
+  //
+  //    template <> struct parameter_traits<void>
+  //    {
+  //        typedef void const_reference;
+  //    };
+  //
+  // ...but since we can't partially specialize on reference types, we need this
+  // long-winded but equivalent incantation.
+
+  // const_ref_selector -- an implementation detail of parameter_traits (below). This uses
+  // the usual "poor man's partial specialization" hack for MSVC. 
+  template <bool is_ref>
+  struct const_ref_selector
+  {
+      template <class T>
+      struct const_ref
+      {
+          typedef const T& type;
+      };
+  };
+
+  template <>
+  struct const_ref_selector<true>
+  {
+      template <class T>
+      struct const_ref
+      {
+          typedef T type;
+      };
+  };
+
+# ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable: 4181)
+# endif // BOOST_MSVC
+  template <class T>
+  struct parameter_traits
+  {
+   private:
+      enum { is_ref = boost::is_reference<T>::value };
+      typedef const_ref_selector<is_ref> selector;
+   public:
+      typedef typename selector::template const_ref<T>::type const_reference;
+  };
+# ifdef BOOST_MSVC
+#  pragma warning(pop)
+# endif // BOOST_MSVC
+
+  // Full spcialization for void
+  template <>
+  struct parameter_traits<void>
+  {
+      typedef void const_reference;
+  };
+
+  struct reference_parameter_base {};
+
+  template <class T>
+  class reference_parameter
+      : public reference_parameter_base
+  {
+   public:
+      typedef typename parameter_traits<T>::const_reference const_reference;
+      reference_parameter(const_reference value)
+          : value(value) {}
+      operator const_reference() { return value; }
+   private:
+      const_reference value;
+  };
+
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+  template <class T>
+  struct unwrap_parameter
+  {
+      typedef typename boost::add_reference<T>::type type;
+  };
+
+  template <class T>
+  struct unwrap_parameter<reference_parameter<T> >
+  {
+      typedef typename reference_parameter<T>::const_reference type;
+  };
+# else
+  template <bool is_wrapped>
+  struct unwrap_parameter_helper
+  {
+      template <class T>
+      struct apply
+      {
+          typedef typename T::const_reference type;
+      };
+  };
+
+  template <>
+  struct unwrap_parameter_helper<false>
+  {
+      template <class T>
+      struct apply
+      {
+          typedef typename add_reference<T>::type type;
+      };
+  };
+
+  template <class T>
+  struct unwrap_parameter
+  {
+      BOOST_STATIC_CONSTANT(
+          bool, is_wrapped = (is_base_and_derived<T,reference_parameter_base>::value));
+      
+      typedef typename unwrap_parameter_helper<
+          is_wrapped
+      >::template apply<T>::type type;
+  };
+# endif 
+  
+class extension_instance;
+class instance_holder_base;
+
+class init;
+template <class T> struct init0;
+template <class T, class A1> struct init1;
+template <class T, class A1, class A2> struct init2;
+template <class T, class A1, class A2, class A3> struct init3;
+template <class T, class A1, class A2, class A3, class A4> struct init4;
+template <class T, class A1, class A2, class A3, class A4, class A5> struct init5;
+template <class T, class A1, class A2, class A3, class A4, class A5, class A6> struct init6;
+template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct init7;
+template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct init8;
+template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct init9;
+template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> struct init10;
+
+template <class T>
+struct init_function
+{
+# ifdef BOOST_MSVC6_OR_EARLIER
+#  define typename
+# endif 
+    static init* create(signature0) {
+        return new init0<T>;
+    }
+
+    template <class A1>
+    static init* create(signature1<A1>) {
+        return new init1<T,
+                       typename detail::parameter_traits<A1>::const_reference>;
+    }
+
+    template <class A1, class A2>
+    static init* create(signature2<A1, A2>) {
+        return new init2<T,
+                       typename detail::parameter_traits<A1>::const_reference,
+                       typename detail::parameter_traits<A2>::const_reference>;
+    }
+
+    template <class A1, class A2, class A3>
+    static init* create(signature3<A1, A2, A3>) {
+        return new init3<T,
+                       typename detail::parameter_traits<A1>::const_reference,
+                       typename detail::parameter_traits<A2>::const_reference,
+                       typename detail::parameter_traits<A3>::const_reference>;
+    }
+
+    template <class A1, class A2, class A3, class A4>
+    static init* create(signature4<A1, A2, A3, A4>) {
+        return new init4<T,
+                       typename detail::parameter_traits<A1>::const_reference,
+                       typename detail::parameter_traits<A2>::const_reference,
+                       typename detail::parameter_traits<A3>::const_reference,
+                       typename detail::parameter_traits<A4>::const_reference>;
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5>
+    static init* create(signature5<A1, A2, A3, A4, A5>) {
+        return new init5<T,
+                       typename detail::parameter_traits<A1>::const_reference,
+                       typename detail::parameter_traits<A2>::const_reference,
+                       typename detail::parameter_traits<A3>::const_reference,
+                       typename detail::parameter_traits<A4>::const_reference,
+                       typename detail::parameter_traits<A5>::const_reference>;
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6>
+    static init* create(signature6<A1, A2, A3, A4, A5, A6>) {
+        return new init6<T,
+                       typename detail::parameter_traits<A1>::const_reference,
+                       typename detail::parameter_traits<A2>::const_reference,
+                       typename detail::parameter_traits<A3>::const_reference,
+                       typename detail::parameter_traits<A4>::const_reference,
+                       typename detail::parameter_traits<A5>::const_reference,
+                       typename detail::parameter_traits<A6>::const_reference>;
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    static init* create(signature7<A1, A2, A3, A4, A5, A6, A7>) {
+        return new init7<T,
+                       typename detail::parameter_traits<A1>::const_reference,
+                       typename detail::parameter_traits<A2>::const_reference,
+                       typename detail::parameter_traits<A3>::const_reference,
+                       typename detail::parameter_traits<A4>::const_reference,
+                       typename detail::parameter_traits<A5>::const_reference,
+                       typename detail::parameter_traits<A6>::const_reference,
+                       typename detail::parameter_traits<A7>::const_reference>;
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    static init* create(signature8<A1, A2, A3, A4, A5, A6, A7, A8>) {
+        return new init8<T,
+                       typename detail::parameter_traits<A1>::const_reference,
+                       typename detail::parameter_traits<A2>::const_reference,
+                       typename detail::parameter_traits<A3>::const_reference,
+                       typename detail::parameter_traits<A4>::const_reference,
+                       typename detail::parameter_traits<A5>::const_reference,
+                       typename detail::parameter_traits<A6>::const_reference,
+                       typename detail::parameter_traits<A7>::const_reference,
+                       typename detail::parameter_traits<A8>::const_reference>;
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    static init* create(signature9<A1, A2, A3, A4, A5, A6, A7, A8, A9>) {
+        return new init9<T,
+                       typename detail::parameter_traits<A1>::const_reference,
+                       typename detail::parameter_traits<A2>::const_reference,
+                       typename detail::parameter_traits<A3>::const_reference,
+                       typename detail::parameter_traits<A4>::const_reference,
+                       typename detail::parameter_traits<A5>::const_reference,
+                       typename detail::parameter_traits<A6>::const_reference,
+                       typename detail::parameter_traits<A7>::const_reference,
+                       typename detail::parameter_traits<A8>::const_reference,
+                       typename detail::parameter_traits<A9>::const_reference>;
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
+    static init* create(signature10<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>) {
+        return new init10<T,
+                       typename detail::parameter_traits<A1>::const_reference,
+                       typename detail::parameter_traits<A2>::const_reference,
+                       typename detail::parameter_traits<A3>::const_reference,
+                       typename detail::parameter_traits<A4>::const_reference,
+                       typename detail::parameter_traits<A5>::const_reference,
+                       typename detail::parameter_traits<A6>::const_reference,
+                       typename detail::parameter_traits<A7>::const_reference,
+                       typename detail::parameter_traits<A8>::const_reference,
+                       typename detail::parameter_traits<A9>::const_reference,
+                       typename detail::parameter_traits<A10>::const_reference>;
+    }
+#ifdef BOOST_MSVC6_OR_EARLIER
+# undef typename
+#endif 
+};
+
+class BOOST_PYTHON_DECL init : public function
+{
+private: // override function hook
+    PyObject* do_call(PyObject* args, PyObject* keywords) const;
+private:
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* tail_args, PyObject* keywords) const = 0;
+};
+
+
+template <class T>
+struct init0 : init
+{
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
+    {
+        if (!PyArg_ParseTuple(args, const_cast<char*>("")))
+            throw_argument_error();
+        return new T(self
+            );
+    }
+    const char* description() const
+        { return typeid(void (*)(T&)).name(); }
+};
+
+template <class T, class A1>
+struct init1 : init
+{
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
+    {
+        PyObject* a1;
+        if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &a1))
+            throw_argument_error();
+        return new T(self,
+            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>()))
+            );
+    }
+    const char* description() const
+        { return typeid(void (*)(T&, A1)).name(); }
+};
+
+template <class T, class A1, class A2>
+struct init2 : init
+{
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
+    {
+        PyObject* a1;
+        PyObject* a2;
+        if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &a1, &a2))
+            throw_argument_error();
+        return new T(self,
+            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
+            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>()))
+            );
+    }
+    const char* description() const
+        { return typeid(void (*)(T&, A1, A2)).name(); }
+};
+
+template <class T, class A1, class A2, class A3>
+struct init3 : init
+{
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
+    {
+        PyObject* a1;
+        PyObject* a2;
+        PyObject* a3;
+        if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &a1, &a2, &a3))
+            throw_argument_error();
+        return new T(self,
+            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
+            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
+            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>()))
+            );
+    }
+    const char* description() const
+        { return typeid(void (*)(T&, A1, A2, A3)).name(); }
+};
+
+template <class T, class A1, class A2, class A3, class A4>
+struct init4 : init
+{
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
+    {
+        PyObject* a1;
+        PyObject* a2;
+        PyObject* a3;
+        PyObject* a4;
+        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &a1, &a2, &a3, &a4))
+            throw_argument_error();
+        return new T(self,
+            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
+            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
+            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
+            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>()))
+            );
+    }
+    const char* description() const
+        { return typeid(void (*)(T&, A1, A2, A3, A4)).name(); }
+};
+
+template <class T, class A1, class A2, class A3, class A4, class A5>
+struct init5 : init
+{
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
+    {
+        PyObject* a1;
+        PyObject* a2;
+        PyObject* a3;
+        PyObject* a4;
+        PyObject* a5;
+        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOO"), &a1, &a2, &a3, &a4, &a5))
+            throw_argument_error();
+        return new T(self,
+            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
+            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
+            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
+            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
+            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>()))
+            );
+    }
+    const char* description() const
+        { return typeid(void (*)(T&, A1, A2, A3, A4, A5)).name(); }
+};
+
+template <class T, class A1, class A2, class A3, class A4, class A5, class A6>
+struct init6 : init
+{
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
+    {
+        PyObject* a1;
+        PyObject* a2;
+        PyObject* a3;
+        PyObject* a4;
+        PyObject* a5;
+        PyObject* a6;
+        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6))
+            throw_argument_error();
+        return new T(self,
+            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
+            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
+            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
+            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
+            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
+            boost::python::detail::reference_parameter<A6>(from_python(a6, type<A6>()))
+            );
+    }
+    const char* description() const
+        { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6)).name(); }
+};
+
+template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+struct init7 : init
+{
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
+    {
+        PyObject* a1;
+        PyObject* a2;
+        PyObject* a3;
+        PyObject* a4;
+        PyObject* a5;
+        PyObject* a6;
+        PyObject* a7;
+        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7))
+            throw_argument_error();
+        return new T(self,
+            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
+            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
+            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
+            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
+            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
+            boost::python::detail::reference_parameter<A6>(from_python(a6, type<A6>())),
+            boost::python::detail::reference_parameter<A7>(from_python(a7, type<A7>()))
+            );
+    }
+    const char* description() const
+        { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7)).name(); }
+};
+
+template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+struct init8 : init
+{
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
+    {
+        PyObject* a1;
+        PyObject* a2;
+        PyObject* a3;
+        PyObject* a4;
+        PyObject* a5;
+        PyObject* a6;
+        PyObject* a7;
+        PyObject* a8;
+        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
+            throw_argument_error();
+        return new T(self,
+            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
+            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
+            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
+            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
+            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
+            boost::python::detail::reference_parameter<A6>(from_python(a6, type<A6>())),
+            boost::python::detail::reference_parameter<A7>(from_python(a7, type<A7>())),
+            boost::python::detail::reference_parameter<A8>(from_python(a8, type<A8>()))
+            );
+    }
+    const char* description() const
+        { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7, A8)).name(); }
+};
+
+template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+struct init9 : init
+{
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
+    {
+        PyObject* a1;
+        PyObject* a2;
+        PyObject* a3;
+        PyObject* a4;
+        PyObject* a5;
+        PyObject* a6;
+        PyObject* a7;
+        PyObject* a8;
+        PyObject* a9;
+        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
+            throw_argument_error();
+        return new T(self,
+            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
+            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
+            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
+            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
+            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
+            boost::python::detail::reference_parameter<A6>(from_python(a6, type<A6>())),
+            boost::python::detail::reference_parameter<A7>(from_python(a7, type<A7>())),
+            boost::python::detail::reference_parameter<A8>(from_python(a8, type<A8>())),
+            boost::python::detail::reference_parameter<A9>(from_python(a9, type<A9>()))
+            );
+    }
+    const char* description() const
+        { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7, A8, A9)).name(); }
+};
+
+template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
+struct init10 : init
+{
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
+    {
+        PyObject* a1;
+        PyObject* a2;
+        PyObject* a3;
+        PyObject* a4;
+        PyObject* a5;
+        PyObject* a6;
+        PyObject* a7;
+        PyObject* a8;
+        PyObject* a9;
+        PyObject* a10;
+        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
+            throw_argument_error();
+        return new T(self,
+            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
+            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
+            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
+            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
+            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
+            boost::python::detail::reference_parameter<A6>(from_python(a6, type<A6>())),
+            boost::python::detail::reference_parameter<A7>(from_python(a7, type<A7>())),
+            boost::python::detail::reference_parameter<A8>(from_python(a8, type<A8>())),
+            boost::python::detail::reference_parameter<A9>(from_python(a9, type<A9>())),
+            boost::python::detail::reference_parameter<A10>(from_python(a10, type<A10>()))
+            );
+    }
+    const char* description() const
+        { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)).name(); }
+};
+
+}}} // namespace boost::python::detail
+
+#endif // INIT_FUNCTION_DWA052000_H_
--- a/include/boost/python/detail/make_tuple.hpp
+++ b/include/boost/python/detail/make_tuple.hpp
@@ -0,0 +1,31 @@
+# // Copyright David Abrahams 2002. 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.
+
+#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_PYTHON_UNARY_ENUM(N, class A)>
+    tuple
+    make_tuple(BOOST_PYTHON_BINARY_ENUM(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
--- a/Show More
+++ b/Show More