diff --git a/include/boost/python/callback.hpp b/include/boost/python/callback.hpp
deleted file mode 100644
index 7240b5b7..00000000
--- a/include/boost/python/callback.hpp
+++ /dev/null
@@ -1,829 +0,0 @@
-//  (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_
diff --git a/include/boost/python/caller.hpp b/include/boost/python/caller.hpp
deleted file mode 100644
index 35b2d618..00000000
--- a/include/boost/python/caller.hpp
+++ /dev/null
@@ -1,1279 +0,0 @@
-//  (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
-
-#ifndef CALLER_DWA05090_H_
-# define CALLER_DWA05090_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/config.hpp>
-# include <boost/python/detail/signatures.hpp>
-# include <boost/python/detail/none.hpp>
-
-namespace boost { namespace python {
-
-// Calling C++ from Python
-template <class R>
-struct caller
-{
-    template <class T>
-    static PyObject* call(R (T::*pmf)(), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &self))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)());
-    }
-
-    template <class T, class A1>
-    static PyObject* call(R (T::*pmf)(A1), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &self, &a1))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)(from_python(a1, type<A1>())));
-    }
-
-    template <class T, class A1, class A2>
-    static PyObject* call(R (T::*pmf)(A1, A2), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &self, &a1, &a2))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>())));
-    }
-
-    template <class T, class A1, class A2, class A3>
-    static PyObject* call(R (T::*pmf)(A1, A2, A3), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &self, &a1, &a2, &a3))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>())));
-    }
-
-    template <class T, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (T::*pmf)(A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOO"), &self, &a1, &a2, &a3, &a4))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>())));
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOO"), &self, &a1, &a2, &a3, &a4, &a5))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>())));
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5, class A6>
-    static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5, A6), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>())));
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5, A6, A7), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>())));
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        PyObject* a8;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()),
-                        from_python(a8, type<A8>())));
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8, A9), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        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*>("OOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()),
-                        from_python(a8, type<A8>()),
-                        from_python(a9, type<A9>())));
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        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*>("OOOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()),
-                        from_python(a8, type<A8>()),
-                        from_python(a9, type<A9>()),
-                        from_python(a10, type<A10>())));
-    }
-
-
-    template <class T>
-    static PyObject* call(R (T::*pmf)() const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &self))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)());
-    }
-
-    template <class T, class A1>
-    static PyObject* call(R (T::*pmf)(A1) const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &self, &a1))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)(from_python(a1, type<A1>())));
-    }
-
-    template <class T, class A1, class A2>
-    static PyObject* call(R (T::*pmf)(A1, A2) const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &self, &a1, &a2))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>())));
-    }
-
-    template <class T, class A1, class A2, class A3>
-    static PyObject* call(R (T::*pmf)(A1, A2, A3) const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &self, &a1, &a2, &a3))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>())));
-    }
-
-    template <class T, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (T::*pmf)(A1, A2, A3, A4) const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOO"), &self, &a1, &a2, &a3, &a4))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>())));
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOO"), &self, &a1, &a2, &a3, &a4, &a5))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>())));
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5, class A6>
-    static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5, A6) const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>())));
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5, A6, A7) const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>())));
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8) const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        PyObject* a8;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()),
-                        from_python(a8, type<A8>())));
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        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*>("OOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()),
-                        from_python(a8, type<A8>()),
-                        from_python(a9, type<A9>())));
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        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*>("OOOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()),
-                        from_python(a8, type<A8>()),
-                        from_python(a9, type<A9>()),
-                        from_python(a10, type<A10>())));
-    }
-
-    // Free functions
-    static PyObject* call(R (*f)(), PyObject* args, PyObject* /* keywords */ ) {
-        if (!PyArg_ParseTuple(args, const_cast<char*>("")))
-            return 0;
-        return to_python(f());
-    }
-
-    template <class A1>
-    static PyObject* call(R (*f)(A1), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* a1;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &a1))
-            return 0;
-        return to_python(f(from_python(a1, type<A1>())));
-    }
-
-    template <class A1, class A2>
-    static PyObject* call(R (*f)(A1, A2), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* a1;
-        PyObject* a2;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &a1, &a2))
-            return 0;
-        return to_python(f(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>())));
-    }
-
-    template <class A1, class A2, class A3>
-    static PyObject* call(R (*f)(A1, A2, A3), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &a1, &a2, &a3))
-            return 0;
-        return to_python(f(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>())));
-    }
-
-    template <class A1, class A2, class A3, class A4>
-    static PyObject* call(R (*f)(A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &a1, &a2, &a3, &a4))
-            return 0;
-        return to_python(f(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>())));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (*f)(A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOO"), &a1, &a2, &a3, &a4, &a5))
-            return 0;
-        return to_python(f(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>())));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    static PyObject* call(R (*f)(A1, A2, A3, A4, A5, A6), PyObject* args, PyObject* /* keywords */ ) {
-        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))
-            return 0;
-        return to_python(f(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>())));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    static PyObject* call(R (*f)(A1, A2, A3, A4, A5, A6, A7), PyObject* args, PyObject* /* keywords */ ) {
-        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))
-            return 0;
-        return to_python(f(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>())));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    static PyObject* call(R (*f)(A1, A2, A3, A4, A5, A6, A7, A8), PyObject* args, PyObject* /* keywords */ ) {
-        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))
-            return 0;
-        return to_python(f(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()),
-                        from_python(a8, type<A8>())));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    static PyObject* call(R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9), PyObject* args, PyObject* /* keywords */ ) {
-        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))
-            return 0;
-        return to_python(f(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()),
-                        from_python(a8, type<A8>()),
-                        from_python(a9, type<A9>())));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    static PyObject* call(R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), PyObject* args, PyObject* /* keywords */ ) {
-        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))
-            return 0;
-        return to_python(f(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()),
-                        from_python(a8, type<A8>()),
-                        from_python(a9, type<A9>()),
-                        from_python(a10, type<A10>())));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
-    static PyObject* call(R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        PyObject* a8;
-        PyObject* a9;
-        PyObject* a10;
-        PyObject* a11;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10, &a11))
-            return 0;
-        return to_python(f(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()),
-                        from_python(a8, type<A8>()),
-                        from_python(a9, type<A9>()),
-                        from_python(a10, type<A10>()),
-                        from_python(a11, type<A11>())));
-    }
-
-};
-                           
-template <>
-struct caller<void>
-{
-    template <class T>
-    static PyObject* call(void (T::*pmf)(), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &self))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)();
-        return detail::none();
-    }
-
-    template <class T, class A1>
-    static PyObject* call(void (T::*pmf)(A1), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &self, &a1))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)(from_python(a1, type<A1>()));
-        return detail::none();
-    }
-
-    template <class T, class A1, class A2>
-    static PyObject* call(void (T::*pmf)(A1, A2), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &self, &a1, &a2))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()));
-        return detail::none();
-    }
-
-    template <class T, class A1, class A2, class A3>
-    static PyObject* call(void (T::*pmf)(A1, A2, A3), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &self, &a1, &a2, &a3))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()));
-        return detail::none();
-    }
-
-    template <class T, class A1, class A2, class A3, class A4>
-    static PyObject* call(void (T::*pmf)(A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOO"), &self, &a1, &a2, &a3, &a4))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()));
-        return detail::none();
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOO"), &self, &a1, &a2, &a3, &a4, &a5))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()));
-        return detail::none();
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5, class A6>
-    static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5, A6), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()));
-        return detail::none();
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5, A6, A7), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()));
-        return detail::none();
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        PyObject* a8;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()),
-                        from_python(a8, type<A8>()));
-        return detail::none();
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8, A9), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        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*>("OOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()),
-                        from_python(a8, type<A8>()),
-                        from_python(a9, type<A9>()));
-        return detail::none();
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        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*>("OOOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()),
-                        from_python(a8, type<A8>()),
-                        from_python(a9, type<A9>()),
-                        from_python(a10, type<A10>()));
-        return detail::none();
-    }
-
-
-    template <class T>
-    static PyObject* call(void (T::*pmf)() const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &self))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)();
-        return detail::none();
-    }
-
-    template <class T, class A1>
-    static PyObject* call(void (T::*pmf)(A1) const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &self, &a1))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)(from_python(a1, type<A1>()));
-        return detail::none();
-    }
-
-    template <class T, class A1, class A2>
-    static PyObject* call(void (T::*pmf)(A1, A2) const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &self, &a1, &a2))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()));
-        return detail::none();
-    }
-
-    template <class T, class A1, class A2, class A3>
-    static PyObject* call(void (T::*pmf)(A1, A2, A3) const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &self, &a1, &a2, &a3))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()));
-        return detail::none();
-    }
-
-    template <class T, class A1, class A2, class A3, class A4>
-    static PyObject* call(void (T::*pmf)(A1, A2, A3, A4) const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOO"), &self, &a1, &a2, &a3, &a4))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()));
-        return detail::none();
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOO"), &self, &a1, &a2, &a3, &a4, &a5))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()));
-        return detail::none();
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5, class A6>
-    static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5, A6) const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()));
-        return detail::none();
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5, A6, A7) const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()));
-        return detail::none();
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8) const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        PyObject* a8;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()),
-                        from_python(a8, type<A8>()));
-        return detail::none();
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        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*>("OOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()),
-                        from_python(a8, type<A8>()),
-                        from_python(a9, type<A9>()));
-        return detail::none();
-    }
-
-    template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const, PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* self;
-        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*>("OOOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
-            return 0;
-        T& target = from_python(self, type<T&>());
-        (target.*pmf)(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()),
-                        from_python(a8, type<A8>()),
-                        from_python(a9, type<A9>()),
-                        from_python(a10, type<A10>()));
-        return detail::none();
-    }
-
-
-    // Free functions
-    static PyObject* call(void (*f)(), PyObject* args, PyObject* /* keywords */ ) {
-        if (!PyArg_ParseTuple(args, const_cast<char*>("")))
-            return 0;
-        f();
-        return detail::none();
-    }
-
-    template <class A1>
-    static PyObject* call(void (*f)(A1), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* a1;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &a1))
-            return 0;
-        f(from_python(a1, type<A1>()));
-        return detail::none();
-    }
-
-    template <class A1, class A2>
-    static PyObject* call(void (*f)(A1, A2), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* a1;
-        PyObject* a2;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &a1, &a2))
-            return 0;
-        f(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()));
-        return detail::none();
-    }
-
-    template <class A1, class A2, class A3>
-    static PyObject* call(void (*f)(A1, A2, A3), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &a1, &a2, &a3))
-            return 0;
-        f(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()));
-        return detail::none();
-    }
-
-    template <class A1, class A2, class A3, class A4>
-    static PyObject* call(void (*f)(A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &a1, &a2, &a3, &a4))
-            return 0;
-        f(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()));
-        return detail::none();
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(void (*f)(A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOO"), &a1, &a2, &a3, &a4, &a5))
-            return 0;
-        f(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()));
-        return detail::none();
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    static PyObject* call(void (*f)(A1, A2, A3, A4, A5, A6), PyObject* args, PyObject* /* keywords */ ) {
-        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))
-            return 0;
-        f(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()));
-        return detail::none();
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    static PyObject* call(void (*f)(A1, A2, A3, A4, A5, A6, A7), PyObject* args, PyObject* /* keywords */ ) {
-        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))
-            return 0;
-        f(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()));
-        return detail::none();
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    static PyObject* call(void (*f)(A1, A2, A3, A4, A5, A6, A7, A8), PyObject* args, PyObject* /* keywords */ ) {
-        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))
-            return 0;
-        f(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()),
-                        from_python(a8, type<A8>()));
-        return detail::none();
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    static PyObject* call(void (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9), PyObject* args, PyObject* /* keywords */ ) {
-        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))
-            return 0;
-        f(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()),
-                        from_python(a8, type<A8>()),
-                        from_python(a9, type<A9>()));
-        return detail::none();
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    static PyObject* call(void (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), PyObject* args, PyObject* /* keywords */ ) {
-        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))
-            return 0;
-        f(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()),
-                        from_python(a8, type<A8>()),
-                        from_python(a9, type<A9>()),
-                        from_python(a10, type<A10>()));
-        return detail::none();
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
-    static PyObject* call(void (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11), PyObject* args, PyObject* /* keywords */ ) {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        PyObject* a8;
-        PyObject* a9;
-        PyObject* a10;
-        PyObject* a11;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10, &a11))
-            return 0;
-        f(from_python(a1, type<A1>()),
-                        from_python(a2, type<A2>()),
-                        from_python(a3, type<A3>()),
-                        from_python(a4, type<A4>()),
-                        from_python(a5, type<A5>()),
-                        from_python(a6, type<A6>()),
-                        from_python(a7, type<A7>()),
-                        from_python(a8, type<A8>()),
-                        from_python(a9, type<A9>()),
-                        from_python(a10, type<A10>()),
-                        from_python(a11, type<A11>()));
-        return detail::none();
-    }
-
-};
-
-}} // namespace boost::python
-
-#endif
diff --git a/include/boost/python/class_builder.hpp b/include/boost/python/class_builder.hpp
deleted file mode 100644
index 7ef843c4..00000000
--- a/include/boost/python/class_builder.hpp
+++ /dev/null
@@ -1,156 +0,0 @@
-#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);
-    }
-    
-    ~class_builder()
-    {}
-    
-    // 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_
diff --git a/include/boost/python/classes.hpp b/include/boost/python/classes.hpp
deleted file mode 100644
index d38fbba5..00000000
--- a/include/boost/python/classes.hpp
+++ /dev/null
@@ -1,527 +0,0 @@
-//  (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 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();
-
- 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 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:
-      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);
-    
-    // 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;
-    
- 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;
-    
- private: // noncopyable, without the size bloat
-    class_t(const class_t<T>&);
-    void operator=(const class_t&);
-};
-
-// 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> > > > > >,
-      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>
-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;
-}
-
-void 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
-{
-    adjust_slice_indices(obj, start, finish);    
-    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
-{
-    adjust_slice_indices(obj, start, finish);
-    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();
-}
-
-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
diff --git a/include/boost/python/conversions.hpp b/include/boost/python/conversions.hpp
deleted file mode 100644
index d11f7f14..00000000
--- a/include/boost/python/conversions.hpp
+++ /dev/null
@@ -1,325 +0,0 @@
-//  (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 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/smart_ptr.hpp>
-# include <boost/python/errors.hpp>
-# include <string>
-
-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 boost::python
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-//
-// Converters
-//
-PyObject* to_python(long);
-long from_python(PyObject* p, boost::python::type<long>);
-long from_python(PyObject* p, boost::python::type<const long&>);
-
-PyObject* to_python(unsigned long);
-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);
-int from_python(PyObject*, boost::python::type<int>);
-int from_python(PyObject*, boost::python::type<const int&>);
-    
-PyObject* to_python(unsigned int);
-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);
-short from_python(PyObject*, boost::python::type<short>);
-short from_python(PyObject*, boost::python::type<const short&>);
-    
-PyObject* to_python(unsigned short);
-unsigned short from_python(PyObject*, boost::python::type<unsigned short>);
-unsigned short from_python(PyObject*, boost::python::type<const unsigned short&>);
-
-PyObject* to_python(signed char);
-signed char from_python(PyObject*, boost::python::type<signed char>);
-signed char from_python(PyObject*, boost::python::type<const signed char&>);
-
-PyObject* to_python(unsigned char);
-unsigned char from_python(PyObject*, boost::python::type<unsigned char>);
-unsigned char from_python(PyObject*, boost::python::type<const unsigned char&>);
-
-PyObject* to_python(float);
-float from_python(PyObject*, boost::python::type<float>);
-float from_python(PyObject*, boost::python::type<const float&>);
-    
-PyObject* to_python(double);
-double from_python(PyObject*, boost::python::type<double>);
-double from_python(PyObject*, boost::python::type<const double&>);
-    
-PyObject* to_python(bool);
-bool from_python(PyObject*, boost::python::type<bool>);
-bool from_python(PyObject*, boost::python::type<const bool&>);
-
-PyObject* to_python(void);
-void from_python(PyObject*, boost::python::type<void>);
-
-PyObject* to_python(const char* s);
-const char* from_python(PyObject*, boost::python::type<const char*>);
-
-PyObject* to_python(const std::string& s);
-std::string from_python(PyObject*, boost::python::type<std::string>);
-std::string from_python(PyObject*, boost::python::type<const std::string&>);
-
-// 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_MSVC6_OR_EARLIER)
-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
-//
-
-#ifndef BOOST_MSVC6_OR_EARLIER
-inline PyObject* to_python(double d)
-{
-    return PyFloat_FromDouble(d);
-}
-
-inline PyObject* to_python(float f)
-{
-    return PyFloat_FromDouble(f);
-}
-#endif // BOOST_MSVC6_OR_EARLIER
-
-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 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_
diff --git a/include/boost/python/detail/base_object.hpp b/include/boost/python/detail/base_object.hpp
deleted file mode 100644
index f8ed665b..00000000
--- a/include/boost/python/detail/base_object.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//  (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 BASE_OBJECT_DWA051600_H_
-# define BASE_OBJECT_DWA051600_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/signatures.hpp> // really just for type<>
-# 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 python_type>
-struct base_object : python_type
-{
-    typedef python_type 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;
-
-
-//
-// class_t template member function implementations 
-//
-template <class python_type>
-base_object<python_type>::base_object(PyTypeObject* type_obj)
-{
-    base_python_type* bp = this;
-#if !defined(_MSC_VER) || defined(__STLPORT)
-    std::
-#endif
-		memset(bp, 0, sizeof(base_python_type));
-    ob_refcnt = 1;
-    ob_type = type_obj;
-    Py_INCREF(type_obj);
-}
-
-template <class python_type>
-inline base_object<python_type>::~base_object()
-{
-    Py_DECREF(ob_type);
-}
-
-}}} // namespace boost::python::detail
-
-#endif // BASE_OBJECT_DWA051600_H_
diff --git a/include/boost/python/detail/cast.hpp b/include/boost/python/detail/cast.hpp
deleted file mode 100644
index a6f2f046..00000000
--- a/include/boost/python/detail/cast.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-//  (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_
-
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/operators.hpp>
-
-namespace boost { namespace python {
-
-namespace detail {
-  // The default way of converting a PyObject* or PyTypeObject* to a T*
-  template <class T>
-  struct downcast_traits
-  {
-      template <class U>
-      static T* cast(U* p) { return static_cast<T*>(p); }
-  };
-
-  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 : boost::dereferenceable<downcast<T>, T*>
-{
-    downcast(PyObject* p)
-        : m_p(detail::downcast_traits<T>::cast(detail::as_base_object((T*)0, p)))
-        {}
-    
-    downcast(const PyObject* p)
-        : m_p(detail::downcast_traits<T>::cast(detail::as_base_object((const T*)0, p)))
-        {}
-    
-    downcast(PyTypeObject* p)
-        : m_p(detail::downcast_traits<T>::cast(p))
-        {}
-    
-    downcast(const PyTypeObject* p)
-        : m_p(detail::downcast_traits<T>::cast(p))
-        {}
-    
-    operator T*() const { return m_p; }
-    T* get() const { return m_p; }
-    T& operator*() const { return *m_p; }
- private:
-    T* m_p;
-};
-
-}} // namespace boost::python
-
-#endif // CAST_DWA052500_H_
diff --git a/include/boost/python/detail/config.hpp b/include/boost/python/detail/config.hpp
deleted file mode 100644
index faf52ee4..00000000
--- a/include/boost/python/detail/config.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-//  (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 CONFIG_DWA052200_H_
-# define CONFIG_DWA052200_H_
-
-# include <boost/config.hpp>
-# include <cstddef>
-
-# 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)
-
-# endif
-
-// Work around the broken library implementation/strict ansi checking on some
-// EDG-based compilers (e.g. alpha), which incorrectly warn that the result of
-// offsetof() is not an integer constant expression.
-# if defined(__DECCXX_VER) && __DECCXX_VER <= 60290024
-#  define BOOST_OFFSETOF(s_name, s_member) \
-        ((size_t)__INTADDR__(&(((s_name *)0)->s_member)))
-# else
-#  define BOOST_OFFSETOF(s_name, s_member) \
-        offsetof(s_name, s_member)
-# 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.
-# if defined(BOOST_MSVC6_OR_EARLIER) && !defined(__STLPORT)
-#  define BOOST_CSTD_
-# else
-#  define BOOST_CSTD_ std
-# endif
-
-#endif // CONFIG_DWA052200_H_
diff --git a/include/boost/python/detail/extension_class.hpp b/include/boost/python/detail/extension_class.hpp
deleted file mode 100644
index 0e2e3427..00000000
--- a/include/boost/python/detail/extension_class.hpp
+++ /dev/null
@@ -1,832 +0,0 @@
-//  (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 automatically generated for 5-argument constructors by
-//  gen_extclass.python
-
-#ifndef EXTENSION_CLASS_DWA052000_H_
-# define EXTENSION_CLASS_DWA052000_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/classes.hpp>
-# include <vector>
-# include <boost/python/detail/none.hpp>
-# include <boost/python/objects.hpp>
-# include <boost/python/detail/functions.hpp>
-# include <memory>
-# include <boost/python/detail/init_function.hpp>
-# include <typeinfo>
-# include <boost/smart_ptr.hpp>
-
-namespace boost { namespace python {
-
-// forward declarations
-template <long which, class operand> struct operators;
-template <class T> struct left_operand;
-template <class T> struct right_operand;
-
-enum without_downcast_t { without_downcast };
-
-namespace detail {
-
-// forward declarations
-class extension_instance;
-class extension_class_base;
-template <class T> class instance_holder;
-template <class T, class U> class instance_value_holder;
-template <class ref, class T> class instance_ptr_holder;
-template <class Specified> struct operand_select;
-  template <long> struct choose_op;
-  template <long> struct choose_rop;
-  template <long> struct choose_unary_op;
-  template <long> struct define_operator;
-
-meta_class<extension_instance>* extension_meta_class();
-extension_instance* get_extension_instance(PyObject* p);
-void report_missing_instance_data(extension_instance*, class_t<extension_instance>*, const std::type_info&);
-void report_missing_ptr_data(extension_instance*, class_t<extension_instance>*, const std::type_info&);
-void report_missing_class_object(const std::type_info&);
-void report_released_smart_pointer(const std::type_info&);
-    
-template <class T>
-T* check_non_null(T* p)
-{
-    if (p == 0)
-        report_released_smart_pointer(typeid(T));
-    return p;
-}
-
-template <class T> class held_instance;
-
-typedef void* (*conversion_function_ptr)(void*);
-
-struct base_class_info
-{
-    base_class_info(extension_class_base* t, conversion_function_ptr f)
-        :class_object(t), convert(f)
-        {}
-    
-    extension_class_base* class_object;
-    conversion_function_ptr convert;
-};
-
-typedef base_class_info derived_class_info;
-
-struct add_operator_base;
-
-class extension_class_base : public class_t<extension_instance>
-{
- public:
-    extension_class_base(const char* name);
-    
- public:
-    // the purpose of try_class_conversions() and its related functions 
-    // is explained in extclass.cpp
-    void* try_class_conversions(instance_holder_base*) const;
-    void* try_base_class_conversions(instance_holder_base*) const;
-    void* try_derived_class_conversions(instance_holder_base*) const;
-
-    void set_attribute(const char* name, PyObject* x);
-    void set_attribute(const char* name, ref x);
-    
- private:
-    virtual void* extract_object_from_holder(instance_holder_base* v) const = 0;
-    virtual std::vector<base_class_info> const& base_classes() const = 0;
-    virtual std::vector<derived_class_info> const& derived_classes() const = 0;
-
- protected:
-    friend struct add_operator_base;
-    void add_method(reference<function> method, const char* name);
-    void add_method(function* method, const char* name);
-    
-    void add_constructor_object(function*);
-    void add_setter_method(function*, const char* name);
-    void add_getter_method(function*, const char* name);
-};
-
-template <class T>
-class class_registry
-{
- public:
-    static extension_class_base* class_object()
-        { return static_class_object; }
-
-    // Register/unregister the Python class object corresponding to T
-    static void register_class(extension_class_base*);
-    static void unregister_class(extension_class_base*);
-
-    // Establish C++ inheritance relationships
-    static void register_base_class(base_class_info const&);
-    static void register_derived_class(derived_class_info const&);
-
-    // Query the C++ inheritance relationships
-    static std::vector<base_class_info> const& base_classes();
-    static std::vector<derived_class_info> const& derived_classes();
- private:
-    static extension_class_base* static_class_object;
-    static std::vector<base_class_info> static_base_class_info;
-    static std::vector<derived_class_info> static_derived_class_info;
-};
-
-}}} // namespace boost::python::detail
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-
-// This class' only job is to define from_python and to_python converters for T
-// and U. T is the class the user really intends to wrap. U is a class derived
-// from T with some virtual function overriding boilerplate, or if there are no
-// virtual functions, U = held_instance<T>.
-template <class T, class U = boost::python::detail::held_instance<T> >
-class python_extension_class_converters
-{
- public:
-    // Get an object which can be used to convert T to/from python. This is used
-    // as a kind of concept check by the global template
-    //
-    //     PyObject* to_python(const T& x)
-    //
-    // below this class, to prevent the confusing messages that would otherwise
-    // pop up. Now, if T hasn't been wrapped as an extension class, the user
-    // will see an error message about the lack of an eligible
-    // py_extension_class_converters() function.
-    friend python_extension_class_converters py_extension_class_converters(boost::python::type<T>)
-    { 
-        return python_extension_class_converters();
-    }
-
-    // This is a member function because in a conforming implementation, friend
-    // funcitons defined inline in the class body are all instantiated as soon
-    // as the enclosing class is instantiated. If T is not copyable, that causes
-    // a compiler error. Instead, we access this function through the global
-    // template 
-    //
-    //     PyObject* to_python(const T& x)
-    //
-    // defined below this class. Since template functions are instantiated only
-    // on demand, errors will be avoided unless T is noncopyable and the user
-    // writes code which causes us to try to copy a T.
-    PyObject* to_python(const T& x) const
-    {
-        boost::python::reference<boost::python::detail::extension_instance> result(create_instance());
-        result->add_implementation(
-            std::auto_ptr<boost::python::detail::instance_holder_base>(
-                new boost::python::detail::instance_value_holder<T,U>(result.get(), x)));
-        return result.release();
-    }
-    
-    // Convert to T*
-    friend T* from_python(PyObject* obj, boost::python::type<T*>)
-    {
-        // downcast to an extension_instance, then find the actual T
-        boost::python::detail::extension_instance* self = boost::python::detail::get_extension_instance(obj);
-        typedef std::vector<boost::python::detail::instance_holder_base*>::const_iterator iterator;
-        for (iterator p = self->wrapped_objects().begin();
-             p != self->wrapped_objects().end(); ++p)
-        {
-            boost::python::detail::instance_holder<T>* held = dynamic_cast<boost::python::detail::instance_holder<T>*>(*p);
-            if (held != 0)
-                return held->target();
-
-            // see extclass.cpp for an explanation of try_class_conversions()
-            void* target = boost::python::detail::class_registry<T>::class_object()->try_class_conversions(*p);
-            if(target) 
-                return static_cast<T*>(target);
-        }
-        boost::python::detail::report_missing_instance_data(self, boost::python::detail::class_registry<T>::class_object(), typeid(T));
-        throw boost::python::argument_error();
-    }
-
-    // Convert to PtrType, where PtrType can be dereferenced to obtain a T.
-    template <class PtrType>
-    static PtrType& ptr_from_python(PyObject* obj, boost::python::type<PtrType>)
-    {
-        // downcast to an extension_instance, then find the actual T
-        boost::python::detail::extension_instance* self = boost::python::detail::get_extension_instance(obj);
-        typedef std::vector<boost::python::detail::instance_holder_base*>::const_iterator iterator;
-        for (iterator p = self->wrapped_objects().begin();
-             p != self->wrapped_objects().end(); ++p)
-        {
-            boost::python::detail::instance_ptr_holder<PtrType, T>* held =
-                dynamic_cast<boost::python::detail::instance_ptr_holder<PtrType, T>*>(*p);
-            if (held != 0)
-                return held->ptr();
-        }
-        boost::python::detail::report_missing_ptr_data(self, boost::python::detail::class_registry<T>::class_object(), typeid(T));
-        throw boost::python::argument_error();
-    }
-
-    template <class PtrType>
-    static PyObject* ptr_to_python(PtrType x)
-    {
-        boost::python::reference<boost::python::detail::extension_instance> result(create_instance());
-        result->add_implementation(
-            std::auto_ptr<boost::python::detail::instance_holder_base>(
-                new boost::python::detail::instance_ptr_holder<PtrType,T>(x)));
-        return result.release();
-    }
-
-    static boost::python::reference<boost::python::detail::extension_instance> create_instance()
-    {
-        PyTypeObject* class_object = boost::python::detail::class_registry<T>::class_object();
-        if (class_object == 0)
-            boost::python::detail::report_missing_class_object(typeid(T));
-            
-        return boost::python::reference<boost::python::detail::extension_instance>(
-            new boost::python::detail::extension_instance(class_object));
-    }
-
-    // Convert to const T*
-    friend const T* from_python(PyObject* p, boost::python::type<const T*>)
-        { return from_python(p, boost::python::type<T*>()); }
-
-    // Convert to const T* const&
-    friend const T* from_python(PyObject* p, boost::python::type<const T*const&>)
-         { return from_python(p, boost::python::type<const T*>()); }
-  
-    // Convert to T* const&
-    friend T* from_python(PyObject* p, boost::python::type<T* const&>)
-         { return from_python(p, boost::python::type<T*>()); }
- 
-    // Convert to T&
-    friend T& from_python(PyObject* p, boost::python::type<T&>)
-        { return *boost::python::detail::check_non_null(from_python(p, boost::python::type<T*>())); }
-
-    // Convert to const T&
-    friend const T& from_python(PyObject* p, boost::python::type<const T&>)
-        { return from_python(p, boost::python::type<T&>()); }
-
-    // Convert to T
-    friend const T& from_python(PyObject* p, boost::python::type<T>)
-        { return from_python(p, boost::python::type<T&>()); }
-
-    friend std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<std::auto_ptr<T>&>)
-        { return ptr_from_python(p, boost::python::type<std::auto_ptr<T> >()); }
-    
-    friend std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<std::auto_ptr<T> >)
-        { return ptr_from_python(p, boost::python::type<std::auto_ptr<T> >()); }
-    
-    friend const std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<const std::auto_ptr<T>&>)
-        { return ptr_from_python(p, boost::python::type<std::auto_ptr<T> >()); }
-
-    friend PyObject* to_python(std::auto_ptr<T> x)
-        { return ptr_to_python(x); }
-
-    friend boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T>&>)
-        { return ptr_from_python(p, boost::python::type<boost::shared_ptr<T> >()); }
-    
-    friend boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T> >)
-        { return ptr_from_python(p, boost::python::type<boost::shared_ptr<T> >()); }
-    
-    friend const boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<const boost::shared_ptr<T>&>)
-        { return ptr_from_python(p, boost::python::type<boost::shared_ptr<T> >()); }
-
-    friend PyObject* to_python(boost::shared_ptr<T> x)
-        { return ptr_to_python(x); }
-};
-
-// Convert T to_python, instantiated on demand and only if there isn't a
-// non-template overload for this function. This version is the one invoked when
-// T is a wrapped class. See the first 2 functions declared in
-// python_extension_class_converters above for more info.
-template <class T>
-PyObject* to_python(const T& x)
-{
-    return py_extension_class_converters(boost::python::type<T>()).to_python(x);
-}
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-namespace boost { namespace python {
-
-BOOST_PYTHON_IMPORT_CONVERSION(python_extension_class_converters);
-
-namespace detail {
-
-template <class T> class instance_holder;
-
-class read_only_setattr_function : public function
-{
- public:
-    read_only_setattr_function(const char* name);
-    PyObject* do_call(PyObject* args, PyObject* keywords) const;
-    const char* description() const;
- private:
-    string m_name;
-};
-
-  template <class From, class To>
-  struct define_conversion
-  {
-      static void* upcast_ptr(void* v)
-      {
-          return static_cast<To*>(static_cast<From*>(v));
-      }
-
-      static void* downcast_ptr(void* v)
-      {
-          return dynamic_cast<To*>(static_cast<From*>(v));
-      }
-  };
-
-// An easy way to make an extension base class which wraps T. Note that Python
-// subclasses of this class will simply be class_t<extension_instance> objects.
-//
-// U should be a class derived from T which overrides virtual functions with
-// boilerplate code to call back into Python. See extclass_demo.h for examples.
-// 
-// U is optional, but you won't be able to override any member functions in
-// Python which are called from C++ if you don't supply it. If you just want to
-// be able to use T in python without overriding member functions, you can omit
-// U.
-template <class T, class U = held_instance<T> >
-class extension_class
-    : public python_extension_class_converters<T, U>, // This generates the to_python/from_python functions
-      public extension_class_base
-{
- public:
-    typedef T wrapped_type;
-    typedef U callback_type;
-    
-    // Construct with a name that comes from typeid(T).name(). The name only
-    // affects the objects of this class are represented through repr()
-    extension_class();
-    
-    // Construct with the given name. The name only affects the objects of this
-    // class are represented through repr()
-    extension_class(const char* name);
-    
-    ~extension_class();
-
-    // define constructors
-    template <class A1, class A2, class A3, class A4, class A5>
-    inline void def(constructor<A1, A2, A3, A4, A5>)
-    // The following incantation builds a signature1, signature2,... object. It
-    // should _all_ get optimized away.
-    { add_constructor(
-        prepend(type<A1>::id(),
-        prepend(type<A2>::id(),
-        prepend(type<A3>::id(),
-        prepend(type<A4>::id(),
-        prepend(type<A5>::id(),
-                signature0()))))));
-    }
-
-
-    // export homogeneous operators (type of both lhs and rhs is 'operator')
-    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub), Foo>());
-    
-    // export homogeneous operators (type of both lhs and rhs is 'T const&')
-    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub)>());
-    template <long which, class Operand>
-    inline void def(operators<which,Operand>)
-    {
-        typedef typename operand_select<Operand>::template wrapped<T>::type true_operand;
-        def_operators(operators<which,true_operand>());
-    }
-
-    // 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&>());
-
-    // export heterogeneous operators (type of lhs: 'T const&', of rhs: 'right')
-    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub)>(),
-    //                       boost::python::right_operand<int const&>());
-    template <long which, class Left, class Right>
-    inline void def(operators<which,Left>, right_operand<Right> r)
-    {
-        typedef typename operand_select<Left>::template wrapped<T>::type true_left;
-        def_operators(operators<which,true_left>(), r);
-    }
-
-    // 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&>());
-    
-    // export heterogeneous reverse-argument operators 
-    // (type of lhs: 'left', of rhs: 'T const&')
-    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub)>(),
-    //                       boost::python::left_operand<int const&>());
-    template <long which, class Left, class Right>
-    inline void def(operators<which,Right>, left_operand<Left> l)
-    {
-        typedef typename operand_select<Right>::template wrapped<T>::type true_right;
-        def_operators(operators<which,true_right>(), l);
-    }
-
-    // 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>
-    inline void def_raw(Fn fn, const char* name)
-    {
-        this->add_method(new_raw_arguments_function(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), they can be used just like
-    // ordinary member functions -- just like Python!
-    template <class Fn>
-    inline void def(Fn fn, const char* name)
-    {
-        this->add_method(new_wrapped_function(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>
-    inline void def(Fn fn, const char* name, DefaultFn default_fn)
-    {
-        this->add_method(new_virtual_function(type<T>(), fn, default_fn), name);
-    }
-
-    // Provide a function which implements x.<name>, reading from the given
-    // member (pm) of the T obj
-    template <class MemberType>
-    inline void def_getter(MemberType T::*pm, const char* name)
-    {
-        this->add_getter_method(new getter_function<T, MemberType>(pm), name);
-    }
-    
-    // Provide a function which implements assignment to x.<name>, writing to
-    // the given member (pm) of the T obj
-    template <class MemberType>
-    inline void def_setter(MemberType T::*pm, const char* name)
-    {
-        this->add_setter_method(new setter_function<T, MemberType>(pm), name);
-    }
-    
-    // Expose the given member (pm) of the T obj as a read-only attribute
-    template <class MemberType>
-    inline void def_readonly(MemberType T::*pm, const char* name)
-    {
-        this->add_setter_method(new read_only_setattr_function(name), name);
-        this->def_getter(pm, name);
-    }
-    
-    // Expose the given member (pm) of the T obj as a read/write attribute
-    template <class MemberType>
-    inline void def_read_write(MemberType T::*pm, const char* name)
-    {
-        this->def_getter(pm, name);
-        this->def_setter(pm, name);
-    }
-    
-    // define the standard coercion needed for operator overloading
-    void def_standard_coerce();
-
-    // declare the given class a base class of this one and register 
-    // up and down conversion functions
-    template <class S, class V>
-    void declare_base(extension_class<S, V>* base)
-    {
-        // see extclass.cpp for an explanation of why we need to register
-        // conversion functions
-        base_class_info baseInfo(base, 
-                            &define_conversion<S, T>::downcast_ptr);
-        class_registry<T>::register_base_class(baseInfo);
-        add_base(ref(as_object(base), ref::increment_count));
-        
-        derived_class_info derivedInfo(this, 
-                            &define_conversion<T, S>::upcast_ptr);
-        class_registry<S>::register_derived_class(derivedInfo);
-    }
-        
-    // declare the given class a base class of this one and register 
-    // only up conversion function
-    template <class S, class V>
-    void declare_base(extension_class<S, V>* base, without_downcast_t)
-    {
-        // see extclass.cpp for an explanation of why we need to register
-        // conversion functions
-        base_class_info baseInfo(base, 0);
-        class_registry<T>::register_base_class(baseInfo);
-        add_base(ref(as_object(base), ref::increment_count));
-        
-        derived_class_info derivedInfo(this, 
-                           &define_conversion<T, S>::upcast_ptr);
-        class_registry<S>::register_derived_class(derivedInfo);
-    }
-    
- private: // types
-    typedef instance_value_holder<T,U> holder;
-
- private: // extension_class_base virtual function implementations
-    std::vector<base_class_info> const& base_classes() const;
-    std::vector<derived_class_info> const& derived_classes() const;
-    void* extract_object_from_holder(instance_holder_base* v) const;
-
- private: // Utility functions
-    template <long which, class Operand>
-    inline void def_operators(operators<which,Operand>)
-    {
-        def_standard_coerce();
-
-        // for some strange reason, this prevents MSVC from having an
-        // "unrecoverable block scoping error"!
-        typedef choose_op<(which & op_add)> choose_add;
-
-        choose_op<(which & op_add)>::template args<Operand>::add(this);
-        choose_op<(which & op_sub)>::template args<Operand>::add(this);
-        choose_op<(which & op_mul)>::template args<Operand>::add(this);
-        choose_op<(which & op_div)>::template args<Operand>::add(this);
-        choose_op<(which & op_mod)>::template args<Operand>::add(this);
-        choose_op<(which & op_divmod)>::template args<Operand>::add(this);
-        choose_op<(which & op_pow)>::template args<Operand>::add(this);
-        choose_op<(which & op_lshift)>::template args<Operand>::add(this);
-        choose_op<(which & op_rshift)>::template args<Operand>::add(this);
-        choose_op<(which & op_and)>::template args<Operand>::add(this);
-        choose_op<(which & op_xor)>::template args<Operand>::add(this);
-        choose_op<(which & op_or)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_neg)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_pos)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_abs)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_invert)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_int)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_long)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_float)>::template args<Operand>::add(this);
-        choose_op<(which & op_cmp)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_str)>::template args<Operand>::add(this);
-    }
-
-    template <long which, class Left, class Right>
-    inline void def_operators(operators<which,Left>, right_operand<Right>)
-    {
-        def_standard_coerce();
-        
-        choose_op<(which & op_add)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_sub)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_mul)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_div)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_mod)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_divmod)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_pow)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_lshift)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_rshift)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_and)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_xor)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_or)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_cmp)>::template args<Left,Right>::add(this);
-    }
-    
-    template <long which, class Left, class Right>
-    inline void def_operators(operators<which,Right>, left_operand<Left>)
-    {
-        def_standard_coerce();
-        
-        choose_rop<(which & op_add)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_sub)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_mul)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_div)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_mod)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_divmod)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_pow)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_lshift)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_rshift)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_and)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_xor)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_or)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_cmp)>::template args<Left,Right>::add(this);
-    }
-    
-    template <class signature>
-    void add_constructor(signature sig)
-    {
-        this->add_constructor_object(init_function<holder>::create(sig));
-    }
-};
-
-// A simple wrapper over a T which allows us to use extension_class<T> with a
-// single template parameter only. See extension_class<T>, above.
-template <class T>
-class held_instance : public T
-{
-    // There are no member functions: we want to avoid inadvertently overriding
-    // any virtual functions in T.
-public:
-    held_instance(PyObject*) : T() {}
-    template <class A1>
-    held_instance(PyObject*, A1 a1) : T(a1) {}
-    template <class A1, class A2>
-    held_instance(PyObject*, A1 a1, A2 a2) : T(a1, a2) {}
-    template <class A1, class A2, class A3>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3) : T(a1, a2, a3) {}
-    template <class A1, class A2, class A3, class A4>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4) : T(a1, a2, a3, a4) {}
-    template <class A1, class A2, class A3, class A4, class A5>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) : T(a1, a2, a3, a4, a5) {}
-};
-
-// Abstract base class for all obj holders. Base for template class
-// instance_holder<>, below.
-class instance_holder_base
-{
-public:
-    virtual ~instance_holder_base() {}
-    virtual bool held_by_value() = 0;
-};
-
-// Abstract base class which holds a Held, somehow. Provides a uniform way to
-// get a pointer to the held object
-template <class Held>
-class instance_holder : public instance_holder_base
-{
-public:
-    virtual Held*target() = 0;
-};
-
-// Concrete class which holds a Held by way of a wrapper class Wrapper. If Held
-// can be constructed with arguments (A1...An), Wrapper must have a
-// corresponding constructor for arguments (PyObject*, A1...An). Wrapper is
-// neccessary to implement virtual function callbacks (there must be a
-// back-pointer to the actual Python object so that we can call any
-// overrides). held_instance (above) is used as a default Wrapper class when
-// there are no virtual functions.
-template <class Held, class Wrapper>
-class instance_value_holder : public instance_holder<Held>
-{
-public:
-    Held* target() { return &m_held; }
-    Wrapper* value_target() { return &m_held; }
-
-    instance_value_holder(extension_instance* p) :
-        m_held(p) {}
-    template <class A1>
-    instance_value_holder(extension_instance* p, A1 a1) :
-        m_held(p, a1) {}
-    template <class A1, class A2>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2) :
-        m_held(p, a1, a2) {}
-    template <class A1, class A2, class A3>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3) :
-        m_held(p, a1, a2, a3) {}
-    template <class A1, class A2, class A3, class A4>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4) :
-        m_held(p, a1, a2, a3, a4) {}
-    template <class A1, class A2, class A3, class A4, class A5>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) :
-        m_held(p, a1, a2, a3, a4, a5) {}
-
- public: // implementation of instance_holder_base required interface
-    bool held_by_value() { return true; }
-
- private:
-    Wrapper m_held;
-};
-
-// Concrete class which holds a HeldType by way of a (possibly smart) pointer
-// PtrType. By default, these are only generated for PtrType ==
-// std::auto_ptr<HeldType> and PtrType == boost::shared_ptr<HeldType>.
-template <class PtrType, class HeldType>
-class instance_ptr_holder : public instance_holder<HeldType>
-{
- public:
-    HeldType* target() { return &*m_ptr; }
-    PtrType& ptr() { return m_ptr; }
-
-    instance_ptr_holder(PtrType ptr) : m_ptr(ptr) {}
-    
- public: // implementation of instance_holder_base required interface
-    bool held_by_value() { return false; }
- private:
-    PtrType m_ptr;
-};
-
-class extension_instance : public instance
-{
- public:
-    extension_instance(PyTypeObject* class_);
-    ~extension_instance();
-    
-    void add_implementation(std::auto_ptr<instance_holder_base> holder);
-
-    typedef std::vector<instance_holder_base*> held_objects;
-    const held_objects& wrapped_objects() const
-        { return m_wrapped_objects; }
- private:
-    held_objects m_wrapped_objects;
-};
-
-//
-// Template function implementations
-//
-
-template <class T, class U>
-extension_class<T, U>::extension_class()
-    : extension_class_base(typeid(T).name())
-{
-    class_registry<T>::register_class(this);
-}
-
-template <class T, class U>
-extension_class<T, U>::extension_class(const char* name)
-    : extension_class_base(name)
-{
-    class_registry<T>::register_class(this);
-}
-
-template <class T, class U>
-void extension_class<T, U>::def_standard_coerce()
-{
-    ref coerce_fct = dict().get_item(string("__coerce__"));
-    
-    if(coerce_fct.get() == 0) // not yet defined
-        this->def(&standard_coerce, "__coerce__");
-}
-
-template <class T, class U>
-inline
-std::vector<base_class_info> const& 
-extension_class<T, U>::base_classes() const
-{
-    return class_registry<T>::base_classes();
-}
-
-template <class T, class U>
-inline
-std::vector<derived_class_info> const& 
-extension_class<T, U>::derived_classes() const
-{
-    return class_registry<T>::derived_classes();
-}
-       
-template <class T, class U>
-void* extension_class<T, U>::extract_object_from_holder(instance_holder_base* v) const
-{
-    instance_holder<T>* held = dynamic_cast<instance_holder<T>*>(v);
-    if(held)
-        return held->target();
-    return 0;
-}
-
-template <class T, class U>
-extension_class<T, U>::~extension_class()
-{
-    class_registry<T>::unregister_class(this);
-}
-
-template <class T>
-inline void class_registry<T>::register_class(extension_class_base* p)
-{
-    // You're not expected to create more than one of these!
-    assert(static_class_object == 0);
-    static_class_object = p;
-}
-
-template <class T>
-inline void class_registry<T>::unregister_class(extension_class_base* p)
-{
-    // The user should be destroying the same object they created.
-    assert(static_class_object == p);
-    (void)p; // unused in shipping version
-    static_class_object = 0;
-}
-
-template <class T>
-void class_registry<T>::register_base_class(base_class_info const& i)
-{
-    static_base_class_info.push_back(i);
-}
-
-template <class T>
-void class_registry<T>::register_derived_class(derived_class_info const& i)
-{
-    static_derived_class_info.push_back(i);
-}
-
-template <class T>
-std::vector<base_class_info> const& class_registry<T>::base_classes()
-{
-    return static_base_class_info;
-}
-
-template <class T>
-std::vector<derived_class_info> const& class_registry<T>::derived_classes()
-{
-    return static_derived_class_info;
-}
-
-//
-// Static data member declaration.
-//
-template <class T>
-extension_class_base* class_registry<T>::static_class_object;
-template <class T>
-std::vector<base_class_info> class_registry<T>::static_base_class_info;
-template <class T>
-std::vector<derived_class_info> class_registry<T>::static_derived_class_info;
-
-}}} // namespace boost::python::detail
-
-#endif // EXTENSION_CLASS_DWA052000_H_
-
diff --git a/include/boost/python/detail/functions.hpp b/include/boost/python/detail/functions.hpp
deleted file mode 100644
index 055255e7..00000000
--- a/include/boost/python/detail/functions.hpp
+++ /dev/null
@@ -1,306 +0,0 @@
-//  (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 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;
-};
-
-// 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
-        { 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 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_
diff --git a/include/boost/python/detail/init_function.hpp b/include/boost/python/detail/init_function.hpp
deleted file mode 100644
index e53f8aa9..00000000
--- a/include/boost/python/detail/init_function.hpp
+++ /dev/null
@@ -1,507 +0,0 @@
-//  (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 %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:
-      typedef const_ref_selector<boost::is_reference<T>::value> 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;
-  };
-
-  template <class T>
-  class reference_parameter
-  {
-      typedef typename parameter_traits<T>::const_reference const_reference;
-   public:
-      reference_parameter(const_reference value)
-          : value(value) {}
-      operator const_reference() { return value; }
-   private:
-      const_reference value;
-  };
-
-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
-{
-    static init* create(signature0) {
-        return new init0<T>;
-    }
-
-    template <class A1>
-    static init* create(signature1<A1>) {
-        return new init1<T,
-                       detail::parameter_traits<A1>::const_reference>;
-    }
-
-    template <class A1, class A2>
-    static init* create(signature2<A1, A2>) {
-        return new init2<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3>
-    static init* create(signature3<A1, A2, A3>) {
-        return new init3<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       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,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       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,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference,
-                       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,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference,
-                       detail::parameter_traits<A5>::const_reference,
-                       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,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference,
-                       detail::parameter_traits<A5>::const_reference,
-                       detail::parameter_traits<A6>::const_reference,
-                       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,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference,
-                       detail::parameter_traits<A5>::const_reference,
-                       detail::parameter_traits<A6>::const_reference,
-                       detail::parameter_traits<A7>::const_reference,
-                       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,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference,
-                       detail::parameter_traits<A5>::const_reference,
-                       detail::parameter_traits<A6>::const_reference,
-                       detail::parameter_traits<A7>::const_reference,
-                       detail::parameter_traits<A8>::const_reference,
-                       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,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference,
-                       detail::parameter_traits<A5>::const_reference,
-                       detail::parameter_traits<A6>::const_reference,
-                       detail::parameter_traits<A7>::const_reference,
-                       detail::parameter_traits<A8>::const_reference,
-                       detail::parameter_traits<A9>::const_reference,
-                       detail::parameter_traits<A10>::const_reference>;
-    }
-};
-
-class 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_
diff --git a/include/boost/python/detail/none.hpp b/include/boost/python/detail/none.hpp
deleted file mode 100644
index 8cb21004..00000000
--- a/include/boost/python/detail/none.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-//  (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 NONE_DWA_052000_H_
-# define NONE_DWA_052000_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-
-namespace boost { namespace python { namespace detail {
-
-inline PyObject* none() { Py_INCREF(Py_None); return Py_None; }
-    
-}}} // namespace boost::python::detail
-
-#endif // NONE_DWA_052000_H_
diff --git a/include/boost/python/detail/signatures.hpp b/include/boost/python/detail/signatures.hpp
deleted file mode 100644
index 2be75b52..00000000
--- a/include/boost/python/detail/signatures.hpp
+++ /dev/null
@@ -1,251 +0,0 @@
-//  (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 automatically generated by gen_signatures.python for 10 arguments.
-#ifndef SIGNATURES_DWA050900_H_
-# define SIGNATURES_DWA050900_H_
-
-# include <boost/python/detail/config.hpp>
-
-namespace boost { namespace python {
-
-namespace detail {
-// A stand-in for the built-in void. This one can be passed to functions and
-// (under MSVC, which has a bug, be used as a default template type parameter).
-struct void_t {};
-}
-
-// An envelope in which type information can be delivered for the purposes
-// of selecting an overloaded from_python() function. This is needed to work
-// around MSVC's lack of partial specialiation/ordering. Where normally we'd
-// want to form a function call like void f<const T&>(), We instead pass
-// type<const T&> as one of the function parameters to select a particular
-// overload.
-//
-// The id typedef helps us deal with the lack of partial ordering by generating
-// unique types for constructor signatures. In general, type<T>::id is type<T>,
-// but type<void_t>::id is just void_t.
-template <class T>
-struct type
-{
-    typedef type id;
-};
-
-template <>
-struct type<boost::python::detail::void_t>
-{
-    typedef boost::python::detail::void_t id;
-};
-
-namespace detail {
-// These basically encapsulate a chain of types, , used to make the syntax of
-// add(constructor<T1, ...>()) work. We need to produce a unique type for each number
-// of non-default parameters to constructor<>.  Q: why not use a recursive
-// formulation for infinite extensibility? A: MSVC6 seems to choke on constructs
-// that involve recursive template nesting.
-//
-// signature chaining
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
-struct signature10 {};
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
-struct signature9 {};
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class X>
-inline signature10<X, T1, T2, T3, T4, T5, T6, T7, T8, T9> prepend(type<X>, signature9<T1, T2, T3, T4, T5, T6, T7, T8, T9>)
-    { return signature10<X, T1, T2, T3, T4, T5, T6, T7, T8, T9>(); }
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
-struct signature8 {};
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class X>
-inline signature9<X, T1, T2, T3, T4, T5, T6, T7, T8> prepend(type<X>, signature8<T1, T2, T3, T4, T5, T6, T7, T8>)
-    { return signature9<X, T1, T2, T3, T4, T5, T6, T7, T8>(); }
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
-struct signature7 {};
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class X>
-inline signature8<X, T1, T2, T3, T4, T5, T6, T7> prepend(type<X>, signature7<T1, T2, T3, T4, T5, T6, T7>)
-    { return signature8<X, T1, T2, T3, T4, T5, T6, T7>(); }
-
-template <class T1, class T2, class T3, class T4, class T5, class T6>
-struct signature6 {};
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class X>
-inline signature7<X, T1, T2, T3, T4, T5, T6> prepend(type<X>, signature6<T1, T2, T3, T4, T5, T6>)
-    { return signature7<X, T1, T2, T3, T4, T5, T6>(); }
-
-template <class T1, class T2, class T3, class T4, class T5>
-struct signature5 {};
-
-template <class T1, class T2, class T3, class T4, class T5, class X>
-inline signature6<X, T1, T2, T3, T4, T5> prepend(type<X>, signature5<T1, T2, T3, T4, T5>)
-    { return signature6<X, T1, T2, T3, T4, T5>(); }
-
-template <class T1, class T2, class T3, class T4>
-struct signature4 {};
-
-template <class T1, class T2, class T3, class T4, class X>
-inline signature5<X, T1, T2, T3, T4> prepend(type<X>, signature4<T1, T2, T3, T4>)
-    { return signature5<X, T1, T2, T3, T4>(); }
-
-template <class T1, class T2, class T3>
-struct signature3 {};
-
-template <class T1, class T2, class T3, class X>
-inline signature4<X, T1, T2, T3> prepend(type<X>, signature3<T1, T2, T3>)
-    { return signature4<X, T1, T2, T3>(); }
-
-template <class T1, class T2>
-struct signature2 {};
-
-template <class T1, class T2, class X>
-inline signature3<X, T1, T2> prepend(type<X>, signature2<T1, T2>)
-    { return signature3<X, T1, T2>(); }
-
-template <class T1>
-struct signature1 {};
-
-template <class T1, class X>
-inline signature2<X, T1> prepend(type<X>, signature1<T1>)
-    { return signature2<X, T1>(); }
-
-struct signature0 {};
-
-template <class X>
-inline signature1<X> prepend(type<X>, signature0)
-    { return signature1<X>(); }
-
-
-// This one terminates the chain. Prepending void_t to the head of a void_t
-// signature results in a void_t signature again.
-inline signature0 prepend(void_t, signature0) { return signature0(); }
-
-} // namespace detail
-
-template <class A1 = detail::void_t, class A2 = detail::void_t, class A3 = detail::void_t, class A4 = detail::void_t, class A5 = detail::void_t, class A6 = detail::void_t, class A7 = detail::void_t, class A8 = detail::void_t, class A9 = detail::void_t, class A10 = detail::void_t>
-struct constructor
-{
-};
-
-namespace detail {
-// Return value extraction:
-
-// This is just another little envelope for carrying a typedef (see type,
-// above). I could have re-used type, but that has a very specific purpose. I
-// thought this would be clearer.
-template <class T>
-struct return_value_select { typedef T type; };
-
-// free functions
-template <class R>
-return_value_select<R> return_value(R (*)()) { return return_value_select<R>(); }
-
-template <class R, class A1>
-return_value_select<R> return_value(R (*)(A1)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2>
-return_value_select<R> return_value(R (*)(A1, A2)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3>
-return_value_select<R> return_value(R (*)(A1, A2, A3)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4, class A5>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4, class A5, class A6>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5, A6)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7, A8)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) { return return_value_select<R>(); }
-
-// TODO(?): handle 'const void'
-
-// member functions
-template <class R, class T>
-return_value_select<R> return_value(R (T::*)()) { return return_value_select<R>(); }
-
-template <class R, class T, class A1>
-return_value_select<R> return_value(R (T::*)(A1)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2>
-return_value_select<R> return_value(R (T::*)(A1, A2)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) { return return_value_select<R>(); }
-
-template <class R, class T>
-return_value_select<R> return_value(R (T::*)() const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1>
-return_value_select<R> return_value(R (T::*)(A1) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2>
-return_value_select<R> return_value(R (T::*)(A1, A2) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const) { return return_value_select<R>(); }
-
-}}} // namespace boost::python::detail
-
-#endif
diff --git a/include/boost/python/detail/singleton.hpp b/include/boost/python/detail/singleton.hpp
deleted file mode 100644
index 07d794ac..00000000
--- a/include/boost/python/detail/singleton.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//  (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 SINGLETON_DWA051900_H_
-# define SINGLETON_DWA051900_H_
-
-# include <boost/python/detail/config.hpp>
-
-namespace boost { namespace python { namespace detail {
-
-struct empty {};
-template <class Derived, class Base = empty>
-struct singleton : Base
-{
-    typedef singleton singleton_base; // Convenience type for derived class constructors
-    
-    static Derived* instance();
-
-    // Pass-through constructors
-    singleton() : Base() {}
-
-    template <class A1>
-    singleton(const A1& a1) : Base(a1) {}
-
-    template <class A1, class A2>
-    singleton(const A1& a1, const A2& a2) : Base(a1, a2) {}
-
-    template <class A1, class A2, class A3>
-    singleton(const A1& a1, const A2& a2, const A3& a3) : Base(a1, a2, a3) {}
-
-    template <class A1, class A2, class A3, class A4>
-    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4) : Base(a1, a2, a3, a4) {}
-
-    template <class A1, class A2, class A3, class A4, class A5>
-    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) : Base(a1, a2, a3, a4, a5) {}
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6) : Base(a1, a2, a3, a4, a5, a6) {}
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7) : Base(a1, a2, a3, a4, a5, a6, a7) {}
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8) : Base(a1, a2, a3, a4, a5, a6, a7, a8) {}
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    singleton(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) : Base(a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    singleton(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) : Base(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
-
-};
-
-template <class Derived, class Base>
-Derived* singleton<Derived,Base>::instance()
-{
-    static Derived x;
-    return &x;
-}
-
-}}} // namespace boost::python::detail
-
-#endif
diff --git a/include/boost/python/detail/types.hpp b/include/boost/python/detail/types.hpp
deleted file mode 100644
index ee33ce04..00000000
--- a/include/boost/python/detail/types.hpp
+++ /dev/null
@@ -1,389 +0,0 @@
-//  (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 TYPES_DWA051800_H_
-# define TYPES_DWA051800_H_
-
-//  Usage:
-//  class X : public
-//          boost::python::callable<
-//          boost::python::getattrable <
-//          boost::python::setattrable<python_object, X> > >
-//  {
-//  public:
-//      ref call(args, kw);
-//      ref getattr(args, kw);
-//      ref setattr(args, kw);
-//  };
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/signatures.hpp> // really just for type<>
-# include <boost/python/detail/cast.hpp>
-# include <boost/python/detail/base_object.hpp>
-# include <typeinfo>
-# include <vector>
-# include <cassert>
-
-namespace boost { namespace python {
-
-class string;
-
-namespace detail {
-
-class instance_holder_base;
-
-class type_object_base : public python_type
-{
- public:
-    explicit type_object_base(PyTypeObject* type_type);
-    virtual ~type_object_base();
-
- public:
-    enum capability {
-        hash, call, str, getattr, setattr, compare, repr,
-
-        mapping_length, mapping_subscript, mapping_ass_subscript,
-        
-        sequence_length, sequence_item, sequence_ass_item,
-        sequence_concat, sequence_repeat, sequence_slice, sequence_ass_slice,
-        
-        number_add, number_subtract, number_multiply, number_divide,
-        number_remainder, number_divmod, number_power, number_negative,
-        number_positive, number_absolute, number_nonzero, number_invert,
-        number_lshift, number_rshift, number_and, number_xor, number_or,
-        number_coerce, number_int, number_long, number_float, number_oct,
-        number_hex
-    };
-    
-    void enable(capability);
-    
-    //
-    // type behaviors
-    //
- public: // Callbacks for basic type functionality.
-    virtual PyObject* instance_repr(PyObject*) const;
-    virtual int instance_compare(PyObject*, PyObject* other) const;
-    virtual PyObject* instance_str(PyObject*) const;
-    virtual long instance_hash(PyObject*) const;
-    virtual PyObject* instance_call(PyObject* obj, PyObject* args, PyObject* kw) const;
-    virtual PyObject* instance_getattr(PyObject* obj, const char* name) const;
-    virtual int instance_setattr(PyObject* obj, const char* name, PyObject* value) const;
-
-    // Dealloc is a special case, since every type needs a nonzero tp_dealloc slot.
-    virtual void instance_dealloc(PyObject*) const = 0;
-
- public: // Callbacks for mapping methods
-    virtual int instance_mapping_length(PyObject*) const;
-    virtual PyObject* instance_mapping_subscript(PyObject*, PyObject*) const ;
-    virtual int instance_mapping_ass_subscript(PyObject*, PyObject*, PyObject*) const;
-
- public: // Callbacks for sequence methods
-    virtual int instance_sequence_length(PyObject* obj) const;
-    virtual PyObject* instance_sequence_concat(PyObject* obj, PyObject* other) const;
-    virtual PyObject* instance_sequence_repeat(PyObject* obj, int n) const;
-    virtual PyObject* instance_sequence_item(PyObject* obj, int n) const;
-    virtual PyObject* instance_sequence_slice(PyObject* obj, int start, int finish) const;
-    virtual int instance_sequence_ass_item(PyObject* obj, int n, PyObject* value) const;
-    virtual int instance_sequence_ass_slice(PyObject* obj, int start, int finish, PyObject* value) const;
-    
- public: // Callbacks for number methods
-    virtual PyObject* instance_number_add(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_subtract(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_multiply(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_divide(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_remainder(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_divmod(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_power(PyObject*, PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_negative(PyObject*) const;
-    virtual PyObject* instance_number_positive(PyObject*) const;
-    virtual PyObject* instance_number_absolute(PyObject*) const;
-    virtual int instance_number_nonzero(PyObject*) const;
-    virtual PyObject* instance_number_invert(PyObject*) const;
-    virtual PyObject* instance_number_lshift(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_rshift(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_and(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_xor(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_or(PyObject*, PyObject*) const;
-    virtual int instance_number_coerce(PyObject*, PyObject**, PyObject**) const;
-    virtual PyObject* instance_number_int(PyObject*) const;
-    virtual PyObject* instance_number_long(PyObject*) const;
-    virtual PyObject* instance_number_float(PyObject*) const;
-    virtual PyObject* instance_number_oct(PyObject*) const;
-    virtual PyObject* instance_number_hex(PyObject*) const;
-};
-
-template <class T>
-class type_object : public type_object_base
-{
- public:
-    typedef T instance;
-
-    type_object(PyTypeObject* type_type, const char* name)
-        : type_object_base(type_type)
-    {
-        assert(name != 0);
-        this->tp_name = const_cast<char*>(name);
-    }
-
-    type_object(PyTypeObject* type_type)
-        : type_object_base(type_type)
-    {
-        this->tp_name = const_cast<char*>(typeid(instance).name());
-    }
-
- private: // Overridable behaviors.
-    // Called when the reference count goes to zero. The default implementation
-    // is "delete p". If you have not allocated your object with operator new or
-    // you have other constraints, you'll need to override this
-    virtual void dealloc(T* p) const;
-    
- private: // Implementation of type_object_base hooks. Do not reimplement in derived classes.
-    void instance_dealloc(PyObject*) const;
-};
-
-//
-// type objects
-//
-template <class Base>
-class callable : public Base
-{
- public:
-    typedef callable properties; // Convenience for derived class construction
-    typedef typename Base::instance instance;
-    callable(PyTypeObject* type_type, const char* name);
-    callable(PyTypeObject* type_type);
- private:
-    PyObject* instance_call(PyObject* obj, PyObject* args, PyObject* kw) const;
-};
-
-template <class Base>
-class getattrable : public Base
-{
- public:
-    typedef getattrable properties; // Convenience for derived class construction
-    typedef typename Base::instance instance;
-    getattrable(PyTypeObject* type_type, const char* name);
-    getattrable(PyTypeObject* type_type);
- private:
-    PyObject* instance_getattr(PyObject* obj, const char* name) const;
-};
-
-template <class Base>
-class setattrable : public Base
-{
- public:
-    typedef setattrable properties; // Convenience for derived class construction
-    typedef typename Base::instance instance;
-    setattrable(PyTypeObject* type_type, const char* name);
-    setattrable(PyTypeObject* type_type);
- private:
-    int instance_setattr(PyObject* obj, const char* name, PyObject* value) const;
-};
-
-template <class Base>
-class reprable : public Base
-{
- public:
-    typedef reprable properties; // Convenience for derived class construction
-    typedef typename Base::instance instance;
-    reprable(PyTypeObject* type_type, const char* name);
-    reprable(PyTypeObject* type_type);
- private:
-    PyObject* instance_repr(PyObject* obj) const;
-};
-
-//
-// Member function definitions
-//
-
-// type_object<>
-template <class T>
-void type_object<T>::instance_dealloc(PyObject* obj) const
-{
-    this->dealloc(downcast<instance>(obj).get());
-}
-
-template <class T>
-void type_object<T>::dealloc(T* obj) const
-{
-    delete obj;
-}
-
-// callable
-template <class Base>
-callable<Base>::callable(PyTypeObject* type_type, const char* name)
-    : Base(type_type, name)
-{
-    this->enable(call);
-}
-        
-template <class Base>
-callable<Base>::callable(PyTypeObject* type_type)
-    : Base(type_type)
-{
-    this->enable(call);
-}
-        
-template <class Base>
-PyObject* callable<Base>::instance_call(PyObject* obj, PyObject* args, PyObject* kw) const
-{
-    return downcast<instance>(obj)->call(args, kw);
-}
-
-// getattrable
-template <class Base>
-getattrable<Base>::getattrable(PyTypeObject* type_type, const char* name)
-    : Base(type_type, name)
-{
-    this->enable(getattr);
-}
-        
-template <class Base>
-getattrable<Base>::getattrable(PyTypeObject* type_type)
-    : Base(type_type)
-{
-    this->enable(getattr);
-}
-        
-template <class Base>
-PyObject* getattrable<Base>::instance_getattr(PyObject* obj, const char* name) const
-{
-    return downcast<instance>(obj)->getattr(name);
-}
-
-// setattrable
-template <class Base>
-setattrable<Base>::setattrable(PyTypeObject* type_type, const char* name)
-    : Base(type_type, name)
-{
-    this->enable(setattr);
-}
-        
-template <class Base>
-setattrable<Base>::setattrable(PyTypeObject* type_type)
-    : Base(type_type)
-{
-    this->enable(setattr);
-}
-        
-template <class Base>
-int setattrable<Base>::instance_setattr(PyObject* obj, const char* name, PyObject* value) const
-{
-    return downcast<instance>(obj)->setattr(name, value);
-}
-
-// reprable
-template <class Base>
-reprable<Base>::reprable(PyTypeObject* type_type, const char* name)
-    : Base(type_type, name)
-{
-    this->enable(repr);
-}
-        
-template <class Base>
-reprable<Base>::reprable(PyTypeObject* type_type)
-    : Base(type_type)
-{
-    this->enable(repr);
-}
-        
-template <class Base>
-PyObject* reprable<Base>::instance_repr(PyObject* obj) const
-{
-    return downcast<instance>(obj)->repr();
-}
-
-  // Helper class for optimized allocation of PODs: If two PODs
-  // happen to contain identical byte patterns, they may share their
-  // memory. Reference counting is used to free unused memory. 
-  // This is useful because method tables of related extension classes tend
-  // to be identical, so less memory is needed for them.
-  class shared_pod_manager
-  {
-      typedef std::pair<char*, std::size_t> holder;
-      typedef std::vector<holder> storage;
-        
-   public:
-      static shared_pod_manager& obj();
-      ~shared_pod_manager();
-
-      // Allocate memory for POD T and fill it with zeros.
-      // This memory is initially not shared.
-      template <class T>
-      static void create(T*& t)
-      {
-          t = reinterpret_cast<T*>(obj().create(sizeof(T)));
-      }
-
-      // Decrement the refcount for the memory t points to. If the count 
-      // goes to zero, the memory is freed.
-      template <class T>
-      static void dispose(T* t)
-      {
-          obj().dec_ref(t, sizeof(T));
-      }
-
-      // Attempt to share the memory t points to. If memory with the same 
-      // contents already exists, t is replaced by a pointer to this memory,
-      // and t's old memory is disposed. Otherwise, t will be registered for
-      // potential future sharing.
-      template <class T>
-      static void replace_if_equal(T*& t)
-      {
-          t = reinterpret_cast<T*>(obj().replace_if_equal(t, sizeof(T)));
-      }
-
-      // Create a copy of t's memory that is guaranteed to be private to t.
-      // Afterwards t points to the new memory, unless it was already private, in
-      // which case there is no change (except that t's memory will no longer
-      // be considered for future sharing - see raplade_if_equal())
-      // This function *must* be called before the contents of (*t) can
-      // be overwritten. Otherwise, inconsistencies and crashes may result.
-      template <class T>
-      static void make_unique_copy(T*& t)
-      {
-          t = reinterpret_cast<T*>(obj().make_unique_copy(t, sizeof(T)));
-      }
-
-   private:
-      void* replace_if_equal(void* pod, std::size_t size);
-      void* make_unique_copy(void* pod, std::size_t size);
-      void* create(std::size_t size);
-      void dec_ref(void* pod, std::size_t size);
-      void erase_from_list(void* pod);
-        
-      struct compare;
-      struct identical;
-
-   private:
-      shared_pod_manager() {} // instance
-
-#ifdef TYPE_OBJECT_BASE_STANDALONE_TEST
-   public:
-#endif
-      storage m_storage;
-  };
-
-
-  void add_capability(type_object_base::capability capability, 
-                      PyTypeObject* dest);
-
-// This macro gets the length of an array as a compile-time constant, and will
-// fail to compile if the parameter is a pointer.
-# define PY_ARRAY_LENGTH(a) \
-        (sizeof(::boost::python::detail::countof_validate(a, &(a))) ? sizeof(a) / sizeof((a)[0]) : 0)
-
-  template<typename T>
-  inline void countof_validate(T* const, T* const*);
-
-  template<typename T>
-  inline int countof_validate(const void*, T);
-
-}}} // namespace boost::python::detail
-
-#endif // TYPES_DWA051800_H_
diff --git a/include/boost/python/detail/wrap_python.hpp b/include/boost/python/detail/wrap_python.hpp
deleted file mode 100644
index eb831b68..00000000
--- a/include/boost/python/detail/wrap_python.hpp
+++ /dev/null
@@ -1,78 +0,0 @@
-//  (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 serves as a wrapper around <Python.h> which allows it to be
-//  compiled with GCC 2.95.2 under Win32 and which disables the default MSVC
-//  behavior so that a program may be compiled in debug mode without requiring a
-//  special debugging build of the Python library.
-
-
-//  To use the Python debugging library, #define BOOST_DEBUG_PYTHON on the
-//  compiler command-line.
-
-#ifdef _DEBUG
-# ifndef BOOST_DEBUG_PYTHON
-#  undef _DEBUG // Don't let Python force the debug library just because we're debugging.
-#  define DEBUG_UNDEFINED_FROM_WRAP_PYTHON_H
-# endif
-#endif
-
-//
-// Some things we need in order to get Python.h to work with compilers other
-// than MSVC on Win32
-//
-#if defined(_WIN32)
-# ifdef __GNUC__
-
-typedef int pid_t;
-#  define WORD_BIT 32
-#  define hypot _hypot
-#  include <stdio.h>
-#  define HAVE_CLOCK
-#  define HAVE_STRFTIME
-#  define HAVE_STRERROR
-#  define NT_THREADS
-#  define WITH_THREAD
-#  ifndef NETSCAPE_PI
-#   define USE_SOCKET
-#  endif
-
-#  ifdef USE_DL_IMPORT
-#   define DL_IMPORT(RTYPE) __declspec(dllimport) RTYPE
-#  endif
-
-#  ifdef USE_DL_EXPORT
-#   define DL_IMPORT(RTYPE) __declspec(dllexport) RTYPE
-#   define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE
-#  endif
-
-#  define HAVE_LONG_LONG 1
-#  define LONG_LONG long long
-
-# elif defined(__MWERKS__)
-
-#  ifndef _MSC_VER
-#   define PY_MSC_VER_DEFINED_FROM_WRAP_PYTHON_H 1
-#   define _MSC_VER 900
-#  endif
-
-# endif
-
-#endif // _WIN32
-
-#include <Python.h>
-
-#ifdef PY_MSC_VER_DEFINED_FROM_WRAP_PYTHON_H
-# undef _MSC_VER
-#endif
-
-#ifdef DEBUG_UNDEFINED_FROM_WRAP_PYTHON_H
-# undef DEBUG_UNDEFINED_FROM_WRAP_PYTHON_H
-# define _DEBUG
-#endif
-
diff --git a/include/boost/python/errors.hpp b/include/boost/python/errors.hpp
deleted file mode 100644
index a1cdbbb0..00000000
--- a/include/boost/python/errors.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//  (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 ERRORS_DWA052500_H_
-# define ERRORS_DWA052500_H_
-
-namespace boost { namespace python {
-
-struct error_already_set {};
-struct argument_error : error_already_set {};
-
-// Handles exceptions caught just before returning to Python code.
-void handle_exception();
-
-template <class T>
-T* expect_non_null(T* x)
-{
-    if (x == 0)
-        throw error_already_set();
-    return x;
-}
-
-}} // namespace boost::python
-
-#endif // ERRORS_DWA052500_H_
diff --git a/include/boost/python/module_builder.hpp b/include/boost/python/module_builder.hpp
deleted file mode 100644
index 6a8a9b4b..00000000
--- a/include/boost/python/module_builder.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//  (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 MODULE_DWA051000_H_
-# define MODULE_DWA051000_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/reference.hpp>
-# include <boost/python/objects.hpp>
-# include <boost/python/detail/functions.hpp>
-
-namespace boost { namespace python {
-
-class module_builder
-{
- public:
-    // Create a module. REQUIRES: only one module_builder is created per module.
-    module_builder(const char* name);
-    ~module_builder();
-
-    // Add elements to the module
-    void add(detail::function* x, const char* name);
-    void add(PyTypeObject* x, const char* name = 0);
-    void add(ref x, const char*name);
-
-    template <class Fn>
-    void def_raw(Fn fn, const char* name)
-    {
-        add(detail::new_raw_arguments_function(fn), name);
-    }
-    
-    template <class Fn>
-    void def(Fn fn, const char* name)
-    {
-        add(detail::new_wrapped_function(fn), name);
-    }
-
-    // Return true iff a module is currently being built.
-    static bool initializing();
-    
-    // Return the name of the module currently being built.
-    // REQUIRES: initializing() == true
-    static string name();
-
-    // Return a pointer to the Python module object being built
-    PyObject* module() const;
-
- private:
-    PyObject* m_module;
-    static PyMethodDef initial_methods[1];
-};
-
-//
-// inline implementations
-//
-inline PyObject* module_builder::module() const
-{
-    return m_module;
-}
-
-}} // namespace boost::python
-
-#endif
diff --git a/include/boost/python/objects.hpp b/include/boost/python/objects.hpp
deleted file mode 100644
index 34052e1f..00000000
--- a/include/boost/python/objects.hpp
+++ /dev/null
@@ -1,334 +0,0 @@
-//  (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 OBJECTS_DWA051100_H_
-# define OBJECTS_DWA051100_H_
-
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/detail/config.hpp>
-# include <boost/python/reference.hpp>
-# include "boost/operators.hpp"
-# include <utility>
-
-namespace boost { namespace python {
-
-class object
-{
- public:
-    explicit object(ref p);
-    
-    // Return a reference to the held object
-    ref reference() const;
-
-    // Return a raw pointer to the held object
-    PyObject* get() const;
-    
- private:
-    ref m_p;
-};
-
-class tuple : public object
-{
- public:
-    explicit tuple(std::size_t n = 0);
-    explicit tuple(ref p);
-
-    template <class First, class Second>
-    tuple(const std::pair<First,Second>& x)
-        : object(ref(PyTuple_New(2)))
-    {
-        set_item(0, x.first);
-        set_item(1, x.second);
-    }
-    
-    template <class First, class Second>
-    tuple(const First& first, const Second& second)
-        : object(ref(PyTuple_New(2)))
-    {
-        set_item(0, first);
-        set_item(1, second);
-    }
-    
-    template <class First, class Second, class Third>
-    tuple(const First& first, const Second& second, const Third& third)
-        : object(ref(PyTuple_New(3)))
-    {
-        set_item(0, first);
-        set_item(1, second);
-        set_item(2, third);
-    }
-    
-    template <class First, class Second, class Third, class Fourth>
-    tuple(const First& first, const Second& second, const Third& third, const Fourth& fourth)
-        : object(ref(PyTuple_New(4)))
-    {
-        set_item(0, first);
-        set_item(1, second);
-        set_item(2, third);
-        set_item(3, fourth);
-    }
-    
-    static PyTypeObject* type_obj();
-    static bool accepts(ref p);
-    std::size_t size() const;
-    ref operator[](std::size_t pos) const;
-
-    template <class T>
-    void set_item(std::size_t pos, const T& rhs)
-    {
-        this->set_item(pos, make_ref(rhs));
-    }
-    
-    void set_item(std::size_t pos, const ref& rhs);
-    
-    tuple slice(int low, int high) const;
-
-    friend tuple operator+(const tuple&, const tuple&);
-    tuple& operator+=(const tuple& rhs);
-};
-
-class list : public object
-{
-    struct proxy;
-    struct slice_proxy;
- public:
-    explicit list(ref p);
-    explicit list(std::size_t sz = 0);
-    static PyTypeObject* type_obj();
-    static bool accepts(ref p);
-    std::size_t size();
-    ref operator[](std::size_t pos) const;
-    proxy operator[](std::size_t pos);
-    ref get_item(std::size_t pos) const;
-
-    template <class T>
-    void set_item(std::size_t pos, const T& x)
-        { this->set_item(pos, make_ref(x)); }
-    void set_item(std::size_t pos, const ref& );
-    
-//    void set_item(std::size_t pos, const object& );
-
-    template <class T>
-    void insert(std::size_t index, const T& x)
-        { this->insert(index, make_ref(x)); }
-    void insert(std::size_t index, const ref& item);
-
-    template <class T>
-    void push_back(const T& item)
-        { this->push_back(make_ref(item)); }
-    void push_back(const ref& item);
-    
-    template <class T>
-    void append(const T& item)
-        { this->append(make_ref(item)); }
-    void append(const ref& item);
-    
-    list slice(int low, int high) const;
-    slice_proxy slice(int low, int high);
-    void sort();
-    void reverse();
-    tuple as_tuple() const;
-};
-
-class string
-    : public object, public boost::multipliable2<string, unsigned int>
-{
- public:
-    // Construct from an owned PyObject*.
-    // Precondition: p must point to a python string.
-    explicit string(ref p);
-    explicit string(const char* s);
-    string(const char* s, std::size_t length);
-    string(const string& rhs);
-
-    enum interned_t { interned };
-    string(const char* s, interned_t);
-    
-    // Get the type object for Strings
-    static PyTypeObject* type_obj();
-
-    // Return true if the given object is a python string
-    static bool accepts(ref o);
-
-    // Return the length of the string.
-    std::size_t size() const;
-
-    // Returns a null-terminated representation of the contents of string.
-    // The pointer refers to the internal buffer of string, not a copy.
-    // The data must not be modified in any way. It must not be de-allocated. 
-    const char* c_str() const;
-
-    string& operator*=(unsigned int repeat_count);
-    string& operator+=(const string& rhs);
-    friend string operator+(string x, string y);
-    string& operator+=(const char* rhs);
-    friend string operator+(string x, const char* y);
-    friend string operator+(const char* x, string y);
-
-    void intern();
-
-    friend string operator%(const string& format, const tuple& args);
-};
-
-class dictionary : public object
-{
- private:
-    struct proxy;
-    
- public:
-    explicit dictionary(ref p);
-    dictionary();
-    void clear();
-
-    static PyTypeObject* type_obj();
-    static bool accepts(ref p);
-    
- public:
-    template <class Key>
-    proxy operator[](const Key& key)
-        { return this->operator[](make_ref(key)); }
-    proxy operator[](ref key);
-    
-    template <class Key>
-    ref operator[](const Key& key) const
-        { return this->operator[](make_ref(key)); }
-    ref operator[](ref key) const;
-
-    template <class Key>
-    ref get_item(const Key& key) const
-        { return this->get_item(make_ref(key)); }
-    ref get_item(const ref& key) const;
-    
-    template <class Key, class Default>
-    ref get_item(const Key& key, const Default& default_) const
-        { return this->get_item(make_ref(key), make_ref(default_)); }
-    ref get_item(const ref& key, const ref& default_) const;
-    
-    template <class Key, class Value>
-    void set_item(const Key& key, const Value& value)
-        { this->set_item(make_ref(key), make_ref(value)); }
-    void set_item(const ref& key, const ref& value);
-
-    template <class Key>
-    void erase(const Key& key)
-        { this->erase(make_ref(key)); }
-    void erase(ref key);
-
-//    proxy operator[](const object& key);
-//    ref operator[](const object& key) const;
-
-//    ref get_item(const object& key, ref default_ = ref()) const;
-//    void set_item(const object& key, const ref& value);
-        
-//    void erase(const object& key);
-
-    list items() const;
-    list keys() const;
-    list values() const;
-
-    std::size_t size() const;
-    // TODO: iterator support
-};
-
-struct dictionary::proxy
-{
-    template <class T>
-    const ref& operator=(const T& rhs)
-        { return (*this) = make_ref(rhs); }
-    const ref& operator=(const ref& rhs);
-
-    operator ref() const;
- private:
-    friend class dictionary;
-    proxy(const ref& dict, const ref& key);
-
-    // This is needed to work around the very strange MSVC error report that the
-    // return type of the built-in operator= differs from that of the ones
-    // defined above. Couldn't hurt to make these un-assignable anyway, though.
-    const ref& operator=(const proxy&); // Not actually implemented
- private:
-    ref m_dict;
-    ref m_key;
-};
-
-struct list::proxy
-{
-    template <class T>
-    const ref& operator=(const T& rhs)
-        { return (*this) = make_ref(rhs); }
-    const ref& operator=(const ref& rhs);
-    
-    operator ref() const;
-    
- private:
-    friend class list;
-    proxy(const ref& list, std::size_t index);
-    
-    // This is needed to work around the very strange MSVC error report that the
-    // return type of the built-in operator= differs from that of the ones
-    // defined above. Couldn't hurt to make these un-assignable anyway, though.
-    const ref& operator=(const proxy&); // Not actually implemented
- private:
-    list m_list;
-    std::size_t m_index;
-};
-
-struct list::slice_proxy
-{
-    const list& operator=(const list& rhs);
-    operator ref() const;
-    operator list() const;
-    std::size_t size();
-    ref operator[](std::size_t pos) const;
- private:
-    friend class list;
-    slice_proxy(const ref& list, int low, int high);
- private:
-    ref m_list;
-    int m_low, m_high;
-};
-
-}} // namespace boost::python
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-
-PyObject* to_python(const boost::python::tuple&);
-boost::python::tuple from_python(PyObject* p, boost::python::type<boost::python::tuple>);
-
-inline boost::python::tuple from_python(PyObject* p, boost::python::type<const boost::python::tuple&>)
-{
-    return from_python(p, boost::python::type<boost::python::tuple>());
-}
-
-PyObject* to_python(const boost::python::list&);
-boost::python::list from_python(PyObject* p, boost::python::type<boost::python::list>);
-
-inline boost::python::list from_python(PyObject* p, boost::python::type<const boost::python::list&>)
-{
-    return from_python(p, boost::python::type<boost::python::list>());
-}
-
-PyObject* to_python(const boost::python::string&);
-boost::python::string from_python(PyObject* p, boost::python::type<boost::python::string>);
-
-inline boost::python::string from_python(PyObject* p, boost::python::type<const boost::python::string&>)
-{
-    return from_python(p, boost::python::type<boost::python::string>());
-}
-
-PyObject* to_python(const boost::python::dictionary&);
-boost::python::dictionary from_python(PyObject* p, boost::python::type<boost::python::dictionary>);
-
-inline boost::python::dictionary from_python(PyObject* p, boost::python::type<const boost::python::dictionary&>)
-{
-    return from_python(p, boost::python::type<boost::python::dictionary>());
-}
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-#endif // OBJECTS_DWA051100_H_
diff --git a/include/boost/python/operators.hpp b/include/boost/python/operators.hpp
deleted file mode 100644
index 40400f47..00000000
--- a/include/boost/python/operators.hpp
+++ /dev/null
@@ -1,509 +0,0 @@
-#ifndef OPERATORS_UK112000_H_
-#define OPERATORS_UK112000_H_
-
-# include <boost/python/reference.hpp>
-# include <boost/python/detail/functions.hpp>
-
-// When STLport is used with native streams, _STL::ostringstream().str() is not
-// _STL::string, but std::string. This confuses to_python(), so we'll use
-// strstream instead. Also, GCC 2.95.2 doesn't have sstream.
-# if defined(__SGI_STL_PORT) ? __SGI_STL_OWN_IOSTREAMS : !defined(__GNUC__) || __GNUC__ > 2
-#  include <sstream>
-# else
-#  include <strstream>
-# endif
-
-namespace boost { namespace python {
-
-tuple standard_coerce(ref l, ref r);
-
-namespace detail {
-  
-  // helper class for automatic operand type detection
-  // during operator wrapping.
-  struct auto_operand {};
-}
-
-// Define operator ids that can be or'ed together
-// (boost::python::op_add | boost::python::op_sub | boost::python::op_mul).
-// This allows to wrap several operators in one line.
-enum operator_id
-{ 
-    op_add = 0x1, 
-    op_sub = 0x2, 
-    op_mul = 0x4, 
-    op_div = 0x8, 
-    op_mod = 0x10, 
-    op_divmod =0x20, 
-    op_pow = 0x40, 
-    op_lshift = 0x80, 
-    op_rshift = 0x100, 
-    op_and = 0x200, 
-    op_xor = 0x400, 
-    op_or = 0x800, 
-    op_neg = 0x1000, 
-    op_pos = 0x2000, 
-    op_abs = 0x4000, 
-    op_invert = 0x8000, 
-    op_int = 0x10000, 
-    op_long = 0x20000, 
-    op_float = 0x40000, 
-    op_str = 0x80000,
-    op_cmp = 0x100000 
-};
-
-// Wrap the operators given by "which". Usage:
-//   foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub)>());
-template <long which, class operand = boost::python::detail::auto_operand>
-struct operators {};
-
-// Wrap heterogeneous operators with given left operand type. Usage:
-//   foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub)>(),
-//                 boost::python::left_operand<int>());
-template <class T>
-struct left_operand {};
-
-// Wrap heterogeneous operators with given right operand type. Usage:
-//   foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub)>(),
-//                 boost::python::right_operand<int>());
-template <class T>
-struct right_operand {};
-
-namespace detail
-{
-  template <class Specified>
-  struct operand_select
-  {
-      template <class wrapped_type>
-      struct wrapped
-      {
-          typedef Specified type;
-      };
-  };
-
-  template <>
-  struct operand_select<auto_operand>
-  {
-      template <class wrapped_type>
-      struct wrapped
-      {
-          typedef const wrapped_type& type;
-      };
-  };
-
-  template <long> struct define_operator;
-
-  // Base class which grants access to extension_class_base::add_method() to its derived classes
-  struct add_operator_base
-  {
-   protected:
-      static inline void add_method(extension_class_base* target, function* method, const char* name)
-          { target->add_method(method, name); }
-  };
-
-//
-// choose_op, choose_unary_op, and choose_rop
-//
-// These templates use "poor man's partial specialization" to generate the
-// appropriate add_method() call (if any) for a given operator and argument set.
-//
-//  Usage:
-//      choose_op<(which & op_add)>::template args<left_t,right_t>::add(ext_class);
-// 
-// (see extension_class<>::def_operators() for more examples).
-//
-  template <long op_selector>
-  struct choose_op
-  {
-      template <class Left, class Right = Left>
-      struct args : add_operator_base
-      {
-          static inline void add(extension_class_base* target)
-          {
-              typedef define_operator<op_selector> def_op;
-              add_method(target,
-                         new typename def_op::template operator_function<Left, Right>(),
-                         def_op::name());
-          }
-
-      };
-  };
-
-  // specialization for 0 has no effect
-  template <>
-  struct choose_op<0>
-  {
-      template <class Left, class Right = Left>
-      struct args
-      {
-          static inline void add(extension_class_base*)
-          {
-          }
-
-      };
-  };
-  
-  template <long op_selector>
-  struct choose_unary_op
-  {
-      template <class Operand>
-      struct args : add_operator_base
-      {
-          static inline void add(extension_class_base* target)
-          {
-              typedef define_operator<op_selector> def_op;
-              add_method(target,
-                         new typename def_op::template operator_function<Operand>(),
-                         def_op::name());
-          }
-
-      };
-  };
-  
-  // specialization for 0 has no effect
-  template <>
-  struct choose_unary_op<0>
-  {
-      template <class Operand>
-      struct args
-      {
-          static inline void add(extension_class_base*)
-          {
-          }
-
-      };
-  };
-  
-  template <long op_selector>
-  struct choose_rop
-  {
-      template <class Left, class Right = Left>
-      struct args : add_operator_base
-      {
-          static inline void add(extension_class_base* target)
-          {
-              typedef define_operator<op_selector> def_op;
-              add_method(target,
-                         new typename def_op::template roperator_function<Right, Left>(),
-                         def_op::rname());
-          }
-
-      };
-  };
-  
-  // specialization for 0 has no effect
-  template <>
-  struct choose_rop<0>
-  {
-      template <class Left, class Right = Left>
-      struct args
-      {
-          static inline void add(extension_class_base*)
-          {
-          }
-
-      };
-  };
-
-
-// Fully specialize define_operator for all operators defined in operator_id above.
-// Every specialization defines one function object for normal operator calls and one
-// for operator calls with operands reversed ("__r*__" function variants).
-// Specializations for most operators follow a standard pattern: execute the expression
-// that uses the operator in question. This standard pattern is realized by the following 
-// macros so that the actual specialization can be done by just calling a macro.
-#define PY_DEFINE_BINARY_OPERATORS(id, oper)                                            \
-  template <>                                                                           \
-  struct define_operator<op_##id>                                                       \
-  {                                                                                     \
-      template <class Left, class Right = Left>                                         \
-      struct operator_function : function                                               \
-      {                                                                                 \
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const        \
-          {                                                                             \
-              tuple args(ref(arguments, ref::increment_count));                                 \
-                                                                                        \
-              return BOOST_PYTHON_CONVERSION::to_python(                                          \
-                  BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Left>()) oper      \
-                  BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Right>()));        \
-          }                                                                             \
-                                                                                        \
-          const char* description() const                                               \
-              { return "__" #id "__"; }                                                 \
-      };                                                                                \
-                                                                                        \
-      template <class Right, class Left>                                                \
-      struct roperator_function : function                                              \
-      {                                                                                 \
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const        \
-          {                                                                             \
-              tuple args(ref(arguments, ref::increment_count));                                 \
-                                                                                        \
-              return BOOST_PYTHON_CONVERSION::to_python(                                          \
-                  BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Left>()) oper      \
-                  BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Right>()));        \
-          }                                                                             \
-                                                                                        \
-          const char* description() const                                               \
-              { return "__r" #id "__"; }                                                \
-                                                                                        \
-      };                                                                                \
-                                                                                        \
-      static const char * name() { return "__" #id "__"; }                              \
-      static const char * rname() { return "__r" #id "__"; }                            \
-  }
-
-#define PY_DEFINE_UNARY_OPERATORS(id, oper) \
-  template <>                                                                                   \
-  struct define_operator<op_##id>                                                               \
-  {                                                                                             \
-      template <class operand>                                                                  \
-      struct operator_function : function                                                       \
-      {                                                                                         \
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const                \
-          {                                                                                     \
-              tuple args(ref(arguments, ref::increment_count));                                         \
-                                                                                                \
-              return BOOST_PYTHON_CONVERSION::to_python(                                                  \
-                  oper(BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<operand>())));        \
-          }                                                                                     \
-                                                                                                \
-          const char* description() const                                                       \
-              { return "__" #id "__"; }                                                         \
-      };                                                                                        \
-                                                                                                \
-      static const char * name() { return "__" #id "__"; }                                      \
-  }
-
-  PY_DEFINE_BINARY_OPERATORS(add, +);
-  PY_DEFINE_BINARY_OPERATORS(sub, -);
-  PY_DEFINE_BINARY_OPERATORS(mul, *);
-  PY_DEFINE_BINARY_OPERATORS(div, /);
-  PY_DEFINE_BINARY_OPERATORS(mod, %);
-  PY_DEFINE_BINARY_OPERATORS(lshift, <<);
-  PY_DEFINE_BINARY_OPERATORS(rshift, >>);
-  PY_DEFINE_BINARY_OPERATORS(and, &);
-  PY_DEFINE_BINARY_OPERATORS(xor, ^);
-  PY_DEFINE_BINARY_OPERATORS(or, |);
-
-  PY_DEFINE_UNARY_OPERATORS(neg, -);
-  PY_DEFINE_UNARY_OPERATORS(pos, +);
-  PY_DEFINE_UNARY_OPERATORS(abs, abs);
-  PY_DEFINE_UNARY_OPERATORS(invert, ~);
-  PY_DEFINE_UNARY_OPERATORS(int, long);
-  PY_DEFINE_UNARY_OPERATORS(long, PyLong_FromLong);
-  PY_DEFINE_UNARY_OPERATORS(float, double);
-
-#undef PY_DEFINE_BINARY_OPERATORS
-#undef PY_DEFINE_UNARY_OPERATORS
-
-// Some operators need special treatment, e.g. because there is no corresponding 
-// expression in C++. These are specialized manually.
-
-// pow(): Manual specialization needed because an error message is required if this 
-// function is called with three arguments. The "power modulo" operator is not  
-// supported by define_operator, but can be wrapped manually (see special.html).
-  template <>
-  struct define_operator<op_pow>
-  {
-      template <class Left, class Right = Left>
-      struct operator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-
-              if (args.size() == 3 && args[2]->ob_type != Py_None->ob_type)
-              {
-                  PyErr_SetString(PyExc_TypeError, "expected 2 arguments, got 3");
-                  throw argument_error();
-              }
-
-              return BOOST_PYTHON_CONVERSION::to_python(
-                  pow(BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Left>()),
-                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Right>()))); 
-          }
-
-          const char* description() const
-              { return "__pow__"; }
-
-      };
-
-      template <class Right, class Left>
-      struct roperator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-
-              if (args.size() == 3 && args[2]->ob_type != Py_None->ob_type)
-              {
-                  PyErr_SetString(PyExc_TypeError, "bad operand type(s) for pow()");
-                  throw argument_error();
-              }
-
-              return BOOST_PYTHON_CONVERSION::to_python(
-                  pow(BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Left>()),
-                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Right>()))); 
-          }
-
-          const char* description() const
-              { return "__rpow__"; }
-
-      };
-
-      static const char * name() { return "__pow__"; }
-      static const char * rname() { return "__rpow__"; }
-  };
-
-// divmod(): Manual specialization needed because we must actually call two operators and
-// return a tuple containing both results
-  template <>
-  struct define_operator<op_divmod>
-  {
-      template <class Left, class Right = Left>
-      struct operator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-              PyObject * res = PyTuple_New(2);
-
-              PyTuple_SET_ITEM(res, 0,
-                BOOST_PYTHON_CONVERSION::to_python(
-                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Left>()) /
-                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Right>()))); 
-              PyTuple_SET_ITEM(res, 1,
-                BOOST_PYTHON_CONVERSION::to_python(
-                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Left>()) %
-                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Right>())));
-
-              return res; 
-          }
-
-          const char* description() const
-              { return "__divmod__"; }
-
-      };
-
-      template <class Right, class Left>
-      struct roperator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-              PyObject * res = PyTuple_New(2);
-
-              PyTuple_SET_ITEM(res, 0,
-                BOOST_PYTHON_CONVERSION::to_python(
-                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Left>()) /
-                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Right>()))); 
-              PyTuple_SET_ITEM(res, 1,
-                BOOST_PYTHON_CONVERSION::to_python(
-                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Left>()) %
-                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Right>())));
-
-              return res; 
-          }
-
-          const char* description() const
-              { return "__rdivmod__"; }
-
-      };
-
-      static const char * name() { return "__divmod__"; }
-      static const char * rname() { return "__rdivmod__"; }
-  };
-
-// cmp(): Manual specialization needed because there is no three-way compare in C++.
-// It is implemented by two one-way comparisons with operators reversed in the second.
-  template <>
-  struct define_operator<op_cmp>
-  {
-      template <class Left, class Right = Left>
-      struct operator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-
-              return BOOST_PYTHON_CONVERSION::to_python(
-                  (BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Left>()) <
-                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Right>())) ?
-                       - 1 :
-                       (BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Right>()) <
-                       BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Left>())) ?
-                           1 :
-                           0) ; 
-          }
-
-          const char* description() const
-              { return "__cmp__"; }
-
-      };
-
-      template <class Right, class Left>
-      struct roperator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-
-              return BOOST_PYTHON_CONVERSION::to_python(
-                  (BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Left>()) <
-                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Right>())) ?
-                       - 1 :
-                       (BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Right>()) <
-                       BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Left>())) ?
-                           1 :
-                           0) ; 
-          }
-
-          const char* description() const
-              { return "__rcmp__"; }
-
-      };
-
-      static const char * name() { return "__cmp__"; }
-      static const char * rname() { return "__rcmp__"; }
-  };
-
-// str(): Manual specialization needed because the string conversion does not follow
-// the standard pattern relized by the macros.
-  template <>
-  struct define_operator<op_str>
-  {
-      template <class operand>
-      struct operator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject*) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-
-// When STLport is used with native streams, _STL::ostringstream().str() is not
-// _STL::string, but std::string.
-#if defined(__SGI_STL_PORT) ? __SGI_STL_OWN_IOSTREAMS : !defined(__GNUC__)
-              std::ostringstream s;
-              s << BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<operand>());
-              return BOOST_PYTHON_CONVERSION::to_python(s.str()); 
-#else
-              std::ostrstream s;
-              s << BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<operand>()) << char();
-              return BOOST_PYTHON_CONVERSION::to_python(const_cast<char const *>(s.str())); 
-#endif
-          }
-
-          const char* description() const
-              { return "__str__"; }
-
-      };
-
-      static const char * name() { return "__str__"; }
-  };
-
-
-} // namespace detail
-
-}} // namespace boost::python
-
-#endif /* OPERATORS_UK112000_H_ */
diff --git a/include/boost/python/reference.hpp b/include/boost/python/reference.hpp
deleted file mode 100644
index c633b9d7..00000000
--- a/include/boost/python/reference.hpp
+++ /dev/null
@@ -1,173 +0,0 @@
-//  (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 PYPTR_DWA050400_H_
-# define PYPTR_DWA050400_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/operators.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/detail/cast.hpp>
-# include <cassert>
-# include <boost/python/detail/signatures.hpp>
-# include <boost/python/errors.hpp>
-# include <boost/python/conversions.hpp>
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-
-template <class T, class Value, class Base>
-struct py_ptr_conversions : Base
-{
-    inline friend T from_python(PyObject* x, boost::python::type<const T&>)
-        { return T(boost::python::downcast<Value>(x).get(), T::increment_count); }
-
-    inline friend T from_python(PyObject* x, boost::python::type<T>)
-        { return T(boost::python::downcast<Value>(x).get(), T::increment_count); }
-    
-    inline friend PyObject* to_python(T x)
-        { return boost::python::as_object(x.release()); }
-    
-};
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-namespace boost { namespace python {
-
-BOOST_PYTHON_IMPORT_CONVERSION(py_ptr_conversions);
-
-template <class T>
-class reference
-	: public py_ptr_conversions<reference<T>, T,
-       boost::dereferenceable<reference<T>, T*> > // supplies op->
-{
-public:
-    typedef T value_type;
-    
-	reference(const reference& rhs)
-		: m_p(rhs.m_p)
-	{
-		Py_XINCREF(object());
-	}
-
-#if !defined(BOOST_MSVC6_OR_EARLIER)
-	template <class T2>
-	reference(const reference<T2>& rhs)
-		: m_p(rhs.object())
-	{
-		Py_XINCREF(object());
-	}
-#endif
-
-	reference() : m_p(0) {}
-    
-    // These are two ways of spelling the same thing, that we need to increment
-    // the reference count on the pointer when we're initialized.
-	enum increment_count_t { increment_count };
-
-    enum allow_null { null_ok };
-    
-    template <class T2>
-    explicit reference(T2* x)
-        : m_p(expect_non_null(x)) {}
-
-    template <class T2>
-    reference(T2* x, increment_count_t)
-        : m_p(expect_non_null(x)) { Py_INCREF(object()); }
-	
-    template <class T2>
-    reference(T2* x, allow_null)
-        : m_p(x) {}
-
-    template <class T2>
-    reference(T2* x, allow_null, increment_count_t)
-        : m_p(x) { Py_XINCREF(object()); }
-	
-    template <class T2>
-    reference(T2* x, increment_count_t, allow_null)
-        : m_p(x) { Py_XINCREF(object()); }
-	
-#if !defined(BOOST_MSVC6_OR_EARLIER)
-	template <class T2>
-	reference& operator=(const reference<T2>& rhs)
-	{
-		Py_XDECREF(object());
-		m_p = rhs.m_p;
-		Py_XINCREF(object());
-		return *this;
-	}
-#endif
-
-	reference& operator=(const reference& rhs)
-	{
-		Py_XINCREF(static_cast<PyObject*>(rhs.m_p));
-		Py_XDECREF(object());
-		m_p = rhs.m_p;
-		return *this;
-	}
-    
-	~reference()
-	{
-		Py_XDECREF(m_p);
-	}
-	
-	T& operator*() const { return *m_p; }
-    
-	T* get() const { return m_p; }
-
-	T* release()
-	{
-		T* p = m_p;
-		m_p = 0;
-		return p;
-	}
-
-    void reset()
-        { Py_XDECREF(m_p); m_p = 0; }
-    
-    template <class T2>
-    void reset(T2* x)
-        { Py_XDECREF(m_p); m_p = expect_non_null(x);}
-
-    template <class T2>
-    void reset(T2* x, increment_count_t)
-        { Py_XDECREF(m_p); m_p = expect_non_null(x); Py_INCREF(object()); }
-	
-    template <class T2>
-    void reset(T2* x, allow_null)
-        { Py_XDECREF(m_p); m_p = x;}
-
-    template <class T2>
-    void reset(T2* x, allow_null, increment_count_t)
-        { Py_XDECREF(m_p); m_p = x; Py_XINCREF(object()); }
-	
-    template <class T2>
-    void reset(T2* x, increment_count_t, allow_null)
-        { Py_XDECREF(m_p); m_p = x; Py_XINCREF(object()); }
-	
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-private:
-    template<typename Y> friend class shared_ptr;
-#endif
-
-    inline PyObject* object() const
-        { return as_object(m_p); }
-
-	T* m_p;
-};
-
-typedef reference<PyObject> ref;
-
-template <class T>
-ref make_ref(const T& x)
-{
-    return ref(to_python(x));
-}
-
-}} // namespace boost::python
-
-#endif // PYPTR_DWA050400_H_
diff --git a/build/bpl_static.dsp b/libs/python/build/bpl_static.dsp
similarity index 100%
rename from build/bpl_static.dsp
rename to libs/python/build/bpl_static.dsp
diff --git a/build/build.dsw b/libs/python/build/build.dsw
similarity index 100%
rename from build/build.dsw
rename to libs/python/build/build.dsw
diff --git a/build/build.opt b/libs/python/build/build.opt
similarity index 100%
rename from build/build.opt
rename to libs/python/build/build.opt
diff --git a/build/como.mak b/libs/python/build/como.mak
similarity index 100%
rename from build/como.mak
rename to libs/python/build/como.mak
diff --git a/build/example1/example1.dsp b/libs/python/build/example1/example1.dsp
similarity index 100%
rename from build/example1/example1.dsp
rename to libs/python/build/example1/example1.dsp
diff --git a/build/gcc.mak b/libs/python/build/gcc.mak
similarity index 100%
rename from build/gcc.mak
rename to libs/python/build/gcc.mak
diff --git a/build/rwgk1/rwgk1.dsp b/libs/python/build/rwgk1/rwgk1.dsp
similarity index 100%
rename from build/rwgk1/rwgk1.dsp
rename to libs/python/build/rwgk1/rwgk1.dsp
diff --git a/build/test/test.dsp b/libs/python/build/test/test.dsp
similarity index 100%
rename from build/test/test.dsp
rename to libs/python/build/test/test.dsp
diff --git a/build/tru64.mak b/libs/python/build/tru64.mak
similarity index 100%
rename from build/tru64.mak
rename to libs/python/build/tru64.mak
diff --git a/doc/building.html b/libs/python/doc/building.html
similarity index 100%
rename from doc/building.html
rename to libs/python/doc/building.html
diff --git a/doc/comparisons.html b/libs/python/doc/comparisons.html
similarity index 100%
rename from doc/comparisons.html
rename to libs/python/doc/comparisons.html
diff --git a/doc/data_structures.txt b/libs/python/doc/data_structures.txt
similarity index 100%
rename from doc/data_structures.txt
rename to libs/python/doc/data_structures.txt
diff --git a/doc/enums.html b/libs/python/doc/enums.html
similarity index 100%
rename from doc/enums.html
rename to libs/python/doc/enums.html
diff --git a/doc/example1.html b/libs/python/doc/example1.html
similarity index 100%
rename from doc/example1.html
rename to libs/python/doc/example1.html
diff --git a/doc/extending.html b/libs/python/doc/extending.html
similarity index 100%
rename from doc/extending.html
rename to libs/python/doc/extending.html
diff --git a/doc/index.html b/libs/python/doc/index.html
similarity index 100%
rename from doc/index.html
rename to libs/python/doc/index.html
diff --git a/doc/inheritance.html b/libs/python/doc/inheritance.html
similarity index 100%
rename from doc/inheritance.html
rename to libs/python/doc/inheritance.html
diff --git a/doc/overloading.html b/libs/python/doc/overloading.html
similarity index 100%
rename from doc/overloading.html
rename to libs/python/doc/overloading.html
diff --git a/doc/overriding.html b/libs/python/doc/overriding.html
similarity index 100%
rename from doc/overriding.html
rename to libs/python/doc/overriding.html
diff --git a/doc/pointers.html b/libs/python/doc/pointers.html
similarity index 100%
rename from doc/pointers.html
rename to libs/python/doc/pointers.html
diff --git a/doc/special.html b/libs/python/doc/special.html
similarity index 100%
rename from doc/special.html
rename to libs/python/doc/special.html
diff --git a/doc/template.html b/libs/python/doc/template.html
similarity index 100%
rename from doc/template.html
rename to libs/python/doc/template.html
diff --git a/doc/under-the-hood.html b/libs/python/doc/under-the-hood.html
similarity index 100%
rename from doc/under-the-hood.html
rename to libs/python/doc/under-the-hood.html
diff --git a/example/example1.cpp b/libs/python/example/example1.cpp
similarity index 100%
rename from example/example1.cpp
rename to libs/python/example/example1.cpp
diff --git a/example/rwgk1.cpp b/libs/python/example/rwgk1.cpp
similarity index 100%
rename from example/rwgk1.cpp
rename to libs/python/example/rwgk1.cpp
diff --git a/example/test_example1.py b/libs/python/example/test_example1.py
similarity index 100%
rename from example/test_example1.py
rename to libs/python/example/test_example1.py
diff --git a/example/test_rwgk1.py b/libs/python/example/test_rwgk1.py
similarity index 100%
rename from example/test_rwgk1.py
rename to libs/python/example/test_rwgk1.py
diff --git a/release_notes.txt b/libs/python/release_notes.txt
similarity index 100%
rename from release_notes.txt
rename to libs/python/release_notes.txt
diff --git a/src/classes.cpp b/libs/python/src/classes.cpp
similarity index 100%
rename from src/classes.cpp
rename to libs/python/src/classes.cpp
diff --git a/src/conversions.cpp b/libs/python/src/conversions.cpp
similarity index 100%
rename from src/conversions.cpp
rename to libs/python/src/conversions.cpp
diff --git a/src/extension_class.cpp b/libs/python/src/extension_class.cpp
similarity index 100%
rename from src/extension_class.cpp
rename to libs/python/src/extension_class.cpp
diff --git a/src/functions.cpp b/libs/python/src/functions.cpp
similarity index 100%
rename from src/functions.cpp
rename to libs/python/src/functions.cpp
diff --git a/src/gen_all.py b/libs/python/src/gen_all.py
similarity index 100%
rename from src/gen_all.py
rename to libs/python/src/gen_all.py
diff --git a/src/gen_callback.py b/libs/python/src/gen_callback.py
similarity index 100%
rename from src/gen_callback.py
rename to libs/python/src/gen_callback.py
diff --git a/src/gen_caller.py b/libs/python/src/gen_caller.py
similarity index 100%
rename from src/gen_caller.py
rename to libs/python/src/gen_caller.py
diff --git a/src/gen_extclass.py b/libs/python/src/gen_extclass.py
similarity index 100%
rename from src/gen_extclass.py
rename to libs/python/src/gen_extclass.py
diff --git a/src/gen_function.py b/libs/python/src/gen_function.py
similarity index 100%
rename from src/gen_function.py
rename to libs/python/src/gen_function.py
diff --git a/src/gen_init_function.py b/libs/python/src/gen_init_function.py
similarity index 100%
rename from src/gen_init_function.py
rename to libs/python/src/gen_init_function.py
diff --git a/src/gen_signatures.py b/libs/python/src/gen_signatures.py
similarity index 100%
rename from src/gen_signatures.py
rename to libs/python/src/gen_signatures.py
diff --git a/src/gen_singleton.py b/libs/python/src/gen_singleton.py
similarity index 100%
rename from src/gen_singleton.py
rename to libs/python/src/gen_singleton.py
diff --git a/src/init_function.cpp b/libs/python/src/init_function.cpp
similarity index 100%
rename from src/init_function.cpp
rename to libs/python/src/init_function.cpp
diff --git a/src/module_builder.cpp b/libs/python/src/module_builder.cpp
similarity index 100%
rename from src/module_builder.cpp
rename to libs/python/src/module_builder.cpp
diff --git a/src/objects.cpp b/libs/python/src/objects.cpp
similarity index 100%
rename from src/objects.cpp
rename to libs/python/src/objects.cpp
diff --git a/src/types.cpp b/libs/python/src/types.cpp
similarity index 100%
rename from src/types.cpp
rename to libs/python/src/types.cpp
diff --git a/test/comprehensive.cpp b/libs/python/test/comprehensive.cpp
similarity index 100%
rename from test/comprehensive.cpp
rename to libs/python/test/comprehensive.cpp
diff --git a/test/comprehensive.hpp b/libs/python/test/comprehensive.hpp
similarity index 100%
rename from test/comprehensive.hpp
rename to libs/python/test/comprehensive.hpp
diff --git a/test/comprehensive.py b/libs/python/test/comprehensive.py
similarity index 100%
rename from test/comprehensive.py
rename to libs/python/test/comprehensive.py
diff --git a/test/doctest.py b/libs/python/test/doctest.py
similarity index 100%
rename from test/doctest.py
rename to libs/python/test/doctest.py
diff --git a/todo.txt b/libs/python/todo.txt
similarity index 100%
rename from todo.txt
rename to libs/python/todo.txt